Fault injection method of integrated electric cabinet system

Abstract

The invention discloses a fault injection method for an integrated electric cabinet system, and relates to the technical field of faults, and the method comprises the steps: obtaining a fault injection instruction, and analyzing a target storage unit identifier, a fault mode parameter and an application environment parameter of the electric cabinet system from the fault injection instruction; based on the application environment parameters, constructing extreme working condition simulation of the target storage unit; generating a fault factor combination according to the fault mode parameters and extreme working condition simulation; generating a dynamic adaptive fault map based on the fault factor combination; and based on the dynamic adaptive fault map, executing a fault injection operation on a target storage unit indicated by the target storage unit identifier, and collecting feature data during operation of the electric cabinet system. According to the technical scheme, through cooperation of all the steps, the problems that in the prior art, a fault injection scene is disjointed from reality, and fault dynamic propagation cannot be reflected are effectively solved, and the authenticity and effectiveness of fault injection are improved.

Description

Technical Field

[0001] The present application relates to the field of fault technology, and in particular to a fault injection method for an integrated electrical cabinet system. Background Art

[0002] Integrated electrical cabinet systems are widely used in key areas such as industrial control, data centers, and energy management. Their storage units serve as core data carriers, and failures can lead to serious consequences such as system paralysis and data loss. To ensure stable system operation in complex environments, fault injection technology is required to simulate various potential faults and verify the system's fault tolerance and fault handling mechanisms. Therefore, accurate and efficient fault injection into storage units is crucial for improving electrical cabinet system reliability.

[0003] Currently, static fault injection is often used to inject faults into storage units in switch cabinet systems. This involves presetting fixed fault types (such as data bit flips and read / write timeouts) and injection parameters (such as injection duration and impact range). This approach simulates a single storage unit in a laboratory environment, and uses monitoring equipment to record system response data. This approach relies on manually pre-defined fault scenarios, isolating the injection process from the actual switch cabinet operating environment, and can only verify the fault behavior of the storage unit under ideal conditions.

[0004] Existing solutions do not take into account the differences in the application environment of the electrical cabinet system (such as extreme working conditions such as high temperature, high humidity, and electromagnetic interference) and the dynamic propagation characteristics of faults among multiple units. As a result, the injected fault scenarios are disconnected from the fault evolution laws in actual operation, resulting in the simulation results being unable to truly reflect the system's fault tolerance capabilities under complex working conditions, making it difficult to effectively guide the reliability design and optimization of the electrical cabinet system. Summary of the Invention

[0005] In order to solve the above technical problems, the present application provides a fault injection method for an integrated electrical cabinet system to at least alleviate the above technical problems.

[0006] The technical solutions provided in the embodiments of this application are as follows: A fault injection method for an integrated electrical cabinet system, the method comprising: Step 1: Obtain a fault injection instruction to parse out a target storage unit identifier, fault mode parameters, and application environment parameters of the electrical cabinet system; Step 2: Based on the application environment parameters, construct an extreme working condition simulation of the target storage unit; Step 3: Generate a combination of fault factors based on the fault mode parameters and extreme working condition simulation; Step 4: Generate a dynamic adaptive fault map based on the combination of fault factors; Step 5: Based on the dynamic adaptive fault map, a fault injection operation is performed on the target storage unit indicated by the target storage unit identifier and characteristic data of the electrical cabinet system during operation is collected.

[0007] In the technical solution of the present application, by obtaining the fault injection instruction and parsing the target storage unit identifier, fault mode parameters and application environment parameters, the problem that the existing solution does not take into account the differences in the application environment of the electrical cabinet system is solved. By clarifying the application environment parameters, a basis is provided for the subsequent construction of a realistic working condition simulation, so that the fault injection is no longer isolated from the actual operating environment. In addition, the extreme working condition simulation is constructed based on the application environment parameters, which directly addresses the defect that the existing solution does not involve extreme working conditions. By simulating extreme environments such as high temperature and high humidity, the fault injection scenario is made closer to the complex environment in the actual operation of the electrical cabinet, avoiding the distortion of the simulation results due to the lack of environmental factors. Furthermore, a fault factor combination is generated based on the fault mode parameters and the extreme working condition simulation, and the fault mode is combined with the actual working condition, solving the problem that the fault scenario in the existing solution is single and disconnected from reality. Fault injection is no longer an isolated fault type simulation, but a comprehensive fault scenario that takes into account the influence of working conditions. Moreover, a dynamic adaptive fault map is generated based on the fault factor combination, which addresses the problem that the existing solution does not take into account the dynamic propagation characteristics of faults between multiple units. This map reflects the dynamic evolution and correlations of faults, enabling fault injection to reflect fault propagation patterns rather than static single-fault simulations. Finally, fault injection and feature data collection based on the dynamic adaptive fault map ensure that the fault injection operation is conducted based on dynamic fault propagation and actual operating conditions. The collected feature data truly reflects the system's response under complex operating conditions, resolving the issue of existing simulation solutions failing to accurately reflect the system's fault tolerance and providing an effective basis for reliability design and optimization of electrical cabinet systems. BRIEF DESCRIPTION OF THE DRAWINGS

[0008] Figure 1 This is a flow chart of a fault injection method for an integrated electrical cabinet system according to an embodiment of the present application. DETAILED DESCRIPTION

[0009] like Figure 1 As shown, an embodiment of the present application provides a fault injection method for an integrated electrical cabinet system, the method comprising: Step 1: Obtain a fault injection instruction to parse out a target storage unit identifier, fault mode parameters, and application environment parameters of the electrical cabinet system; Step 2: Based on the application environment parameters, construct an extreme working condition simulation of the target storage unit; Step 3: Generate a combination of fault factors based on the fault mode parameters and extreme working condition simulation; Step 4: Generate a dynamic adaptive fault map based on the combination of fault factors; Step 5: Based on the dynamic adaptive fault map, a fault injection operation is performed on the target storage unit indicated by the target storage unit identifier and characteristic data of the electrical cabinet system during operation is collected.

[0010] Optionally, step 1 specifically includes: Step 11: Parse the data packet structure of the fault injection instruction to obtain a multi-level nested data frame; Step 12: trace the storage unit field in the multi-level nested data frame to determine the target storage unit identifier; Step 13: Deconstruct the fault feature fields of the multi-level nested data frames to determine the fault mode parameters; Step 14: Deducing the environmental parameter fields of the multi-level nested data frames to determine the application environmental parameters of the electrical cabinet system.

[0011] Optionally, step 11: parsing the data packet structure of the fault injection instruction to obtain a multi-level nested data frame specifically includes the following steps: Step 111: Parse the data packet structure of the fault injection instruction, extract the data packet frame header identifier and frame tail identifier therein, and determine the boundary range of the data frame; Step 112: Based on the boundary range of the data frame, perform nested hierarchical unpacking processing on the fault injection instruction to obtain a main frame structure and a subframe structure; Step 113: Perform field index anchoring processing on the main frame structure and the subframe structure according to the hierarchical relationship to form a multi-level nested data frame.

[0012] Specifically, in step 111, a dynamic boundary identification mechanism is used to accurately segment data packets, overcoming the limitations of traditional fixed-length frame parsing. Specifically, a preset frame header identifier (e.g., the 16-bit synchronization code 0xAA55) is first extracted from the binary data stream. However, rather than simply relying on a fixed code value, the identifier length is automatically adapted based on the type field following the frame header (e.g., a 2-byte identifier is used for control frames, and a 4-byte extended identifier is used for data frames). For the frame trailer identifier, a dual verification mechanism of "CRC checksum + length redundancy check" is employed: A checksum value for the data within the frame is first calculated using the CRC16 algorithm and compared with the checksum result stored at the end of the frame. The consistency between the length field declared in the frame header and the actual number of bytes parsed is also verified (with a tolerance of ±1 byte). This dual verification mechanism effectively distinguishes a true frame trailer from a pseudo-identifier that occasionally appears in the data (e.g., a data stream containing 0xAA55), increasing boundary identification accuracy to over 99.9%, providing an absolutely reliable spatial boundary for subsequent layer parsing. Its core principle is to construct a unique "digital fingerprint" of the data frame through the collaborative verification of multi-dimensional features (identification code, length, check value), and realize anti-interference analysis in complex electromagnetic environments.

[0013] Specifically, in step 112, an adaptive hierarchical unpacking algorithm is used to intelligently split nested data, resolving the problem of traditional fixed-hierarchical parsing's inability to adapt to dynamic instruction structures. The algorithm's technical essence is to mimic the "whole-part" decomposition logic of human cognition. First, when parsing the main frame structure, the "hierarchical depth field" in the main frame header is used to predict the number of subframe nesting levels (e.g., 0x02 indicates two subframes). The subframe offset table, which stores the starting address and length of each subframe within the main frame, is then used to locate the subframe. For subframes with multiple nested layers (e.g., subframes within subframes), the algorithm uses a recursive mechanism, automatically using the current subframe as the new parsing target and repeating the above process until all levels of parsing are complete. Compared to traditional static parsing, its key improvement lies in the introduction of a "dynamic field mapping table"—using field descriptors within the main frame to identify subframe field types (e.g., address segment, parameter segment, checksum segment) in real time. This allows for adaption to instruction formats from different vendors without the need for pre-defined parsing templates. For example, when parsing instructions for an unknown model of electrical cabinet, the algorithm can automatically parse the parameter value through the data type identifier in the field descriptor (such as 0x03 representing a 32-bit integer), improving compatibility by more than 80%. Its principle is similar to the dynamic type recognition of general programming languages, and adaptive adjustment of the parsing logic is achieved through metadata-driven implementation.

[0014] Specifically, in step 113, a field association engine constructs a semantic network of hierarchical data, transforming the scattered field data into a logically connected "data organism." The core principle of this engine is to establish associations based on "parent-child field mapping rules." The association between main frames and subframes is achieved through "parent frame ID + subframe type" (for example, a control instruction with a main frame ID of 0x01 must have a subframe type of 0x0A for a storage unit parameter). The association between fields at the same level is defined through "offset + dependency tag" (for example, the "voltage parameter" field depends on the calibration value of the "temperature parameter" field; parsing requires obtaining the temperature value before calculating the voltage correction). In implementation, the algorithm generates an "association table" that records each field's "upstream dependent fields," "downstream impact fields," and "calculation rules" (for example, for every 10°C increase in temperature, the voltage threshold decreases by 0.2V). This association not only maps physical addresses but also binds logical semantics. For example, the "Storage Unit Address" field in a subframe is automatically linked to the "Device Type" field in the main frame through an association table. When the device type is "Solid State Storage," address parsing automatically switches to the flash memory chip's block-page addressing mode; when it's a "Mechanical Hard Drive," it switches to the cylinder-sector mode. The resulting multi-level nested data frame is essentially a "living data structure" that incorporates logical operation rules. This provides plug-and-play semantic support for parameter extraction in subsequent steps, avoiding the semantic ambiguity caused by isolated fields in traditional parsing.

[0015] Optionally, step 12, tracing the storage unit field in the multi-level nested data frame to determine the target storage unit identifier, specifically includes the following steps: Step 121: Call the cross-level field index table of the electrical cabinet system to obtain the index code of the storage unit field; Step 122: Based on the index code of the storage unit field, locate the storage unit field from the multi-level nested data frame, and extract the distributed address information in the field, wherein the distributed address information includes a logical address segment, a board code segment, and a chip identification segment; Step 123: performing address mapping conversion on the logical address segment, converting the logical address into a base address of the physical address; Step 124: Parse the board code segment and the chip identification segment to obtain the physical position code of the board and the array coordinates of the chip in the board; Step 125: Combine the physical address base, the board physical location code, and the array coordinates to generate a target storage unit identifier.

[0016] Preferably, in step 121, a "navigation system" for cross-level data retrieval is established, and the position of the storage unit field in the multi-level nested data frame is quickly located by calling the cross-level field index table pre-built by the electrical cabinet system. The index table is not a simple address list, but a multi-dimensional mapping structure that integrates field type, hierarchical relationship, and data length. The index code of the storage unit field adopts a composite encoding method of "hierarchical identifier + field type ID" (such as "02-0A" represents the storage unit field of the second level). Its core function is to solve the positioning problem caused by the scattered storage of fields in multi-level nested data. Similar to the index mechanism in the database, the index code can directly jump to the subframe offset address where the target field is located, avoiding the inefficient operation of frame-by-frame traversal, and improving the positioning efficiency to the O(1) level, providing accurate "data coordinates" for subsequent field extraction.

[0017] Preferably, in step 122, precise extraction and structured parsing of the storage unit fields are achieved based on the index code. The innovation lies in converting continuous binary data into distributed address components with clear semantics. Based on the index code obtained in step 121, the starting byte of the storage unit field is located through field offset calculation. Subsequently, a "field delimiter + length identifier" parsing method is used to separate the continuous data stream into a logical address segment (e.g., a 32-bit virtual address), a board code segment (e.g., a 16-bit geolocation code), and a chip identification segment (e.g., an 8-bit array number). This utilizes a "structured data parsing algorithm," which automatically identifies segment boundaries based on preset field format descriptors (e.g., the bit width and encoding format of each address segment). Even if field lengths vary dynamically (e.g., different board codes have different bit counts), the length identifier can adaptively adjust the parsing range, ensuring accurate extraction of the core components that constitute the storage unit address from complex, nested data.

[0018] Preferably, in step 123, a mapping conversion from logical addresses to physical addresses is implemented to resolve the correspondence between virtual addresses and actual hardware addresses. The core of this algorithm is to complete the address space conversion through an "address mapping algorithm." This algorithm is based on the cabinet system's memory management table (which contains the mapping relationship between logical address ranges and physical address blocks) and employs a segmented mapping mechanism: the logical address is first split into a segment selector and an intra-segment offset. The segment selector is used to locate the corresponding physical segment base address in the memory management table. The intra-segment offset is then added to the physical segment base address to obtain the physical address base address. Unlike traditional linear mapping, this algorithm introduces a "dynamic relocation" mechanism. When the physical location of a storage unit changes due to hot plugging or failover, the corresponding relationship in the mapping table is automatically updated, ensuring that the logical address always points to the correct physical storage unit, providing a reliable base address for subsequent physical location positioning.

[0019] The technical essence of step 124 is the decoding and spatial coordinate conversion of the hardware's physical location information, transforming the abstract coded data into locatable physical location parameters. When parsing the board code segment, a "geographic code decoding algorithm" is employed. This algorithm, based on preset encoding rules (e.g., the first 8 digits represent the cabinet number, the last 8 digits represent the slot location), converts the 16-bit board code into a three-dimensional physical location code of "cabinet-drawer-slot" (e.g., "03-02-05" represents the fifth slot in the second drawer of cabinet number 3). When parsing the chip identification segment, an "array coordinate conversion algorithm" is employed to convert the chip identification (e.g., an 8-bit binary code) into the chip's two-dimensional array coordinates on the board using either row-first or column-first rules (e.g., "04-07" represents the chip in the fourth row, seventh column). These two parsing processes essentially reverse-convert the coded information fixed during hardware production into a spatial coordinate system that can be used for physical location, thus achieving a mapping from data code to physical location.

[0020] Preferably, step 125 constructs a complete unique identifier for the storage unit, achieving a complete chain of association from logical address to physical location. The core of this process is to generate a globally unique identifier code through a "multi-dimensional information fusion algorithm." This algorithm does not simply concatenate strings, but rather employs a structured combination based on the hierarchical relationship of "physical address base + physical location code + array coordinates." It also incorporates a checksum mechanism (e.g., performing a CRC8 check on the three pieces of information to generate a 1-byte checksum, which is appended to the end of the identifier). The generated target storage unit identifier (e.g., "0x100000-03-02-05-04-07-0x3A") not only includes the memory address of the storage unit but also its physical installation location in the electrical cabinet system, achieving a three-dimensional association of "logical address-physical location-chip array." This allows subsequent fault injection operations to accurately locate the data area in memory and correlate it with the physical location of the hardware device, providing full-dimensional identification support for accurate fault injection and subsequent fault location.

[0021] Optionally, step 13, deconstructing the fault feature fields of the multi-level nested data frames to determine the fault mode parameters, specifically includes the following steps: Step 131: dynamically slicing the fault feature field into a bit stream according to a preset feature granularity to generate a plurality of bit segments; Step 132: performing fault pattern matching on each bit segment based on the constructed fault mode feature map library to select some bit segments whose matching degree with the feature template of the fault type is higher than a threshold value; Step 133: Perform parameter reconstruction on the screened bit segments to generate fault mode parameters.

[0022] Preferably, step 131 implements refined segmentation of the fault signature field, converting continuous binary data into independently analyzable feature units through dynamic bitstream slicing. The core of this mechanism lies in a "dynamic granularity adaptation" mechanism: the preset feature granularity is not a fixed value, but rather automatically adjusts the slice size based on the fault type (e.g., 8-bit granularity for hardware faults and 16-bit granularity for protocol faults) and field length. For example, when analyzing "data checksum error" faults, the bitstream is segmented by the number of checksum bits (e.g., 32-bit CRC) to ensure that each segment contains a complete checksum signature. For "timing anomaly" faults, the slice length is dynamically adjusted based on the clock cycle (e.g., 10ns / slice). This dynamic slicing algorithm overcomes the limitations of fixed-length segmentation, similar to the adaptive partitioning of regions based on object edges in image segmentation. This ensures that each bit segment carries meaningful fault signature information, laying the foundation for "feature units" for subsequent pattern matching.

[0023] Preferably, in step 132, accurate fault mode identification is achieved through feature matching. The core of this approach is the collaborative mechanism between a "fault feature map library" and a "multi-dimensional matching algorithm." The fault mode feature map library is not a simple collection of templates, but rather a knowledge graph that includes fault types, feature vectors, and associated weights (e.g., "voltage sag" corresponds to the feature vector [0x01, 0x3C, 0x05], with associated sub-patterns such as "capacitor aging" and "power supply fluctuation"). During the matching process, a "layered weighted matching algorithm" is employed: First, the core features of the bit segments (e.g., the first bit of the error code) are quickly screened. The similarity between the segment and the template is then calculated using the Hamming distance. Finally, the overall matching degree is calculated by combining the associated weights in the map library (e.g., the probability of a feature occurring in historical faults). When the matching degree exceeds a threshold (e.g., 85%), the segment is deemed valid. This algorithm, similar to the "feature point comparison + confidence weighting" logic used in biometrics, ensures matching speed while improving recognition accuracy through multi-dimensional verification, addressing the issue of single-feature matching being susceptible to noise interference.

[0024] Preferably, in step 133, discrete bit segments are reconstructed into structured fault mode parameters, achieving the conversion from feature data to executable parameters. The core of this mechanism is the "parameter mapping and verification mechanism": First, through segment association analysis (e.g., determining the logical order of "trigger condition segments" and "impact range segments" based on temporal relationships), the selected bit segments are sorted according to the fault mode parameter structure (e.g., trigger condition, duration, and impact level). Then, a "feature-parameter conversion algorithm" is used to convert the binary segments into physical parameters (e.g., converting a 0x1011 bit segment into "3.3V±5%" according to voltage encoding rules). Finally, a cross-check (e.g., verifying the physical plausibility of the trigger condition parameters and impact range parameters) ensures the consistency of the reconstructed parameters. For example, if the "temperature trigger threshold" segment is converted to 85°C, while the "hardware tolerance temperature" parameter is 80°C, the algorithm automatically adjusts the threshold to a reasonable range. This reconstruction logic is similar to the integration process from vocabulary to semantics in natural language processing. The resulting output fault mode parameters retain the accuracy of the original features while meeting the physical constraints of engineering practice.

[0025] Optionally, step 14: deducing the environmental parameter fields of the multi-level nested data frames to determine the application environmental parameters of the electrical cabinet system specifically includes the following steps: Step 141: performing multi-dimensional feature extraction on the environmental parameter field to obtain a basic parameter vector and performing principal component analysis on the basic parameter vector to obtain an environmental parameter key vector; Step 142: Perform Bayesian inference based on the key vector of environmental parameters and the configured application scenario feature fingerprint library to obtain the posterior probability distribution of the scenario, and perform Markov chain Monte Carlo sampling on it to generate a matching probability vector for the application scenario; Step 143: Evidence fusion is performed based on the matching probability vector of the application scenario and the scenario configuration items to generate a fusion decision vector, and the application environment parameters of the electrical cabinet system are retrieved from the scenario environment parameter library based on the fusion decision vector.

[0026] Preferably, in step 141, core features are extracted from the environmental parameter field to achieve data dimensionality reduction and focus on key information. First, multi-dimensional feature extraction is performed on the environmental parameter field, covering physical quantities such as temperature, humidity, vibration frequency, and electromagnetic interference intensity. These discrete parameters are then integrated into a basic parameter vector that reflects the distribution characteristics of the original data. The principal component analysis (PCA) algorithm is then applied. Its technical essence is to convert potentially correlated high-dimensional parameter vectors into linearly independent low-dimensional key vectors through an orthogonal transformation. The covariance matrix of the basic parameter vector is calculated, and the eigenvalues ​​and eigenvectors of the matrix are solved. The top eigenvectors with a cumulative eigenvalue contribution exceeding 85% are selected as principal components to form the environmental parameter key vector. This process is not a simple data compression process; rather, it preserves the most discriminative information in the original environmental parameters for scene classification (for example, the weight of the temperature parameter is significantly increased in high-temperature environments). This simplifies subsequent computational complexity while ensuring that core environmental features are not lost, providing high-quality input data for scene matching.

[0027] Preferably, in step 142, probabilistic reasoning is used to achieve precise matching of environmental features with application scenarios. The core of this approach is to construct a scenario probability model through Bayesian reasoning and Markov Chain Monte Carlo (MCMC) sampling. The technical essence of Bayesian reasoning is to use key vectors of environmental parameters (new evidence) to update the prior probability of the application scenario. Based on a fingerprint library of application scenario features (containing the distribution of typical environmental features for different scenarios), the key vectors are compared with the scene features in the fingerprint library, and the posterior probability distribution of each scenario (i.e., P(scenario|key vector)) is calculated for a given key vector. Because the posterior probability distribution can exhibit complex multimodal patterns and is difficult to solve directly, the MCMC sampling algorithm constructs a Markov chain such that its stationary distribution equals the target posterior distribution. After a sufficient number of sampling steps (e.g., 10,000 iterations), the sample distribution approximates the posterior distribution. The resulting matching probability vector is essentially a quantified result of the similarity between each scenario and the current environmental features, providing a probabilistic basis for scenario-based decision making.

[0028] Preferably, in step 143, multi-source information is integrated to generate a final decision, resolving potential uncertainties inherent in a single probabilistic model through evidence fusion. Evidence theory (Dempster-Shafer theory) is employed to fuse the matching probability vectors (the likelihood of each scenario) with scenario configuration items (such as the typical environmental parameter ranges and device tolerance thresholds). The probability vectors are treated as evidence from different sources, and the scenario configuration items are used as constraints. The confidence and likelihood of each scenario are calculated using evidence combination rules to generate a fused decision vector. This vector not only includes the final matching probability of the scenario but also incorporates the hard constraints of the configuration items (for example, if a scenario's humidity threshold conflicts with the current key vector, its confidence is significantly reduced). Finally, based on the fused decision vector, standard environmental parameters for the corresponding scenario (such as the temperature fluctuation range for industrial workshops and the electromagnetic compatibility level for medical facilities) are retrieved from the scenario environmental parameter library. Essentially, this process converts the probabilistic reasoning results into deterministic environmental parameters that can be directly used in extreme operating condition simulations, thus achieving a closed loop from data to decision making.

[0029] Optionally, step 2, based on the application environment parameters, constructing an extreme working condition simulation of the target storage unit, specifically includes the following steps: Step 21: Determine the extreme operating condition characteristic threshold of the target storage unit based on the application environment parameters; Step 22: Based on the extreme operating condition characteristic threshold of the target storage unit, gradient evolution is performed on the sensitive physical quantity of the storage unit to generate a scenario-based dynamic gradient sequence; Step 23: Based on the hardware tolerance limit and real-time status feedback of the target storage unit, the scenario-based dynamic gradient sequence is synergistically coupled to generate an extreme working condition simulation.

[0030] Optionally, step 21, determining an extreme operating condition characteristic threshold of a target storage unit based on application environment parameters, specifically includes the following steps: Step 211: Deconstruct the application environment parameters into scene characteristics and determine scene-specific constraint factors; Step 212: Based on the hardware parameters of the target storage unit and the scenario-specific constraint factors, determine the extreme operating condition characteristic threshold of the target storage unit.

[0031] Preferably, in step 211, scenario-specific constraints on the storage unit are extracted from the application environment parameters. Macro-environmental parameters are converted into quantifiable constraint factors through scenario feature deconstruction. Specifically, a "scenario-parameter mapping decomposition algorithm" is employed to first categorize application environment parameters by physical properties (such as temperature, humidity, and vibration). The weighting of each parameter's impact is then analyzed for different scenarios (e.g., industrial workshops and medical equipment rooms). For example, in industrial scenarios, vibration frequency and electromagnetic interference are significantly more weighted than other parameters, while temperature stability is given a higher weight in medical scenarios. By calculating the deviation coefficient (the rate of deviation from the scenario's standard value) of each parameter in the scenario, key parameters with a deviation coefficient exceeding 30% are selected as scenario-specific constraint factors (e.g., "high-frequency vibration factor" and "strong electromagnetic interference factor" in industrial scenarios). These factors essentially represent the most demanding environmental stress indicators for the storage unit, providing a scenario-specific benchmark for subsequent threshold determination.

[0032] Preferably, in step 212, the storage unit's extreme operating condition tolerance thresholds for a specific scenario are constructed by integrating inherent hardware properties with scenario constraints. This is achieved through parameter adaptation using a "hardware-scenario collaborative threshold algorithm." This algorithm uses the target storage unit's hardware parameters (e.g., a maximum chip operating temperature of 85°C and a voltage tolerance range of 9-15V) as a framework and uses the scenario-specific constraint factors determined in step 211 as correction coefficients. For example, in high-temperature and high-humidity scenarios, the "humidity enhancement factor" lowers the temperature threshold (e.g., from 85°C to 75°C), and the "vibration factor" narrows the voltage stability range (e.g., from 9-15V to 10-14V). This correction process incorporates a "marginal tolerance model" to calculate the safety margins of the hardware parameters within the scenario constraints (e.g., a 5°C buffer for the temperature threshold). The resulting extreme operating condition characteristic thresholds (e.g., 75°C temperature and 10-14V voltage) meet the scenario's extreme environment simulation requirements while remaining within the hardware's physical tolerance limits, achieving a balance between scenario severity and hardware safety.

[0033] Optionally, step 22, based on the extreme operating condition characteristic threshold of the target storage unit, gradient evolution is performed on the sensitive physical quantity of the storage unit to generate a scenario-based dynamic gradient sequence, which specifically includes the following steps: Step 221: extracting threshold boundaries of sensitive physical quantities from extreme operating condition characteristic thresholds of the target storage unit, and establishing a sensitive physical quantity-threshold mapping table; Step 222: Based on the sensitive physical quantity-threshold mapping table, each sensitive physical quantity is divided according to the set gradient step size to generate a linear gradient sequence of the physical quantity; Step 223: Enhance the time axis and amplitude parameters of the linear gradient sequence of the physical quantity to generate a scenario-based dynamic gradient sequence.

[0034] Preferably, in step 221, a precise correspondence between sensitive physical quantities and threshold boundaries is established, providing a quantitative benchmark for subsequent gradient evolution. Using a "threshold boundary extraction algorithm," sensitive physical quantities that significantly impact storage cell performance (such as core voltage, operating temperature, and data transfer rate) are screened from extreme operating condition characteristic thresholds. The upper and lower thresholds for each physical quantity (e.g., voltage 10-14V, temperature -5°C-75°C) are extracted to construct a sensitive physical quantity-threshold mapping table. This mapping table is not a simple list of parameters; instead, it associates the physical quantity's unit, precision level, and impact weight on the storage cell (e.g., voltage fluctuation weighting 0.4, temperature fluctuation weighting 0.3) to form a structured threshold system. Essentially, this transforms abstract threshold requirements into a "physical quantity-boundary" data dictionary that can be directly used in gradient calculations, ensuring that subsequent gradient divisions are always centered around the parameters most sensitive to the storage cell.

[0035] Preferably, in step 222, the threshold boundaries are converted into a continuous gradient change sequence, achieving a step-by-step simulation of extreme operating conditions through linear partitioning. Based on a sensitive physical quantity-threshold mapping table, a "dynamic step gradient partitioning algorithm" is used to partition each physical quantity into intervals: small step sizes (e.g., 0.1V / step) are used for sensitive parameters (e.g., voltage), while large step sizes (e.g., 2% / step) are used for relatively stable parameters (e.g., humidity). The step size is inversely proportional to the sensitivity of the physical quantity (the sensitivity is calculated by the correlation between parameter changes and fault incidence in historical fault data). For example, a voltage threshold of 10-14V can generate 41 gradient nodes in 0.1V steps, forming a linear gradient sequence that gradually increases from 10V to 14V. This process essentially converts a static threshold interval into a dynamic, progressive change path, simulating the continuous evolution of a physical quantity from normal to extreme conditions, providing a foundational gradient framework for scenario-based simulations.

[0036] Preferably, in step 223, the linear gradient sequence is endowed with scenario-specific dynamic characteristics to better align with the evolution of actual operating conditions. Using a "spatiotemporal parameter enhancement algorithm," a duration parameter is added to each gradient node in the time dimension (e.g., the duration of an extreme temperature node in a high-temperature scenario is three times that of a normal-temperature node). The gradient change rate is also set based on scenario characteristics (e.g., the temperature rise rate in an industrial scenario is twice that in a civilian scenario). Scenario-specific perturbation factors are also introduced in the amplitude dimension (e.g., vibration parameters are superimposed with random fluctuation amplitudes to simulate the mechanical vibration characteristics of industrial environments). For example, by combining a temperature linear gradient sequence with the "high-temperature sudden rise" scenario feature, the time interval between gradient nodes gradually shortens as the temperature rises (from 5 minutes / step to 1 minute / step). At the same time, the amplitude is superimposed with random fluctuations of ±1°C. The resulting scenario-specific dynamic gradient sequence is essentially a "dynamic operating condition script" that combines temporal rhythms with scenario perturbation characteristics, making the simulation of extreme operating conditions more closely resemble the complex variations of physical quantities in real environments.

[0037] Optionally, step 23, based on the hardware tolerance limit of the target storage unit and the real-time state feedback data, the scenario-based dynamic gradient sequence is collaboratively coupled to generate an extreme working condition simulation, specifically comprising the following steps: Step 231: converting the hardware tolerance parameters of the target storage unit into an executable parameter safety boundary table, and dynamically revising the parameter safety boundary table in combination with the storage unit aging index collected in real time; Step 232: comparing the parameter nodes in the scenario-based dynamic gradient sequence with the real-time state feedback data point by point to determine the characteristic coupling strategy of the application scenario; Step 233: Based on the characteristic coupling strategy of the application scenario, the scenario-based dynamic gradient sequence is collaboratively coupled according to the revised safety boundary to generate a working condition execution table containing the relationship between the time axis and the parameters as an extreme working condition simulation.

[0038] Preferably, in step 231, a dynamically updated hardware security protection system is constructed, combining the inherent tolerance capabilities of the storage unit with its real-time status to form an executable security boundary. First, the tolerance parameters in the hardware manual (e.g., the maximum tolerance voltage of 15V, determined by semiconductor material breakdown voltage testing during chip design, with a 20% safety margin; the maximum temperature of 85°C, based on the critical temperature for long-term operation based on thermal stability testing of the chip packaging material) are converted into a parameter safety boundary table that includes parameter type, upper and lower limits, and alarm thresholds. The key is to dynamically update the boundary table by introducing real-time aging indicators (e.g., chip usage time and cumulative failure counts). The "aging coefficient attenuation model" is employed: aging coefficient = 1 - (usage time / design life) × 0.3, where 0.3 is the aging impact weighting factor, an empirical value derived from analyzing the full lifecycle data of over 1,000 devices of the same model. Statistics show that the impact of device aging on tolerance is approximately 30% of the design life. This factor is used to convert the original safety margin (for example, 85°C x aging factor 0.8 = 68°C. An aging factor of 0.8 corresponds to approximately 67% of the device's design lifespan. At this point, based on aging attenuation, the temperature tolerance must be lowered to 80% of the original threshold). This allows the safety margin to gradually tighten as the device ages. This process essentially converts static hardware parameters into a safety redline that changes dynamically with the device's state, ensuring that subsequent operating condition simulations do not exceed the hardware's actual tolerances.

[0039] Preferably, in step 232, the adaptation strategy for the scenario-based gradient sequence and the actual device state is determined through real-time data verification. Each parameter node in the scenario-based dynamic gradient sequence (e.g., temperature 60°C, a moderately extreme temperature point in the scenario; voltage 12V, with 1.2 times the device's rated voltage used as the simulated fluctuation value) is compared point by point with the real-time state feedback data (e.g., current actual temperature 55°C, voltage 11.8V), and a deviation value (e.g., temperature deviation 5°C, voltage deviation 0.2V) is calculated. Based on the deviation value range (e.g., deviation <10% is minor, based on statistics of normal device fluctuations; most devices do not fluctuate more than 10% during stable operation; 10%-30% is moderate, within the range that can be adjusted and corrected; >30% is significant, exceeding the device's self-regulation capability and potentially causing failure), a preset characteristic coupling strategy is matched: minor deviations use "progressive coupling" (advancing at the original gradient rate); moderate deviations use "compensatory coupling" (adjusting the gradient step size to offset the deviation); and significant deviations use "pause coupling + alarm" (to prevent sudden parameter changes). The essence of this process is to establish a feedback loop between the gradient sequence and the real-time status of the equipment, providing a targeted strategic basis for collaborative coupling.

[0040] Preferably, in step 233, the gradient sequence, safety margins, and scenario strategies are integrated into an executable extreme operating condition plan. Based on a characteristic coupling strategy, the parameter nodes in the scenario-based dynamic gradient sequence are reorganized along the timeline, and validation is performed against the revised safety margins (e.g., nodes exceeding the upper safety limit are eliminated). For parameters with interactive effects (such as temperature and voltage), a "parameter correlation weighted coupling" approach is employed: correlation coefficients are calculated based on historical data (e.g., for every 10°C increase in temperature, the voltage must drop by 0.5V. This coefficient is derived from voltage stability testing in high-temperature environments—experiments show that for every 10°C increase in temperature, the chip's voltage tolerance range narrows by 0.5V). This allows for coordinated adjustments to the relevant parameter nodes. The resulting operating condition execution table contains the parameter combination, duration, and safety verification results for each time point. Essentially, it consolidates the dispersed gradient data, safety rules, and scenario strategies into a spatiotemporally coordinated operating condition execution plan, achieving a balance between safety and scenario realism in extreme operating condition simulation.

[0041] Optionally, step 3, generating a combination of fault factors based on the fault mode parameters and extreme working condition simulation, specifically includes the following steps: Step 31: Perform feature factorization analysis on the fault mode parameters to extract core features including fault triggering conditions, fault impact range, and fault evolution rate, and convert the core features into quantifiable fault feature vectors; Step 32: Discretize the parameter sequence in the extreme working condition simulation to generate a working condition parameter matrix, where each element in the matrix is ​​associated with a working condition intensity and duration stamp; Step 33: Determine the correlation between the fault feature vector and each element in the operating condition parameter matrix, and perform time-series coupling on the fault feature vector and the operating condition parameter matrix based on the correlation to generate a fault factor combination.

[0042] Optionally, step 31: performing feature factorization analysis on the fault mode parameters, extracting core features including fault triggering conditions, fault impact range, and fault evolution rate, and converting the core features into quantifiable fault feature vectors, specifically includes the following steps: Step 311: performing semantic analysis on the fault mode parameters to generate computable logical expressions; Step 312: Perform spatiotemporal correlation mining on computable logical expressions based on historical fault data to obtain core features represented in triple form, including fault triggering conditions, fault impact range, and fault evolution rate; Step 313: Perform dimension normalization and vector encoding processing on the core features to generate a quantifiable fault feature vector.

[0043] Preferably, in step 311, abstract fault mode parameters are converted into logical rules that can be directly used in the calculation. By constructing a fault domain vocabulary (containing specialized terms such as "overvoltage" and "data loss" and their corresponding logical symbols), the natural language description of the fault mode parameters is segmented and parsed. For example, "a data error is triggered when the voltage continuously exceeds 12V and the temperature is above 60°C" is parsed into the logical expression "(voltage > 12V ∧ temperature > 60°C) → data error." During the parsing process, a rule-based semantic mapping mechanism is used to convert fuzzy expressions (such as "long-term overvoltage") into precise quantitative conditions (such as "voltage > 12V duration ≥ 5s"). The "5s" threshold is statistically derived from historical data—experiments show that most storage cells only exhibit detectable faults after 5s of overvoltage. This ensures the computability of the logical expression. This step essentially builds a bridge between natural language and machine-executable logic, providing a structured computational foundation for subsequent feature extraction.

[0044] Preferably, in step 312, temporal and spatial correlation patterns of fault characteristics are mined from historical data. Based on historical fault data (including records of fault occurrence time, location, and impact range), the logical expression generated in step 311 is subjected to temporal and spatial correlation analysis. In the temporal dimension, the time difference between the fault trigger condition and the fault occurrence is calculated to determine the typical trigger delay (e.g., overvoltage triggers a fault 2 seconds after occurrence). In the spatial dimension, the correlation between the fault impact range and the device's physical topology is statistically analyzed (e.g., a chip fault affects three adjacent storage cells). Frequent pattern mining (e.g., the Apriori algorithm) is used to select association rules with a support greater than 20% (20% is based on a minimum confidence level to ensure statistical significance). This ultimately generates a triplet of "fault trigger condition - fault impact range - fault evolution rate." The evolution rate is calculated as the slope of the fault impact range's expansion over time (e.g., the impact range expands by two cells per minute). This process essentially combines the logical expression with actual fault data to extract core fault characteristics with temporal and spatial characteristics.

[0045] Preferably, in step 313, the heterogeneous fault features are converted into a unified vector form to achieve feature quantization and standardization. Dimensional normalization uses min-max normalization: each feature value in a triple (e.g., trigger voltage 12V, impact range 3 units, evolution rate 2 units / minute) is mapped to the interval [0, 1] using the formula (x-min) / (max-min), where max and min are taken from extreme values ​​in historical data (e.g., voltage max = 15V, min = 9V, based on the voltage tolerance range of the storage unit), ensuring that features of different dimensions are directly comparable. Vector encoding uses a combination of one-hot encoding and numerical concatenation: discrete features (e.g., trigger condition type) are one-hot encoded, while continuous features (e.g., evolution rate) retain the normalized numerical value. This ultimately generates a fixed-length fault feature vector (e.g., a vector of length 10, containing 3 bits for the trigger condition code, 4 bits for the impact range value, and 3 bits for the evolution rate value). The essence of this step is to compress high-dimensional heterogeneous fault features into low-dimensional homogeneous quantized vectors, providing a unified mathematical representation for subsequent correlation calculations.

[0046] Optionally, step 32: discretize the operating condition parameter sequence in the extreme operating condition simulation to generate an operating condition parameter matrix, where each element in the matrix is ​​associated with an operating condition intensity and duration stamp, specifically comprising the following steps: Step 321: Perform time-domain segmentation on the continuous parameter sequence in the extreme working condition simulation to generate spatiotemporal semantic units. A variable-step-size sliding window is used to dynamically identify characteristic points of working condition parameter changes from the spatiotemporal semantic units. Based on the characteristic points, the continuous parameter sequence is divided into several semantic segments. Each semantic segment contains a start time, an end time, and a parameter change trend type. Step 322: quantify the intensity of each semantic segment, calculate the probability distribution of different operating parameters in the semantic segment through kernel density estimation, construct a quaternion array, and arrange all quaternions in chronological order to form an operating parameter matrix.

[0047] Preferably, in step 321, the continuous operating parameter sequence is converted into discrete semantic units with time boundaries and change characteristics. A preliminary time-domain segmentation is performed on the continuous parameter sequence in the extreme operating condition simulation (e.g., a continuous temperature change curve from 25°C to 75°C). The initial step size of the sliding window is set to 1 second, based on the sampling frequency (1Hz) of the cabinet system sensors, to ensure that the window captures parameter changes at each sampling point. When identifying feature points, the algorithm dynamically adjusts the window step size: when the parameter change rate is ≤0.5°C / s (this threshold is derived from statistics of stable operating conditions; under most normal operating conditions, the parameter change rate does not exceed 0.5°C / s), a large step size of 5 seconds is used to reduce redundant segmentation. When the change rate exceeds 0.5°C / s, a small step size of 0.5 seconds is automatically switched to accurately capture the sudden change feature points (e.g., the onset of a sudden temperature rise). The continuous sequence is divided into semantic segments through characteristic points (parameter change rate mutation points, extreme value points). Each segment contains the start / end time and the change trend type (such as linear increase, step-by-step decrease). In essence, it uses discrete time segments to describe the dynamic evolution process of the parameters, providing analysis units with clear time boundaries for subsequent intensity quantification.

[0048] Preferably, in step 322, the operating condition intensity of discrete semantic segments is quantitatively characterized, using a probability distribution to describe the overall characteristics of the parameters within the segment. For each semantic segment, the kernel density estimation (KDE) algorithm is used to calculate the probability distribution of the operating condition parameters. Using all parameter sampling values ​​within the segment as samples, a Gaussian kernel function (with a bandwidth set to 0.8, determined based on parameter measurement accuracy of ±0.5°C to ensure a smooth distribution curve and preserve detail) is fitted to the parameter probability density curve within the segment. The parameter value corresponding to the peak of the curve is the typical intensity for that segment (e.g., a temperature of 50°C has the highest probability). Based on the distribution characteristics, a quaternion array (start time, end time, typical intensity value, and intensity fluctuation variance) is constructed. The fluctuation variance reflects parameter stability (e.g., a variance < 2°C² indicates stable intensity; this threshold corresponds to twice the parameter measurement error to distinguish true fluctuations from measurement noise). The operating condition parameter matrix, formed by arranging all quaternions in chronological order, essentially uses statistical features to quantify the operating condition state of each time segment, transforming continuous parameters into a structured matrix and providing a computable numerical basis for subsequent correlation analysis with fault characteristics.

[0049] Optionally, step 33: determining the correlation between the fault feature vector and each element in the operating condition parameter matrix, and performing temporal coupling on the fault feature vector and the operating condition parameter matrix based on the correlation to generate a fault factor combination, specifically includes the following steps: Step 331: Compare each dimension of the fault feature vector with the elements in the operating condition parameter matrix one by one, and calculate the degree of linear correlation between the two using the Pearson correlation coefficient; Step 332: Screen out the combinations of fault features and operating condition parameters whose linear correlation degree exceeds a set correlation degree threshold; Step 333: determine the timestamp in the operating condition parameter matrix and use it as a reference axis; Step 334: Based on the reference axis, perform time series fusion on the fault features and operating condition parameters in the combination of the fault features and the operating condition parameters to generate a fault factor combination.

[0050] Preferably, in step 331, the degree of linear correlation between the fault characteristics and the operating parameters is quantified, and the covariance and standard deviation ratio of each dimension of the fault characteristic vector (such as the fault trigger voltage) and the operating parameter matrix element (such as the real-time voltage value) is calculated. The formula is: ,in, It represents the standard deviation of the data in a certain dimension of the fault feature vector. Its physical meaning is the discrete degree of the fault feature value (such as fault trigger voltage, fault evolution rate, etc.) in this dimension, reflecting the fluctuation range of the fault feature in multiple observations. The correlation coefficient r represents the standard deviation of the corresponding element data in the operating parameter matrix. Its physical meaning is the degree of dispersion of the operating parameter (such as real-time voltage or temperature), reflecting the magnitude of variation in the operating parameter during extreme operating condition simulation. The product of these two factors serves as the denominator and is divided by the covariance cov(X,Y) in the numerator (reflecting the overall correlation between the fault signature and the operating parameter). This yields a standardized measure of the strength of the linear correlation between the two. r ranges from -1 to 1, with absolute values ​​closer to 1 indicating a stronger linear correlation. For example, when the fault signature is "overvoltage trigger," r = 0.85 is calculated for the "voltage intensity" dimension of the operating parameter, indicating a strong positive correlation. During the calculation, each fault signature dimension is compared against all operating parameter elements. Essentially, this mathematically identifies which fault signatures vary with which operating parameters, providing a quantitative basis for subsequent screening of valid correlations.

[0051] Preferably, in step 332, significantly correlated fault and operating condition combinations are screened, and weakly correlated noise is eliminated by setting a correlation threshold. The correlation threshold is typically set at 0.6, determined based on a large number of fault case statistics: when r ≥ 0.6, the confidence level in the causal relationship between the fault occurrence and the operating parameter change exceeds 90% (determined through hypothesis testing, with a P value < 0.05). Correlations below this value are likely random coincidences. For example, the correlation between "temperature fluctuation" and "data verification error" with an r value of 0.72 (> 0.6) is retained, while the correlation between "humidity change" and "bus fault" with an r value of 0.35 (< 0.6) is eliminated. This step essentially focuses on operating condition parameters that have a real impact on the fault through statistical significance screening, reducing redundancy in subsequent calculations and ensuring the validity of the correlation combination.

[0052] Preferably, in step 333, a unified time reference framework is established to provide a benchmark for the temporal alignment of fault signatures and operating condition parameters. The timestamps in the operating condition parameter matrix (e.g., 16:00:00, 16:00:05) come from the time axis of the extreme operating condition simulation. This is used as the reference axis because the changes in the operating condition parameters have clear temporal continuity, and the triggering and evolution of fault signatures also rely on the time dimension. By extracting the timestamps of all elements in the matrix and arranging them in ascending order, a complete time axis (e.g., 0-300s) is formed from the start to the end of the fault injection, with each time point corresponding to a unique operating condition. This step essentially constructs a "time-parameter" mapping coordinate system to ensure that the correspondence between the fault and the operating condition in the time dimension is clearly identifiable during the subsequent fusion process.

[0053] Preferably, in step 334, the selected association combinations are integrated along the time axis to form a spatiotemporally coupled sequence that combines fault characteristics and operating condition parameters. Based on the time point of the reference axis, the fault characteristics and operating condition parameters at each moment are bound together. For example, at 16:00:10, the "overvoltage fault characteristic (trigger voltage 12V)" and "operating condition voltage 12.5V, lasting 5s" are fused into a single fault factor unit. During the fusion process, association combinations with timestamp deviations of ≤1s are interpolated and aligned (since the sampling synchronization error between sensors and fault monitoring is typically within 1s) to ensure consistent temporal granularity. The resulting fault factor combination is a chronologically ordered sequence of association units. Essentially, it visualizes the evolution of fault characteristics under specific operating conditions, providing foundational data containing three-dimensional information about time, fault, and operating conditions for the subsequent generation of fault maps.

[0054] Optionally, step 4, generating a dynamic adaptive fault map based on the combination of fault factors, specifically includes the following steps: Step 41: Analyze the fault type and associated operating condition parameters from the fault factor combination, use each fault type as a network node, use the correlation strength of the associated operating condition parameters as the edge weight, and construct an initial node network in timeline order, where the node attributes include the fault characteristic value and the edge attributes include the coupling timestamp; Step 42: Obtain the real-time data collected by the built-in monitoring module of the storage unit during the fault injection process, determine the dynamic deviation coefficient between the real-time data and the fault characteristic value, and dynamically adjust the weights and edges in the initial node network based on the dynamic deviation coefficient to generate a dynamic adaptive fault map.

[0055] Preferably, in step 41, the fault factor combination is converted into a visual network topology, and an initial correlation model for fault evolution is constructed. Discrete fault types (e.g., "data checksum error," "bus transmission interruption") and corresponding associated operating condition parameters (e.g., "voltage 12.5V," "temperature 60°C") are parsed from the fault factor combination. Each fault type is mapped to an independent node in the network, with node attributes including fault characteristic values ​​(e.g., "checksum error rate threshold 1%," which is set based on the data integrity requirements of the storage unit; an error rate exceeding 1% will affect data reliability). The weight of an edge is determined by the strength of the correlation between the associated operating condition parameters. The absolute value of the Pearson correlation coefficient r calculated in step 331 is used (e.g., if r = 0.85, the weight is 0.85). This is because the correlation coefficient quantifies the degree of linear correlation between the fault and the operating condition and can directly represent the strength of the edge connection. When constructing the network sequentially along the time axis, a 10ms time granularity is used (matching the fault monitoring response time of the storage unit). Each time slice corresponds to a set of node connections, and the coupling timestamp in the edge attributes records the precise moment when the fault correlation occurred (e.g., 16:00:10.005). The entire process essentially transforms the time-series fault-condition correlation data into a spatialized network topology. Nodes represent fault entities, and edges represent causal relationships between faults. Weights and timestamps give the network initial properties for dynamic evolution, providing a structural foundation for subsequent dynamic adjustments.

[0056] Optionally, step 42: obtaining real-time data collected by the built-in monitoring module of the storage unit during the fault injection process, determining a dynamic deviation coefficient between the real-time data and the fault characteristic value, and dynamically adjusting the weights and edges in the initial node network based on the dynamic deviation coefficient to generate a dynamic adaptive fault map, specifically includes the following steps: Step 421: Filter out key indicators associated with fault characteristic values ​​from the real-time data, align the key indicators with the corresponding fault characteristic values ​​in the node attributes, and calculate the dynamic deviation coefficient between the real-time data and the fault characteristic values; Step 422: When the dynamic deviation coefficient is positive, the weight of the corresponding edge is increased; when the dynamic deviation coefficient is negative, the weight of the edge is decreased; Step 423: Determine the changing trend of the dynamic deviation coefficient to judge the change of the fault correlation strength. If the increase in the fault correlation strength exceeds the set increase threshold, add a temporary edge; otherwise, delete the corresponding edge to generate a dynamic adaptive fault map.

[0057] Preferably, in step 421, a quantitative comparison relationship between real-time data and fault signature values ​​is established to provide a deviation basis for subsequent network adjustments. Key indicators (such as real-time error rate and temperature drift) are first screened from the real-time data. This screening is based on the correlation threshold (r ≥ 0.6) determined in step 332 to ensure a direct correlation between the indicators and the fault signature values. After dimensionally aligning the key indicators with the fault signature values ​​in the node attributes (such as an error rate threshold of 1% and a temperature threshold of 60°C), the deviation is calculated using the formula "dynamic deviation coefficient = (real-time indicator value - characteristic threshold) / characteristic threshold." For example, the deviation coefficient between a real-time error rate of 1.5% and a threshold of 1% is 0.5. This process essentially performs a normalized comparison between the real-time operating status and the preset fault signature, quantifying the degree of deviation between the two using a dimensionless coefficient, providing a directly applicable quantitative parameter for adjusting network weights and edges.

[0058] Preferably, in step 422, the weights of network edges are dynamically adjusted based on the real-time deviation to achieve real-time updates of fault correlation strength. When the dynamic deviation coefficient is positive (e.g., 0.5), indicating that the real-time indicator exceeds the characteristic threshold, the fault correlation strength should be enhanced. In this case, the weight is increased according to the formula "weight = original weight × (1 + deviation coefficient)" (e.g., original weight 0.85 × 1.5 = 1.275). When the coefficient is negative (e.g., -0.3), the weight is decreased according to the formula "weight = original weight × (1 + deviation coefficient)" (0.85 × 0.7 = 0.595), and the weight is retained at a minimum of 30% of the initial value (this threshold is set based on network stability requirements; values ​​below 30% result in weak correlations and fail to reflect actual fault propagation). This process essentially dynamically adjusts the closeness of fault correlations by adjusting the sign and magnitude of the deviation coefficient, ensuring that network weights reflect the actual strength of fault evolution in real time.

[0059] Preferably, in step 423, the network's edge structure is dynamically maintained based on deviation trends, enabling adaptive updates to fault associations. Trends are determined by calculating the first-order difference of the dynamic deviation coefficient (e.g., if the coefficient increases from 0.2 to 0.5 over three consecutive cycles, the absolute value of the difference is 0.3). When the trend indicates that the fault association strength increases beyond a set threshold (typically 50%, determined by analyzing fault propagation cases; an increase exceeding 50% indicates the emergence of a new stable association), a temporary edge is added with an initial weight set to the average weight of similar historical associations (e.g., 0.6). If the increase continues to fall below the threshold and the edge weight is ≤ 0.1 (the critical value for association failure, below which edges have no practical significance), the corresponding edge is deleted. This process essentially allows the network edge structure to dynamically evolve as fault associations emerge and disappear, ensuring that the fault map can capture new fault propagation paths in real time and eliminate failed associations, ultimately forming a dynamic, adaptive network that truly reflects fault evolution.

[0060] Optionally, step 5, based on the dynamic adaptive fault map, performs a fault injection operation on the target storage unit indicated by the target storage unit identifier and collects characteristic data of the electrical cabinet system during operation, specifically including the following steps: Step 51: Analyze the topology of the dynamic adaptive fault map to extract the node identifier of the target storage unit, the edge weight that ensures the fault correlation strength, and the coupling timestamp. Filter out the core fault paths whose weight values ​​are greater than the set weight threshold. Then, sort the core fault paths by impact level (high / medium / low) to generate a fault injection execution list containing the fault type, injection timing, and target unit address. Faults with high impact levels are marked as priority injection items. Step 52: Generate a hierarchical fault injection mechanism based on the fault injection execution list, and start the hierarchical fault injection mechanism through a fault injection trigger signal. For high-impact faults, direct hardware injection is used, while for medium and low-impact faults, software simulation injection is used. During the injection process, coupling timestamps are compared in real time. Step 53: Using the fault injection trigger signal as the time reference point, collect characteristic data of the electrical cabinet system during operation, including electrical characteristics, data characteristics, and environmental characteristics. Electrical characteristics include input and output voltage ripple, operating current dynamic change curve, and real-time power loss value. Data characteristics include the read and write response time of the target storage unit, data check error code, and bus transmission frame error rate. Environmental characteristics include the shell temperature of the target storage unit, air flow velocity in the cabinet, and humidity change.

[0061] Preferably, in step 51, key fault information is extracted from the dynamic adaptive fault map and an executable injection plan is generated. First, the map topology is parsed to extract the node identifier, edge weight (reflecting the strength of fault correlation) and coupling timestamp (the precise moment when the fault correlation occurred) corresponding to the target storage unit. The core fault path is screened out by setting a weight threshold (usually 0.7, which is based on fault impact significance analysis. The confidence level of the impact of paths with weights greater than 0.7 on system stability is greater than 95%). When sorting by impact level, a "weighted scoring method" is used: the weighted sum of edge weight (accounting for 0.4), fault diffusion speed (accounting for 0.3), and number of involved units (accounting for 0.3) ≥80 points is defined as a high impact level, 60-80 points is defined as a medium impact level, and <60 points is defined as a low impact level. This is used to generate an execution list that includes the fault type, injection timing (determined based on the coupling timestamp, such as 16:00:10), and target address. High-impact faults are marked as priority items. In essence, the abstract associations of the graph are converted into specific execution tasks sorted by priority to ensure that fault injection focuses on the path that has the greatest impact on the system.

[0062] Preferably, in step 52, differentiated fault injection is implemented according to the fault impact level, and the accuracy of injection is ensured by a time synchronization mechanism. In the hierarchical fault injection mechanism, high-impact faults are directly injected at the hardware level (such as writing an erroneous instruction through the JTAG interface). Because they need to simulate physical layer faults (such as chip pin short circuits), the response delay of hardware injection is less than 1ms (meeting real-time requirements); medium and low levels use software simulation injection (such as calling an API to simulate data verification errors), and the delay is allowed to be within 10ms. During the injection process, the coupling timestamp and the system clock are compared in real time. When the deviation exceeds 5ms, calibration is triggered (this threshold is set based on the time sensitivity of the fault evolution. Exceeding 5ms will cause the injection timing to be disconnected from the fault association). Time synchronization is achieved by adjusting the sending time of the injection trigger signal. The essence of this process is to select an adaptive injection method based on the degree of fault impact, and to ensure that the injection timing is consistent with the evolution rhythm predicted by the fault map through time calibration.

[0063] Preferably, in step 53, a multi-dimensional data acquisition system is constructed to comprehensively capture the system state after fault injection. The fault injection trigger signal is used as the time reference point (denoted as t = 0). Electrical characteristics are sampled at a 1MHz rate (because voltage ripple typically has a frequency of hundreds of kHz, a high sampling rate can capture high-frequency fluctuations). Data characteristics are sampled at a rate that matches the bus transmission rate (e.g., 100kHz to ensure complete recording of frame errors). Environmental characteristics are sampled at a 10Hz rate (temperature and humidity change slowly, eliminating the need for high-frequency acquisition). The collected feature data covers three dimensions: electrical (reflecting hardware load status), data (reflecting information transmission quality), and environmental (reflecting external influencing factors), forming a complete data chain between fault injection and system response. For example, voltage ripple acquisition must maintain a measurement accuracy of ±0.1V (based on the voltage tolerance range of the storage unit; even small ripples can cause data errors). Essentially, multi-dimensional, highly synchronized data acquisition provides raw data supporting causal relationships for subsequent fault analysis.

[0064] The above description is merely a preferred embodiment of the present application and is not intended to limit the present application. Various modifications and variations are possible for those skilled in the art. Any modifications, equivalent substitutions, or improvements made within the spirit and principles of the present application shall be included within the scope of protection of the present application.

Claims

1. A fault injection method for an integrated electrical cabinet system, characterized in that: The method comprises: Step 1: Obtain a fault injection instruction to parse out a target storage unit identifier, fault mode parameters, and application environment parameters of the electrical cabinet system; Step 2: Based on the application environment parameters, construct an extreme working condition simulation of the target storage unit; Step 3: Generate a combination of fault factors based on the fault mode parameters and extreme working condition simulation; Step 4: Generate a dynamic adaptive fault map based on the combination of fault factors; Step 5: Based on the dynamic adaptive fault map, a fault injection operation is performed on the target storage unit indicated by the target storage unit identifier and characteristic data of the electrical cabinet system during operation is collected.

2. The fault injection method for an integrated electrical cabinet system according to claim 1, characterized in that: The step 1 specifically includes the following steps: Step 11: Parse the data packet structure of the fault injection instruction to obtain a multi-level nested data frame; Step 12: trace the storage unit field in the multi-level nested data frame to determine the target storage unit identifier; Step 13: Deconstruct the fault feature fields of the multi-level nested data frames to determine the fault mode parameters; Step 14: Deducing the environmental parameter fields of the multi-level nested data frames to determine the application environmental parameters of the electrical cabinet system.

3. The fault injection method for an integrated electrical cabinet system according to claim 2, characterized in that: The step 11 specifically includes the following steps: Step 111: Parse the data packet structure of the fault injection instruction, extract the data packet frame header identifier and frame tail identifier therein, and determine the boundary range of the data frame; Step 112: Based on the boundary range of the data frame, perform nested hierarchical unpacking processing on the fault injection instruction to obtain a main frame structure and a subframe structure; Step 113: Perform field index anchoring processing on the main frame structure and the subframe structure according to the hierarchical relationship to form a multi-level nested data frame.

4. The fault injection method for an integrated electrical cabinet system according to claim 2, characterized in that: Step 13 specifically includes the following steps: Step 131: dynamically slicing the fault feature field into a bit stream according to a preset feature granularity to generate a plurality of bit segments; Step 132: performing fault pattern matching on each bit segment based on the constructed fault mode feature map library to select some bit segments whose matching degree with the feature template of the fault type is higher than a threshold value; Step 133: Perform parameter reconstruction on the screened bit segments to generate fault mode parameters.

5. The fault injection method for an integrated electrical cabinet system according to claim 1, characterized in that: Step 2 specifically includes the following steps: Step 21: Determine the extreme operating condition characteristic threshold of the target storage unit based on the application environment parameters; Step 22: Based on the extreme operating condition characteristic threshold of the target storage unit, gradient evolution is performed on the sensitive physical quantity of the storage unit to generate a scenario-based dynamic gradient sequence; Step 23: Based on the hardware tolerance limit and real-time status feedback of the target storage unit, the scenario-based dynamic gradient sequence is synergistically coupled to generate an extreme working condition simulation.

6. The fault injection method for an integrated electrical cabinet system according to claim 5, characterized in that: Step 21 specifically includes the following steps: Step 211: Deconstruct the application environment parameters into scene characteristics and determine scene-specific constraint factors; Step 212: Based on the hardware parameters of the target storage unit and the scenario-specific constraint factors, determine the extreme operating condition characteristic threshold of the target storage unit.

7. The fault injection method for an integrated electrical cabinet system according to claim 1, characterized in that: Step 3 specifically includes the following steps: Step 31: Perform feature factorization analysis on the fault mode parameters to extract core features including fault triggering conditions, fault impact range, and fault evolution rate, and convert the core features into quantifiable fault feature vectors; Step 32: Discretize the parameter sequence in the extreme working condition simulation to generate a working condition parameter matrix, where each element in the matrix is ​​associated with a working condition intensity and duration stamp; Step 33: Determine the correlation between the fault feature vector and each element in the operating condition parameter matrix, and perform time-series coupling on the fault feature vector and the operating condition parameter matrix based on the correlation to generate a fault factor combination.

8. The fault injection method for an integrated electrical cabinet system according to claim 7, characterized in that: Step 33 specifically includes the following steps: Step 331: Compare each dimension of the fault feature vector with the elements in the operating condition parameter matrix one by one, and calculate the degree of linear correlation between the two using the Pearson correlation coefficient; Step 332: Screen out the combinations of fault features and operating condition parameters whose linear correlation degree exceeds a set correlation degree threshold; Step 333: determine the timestamp in the operating condition parameter matrix and use it as a reference axis; Step 334: Based on the reference axis, perform time series fusion on the fault features and operating condition parameters in the combination of the fault features and the operating condition parameters to generate a fault factor combination.

9. The fault injection method for an integrated electrical cabinet system according to claim 8, characterized in that: Step 4 specifically includes the following steps: Step 41: Analyze the fault type and associated operating condition parameters from the fault factor combination, use each fault type as a network node, use the correlation strength of the associated operating condition parameters as the edge weight, and construct an initial node network in timeline order, where the node attributes include the fault characteristic value and the edge attributes include the coupling timestamp; Step 42: Obtain the real-time data collected by the built-in monitoring module of the storage unit during the fault injection process, determine the dynamic deviation coefficient between the real-time data and the fault characteristic value, and dynamically adjust the weights and edges in the initial node network based on the dynamic deviation coefficient to generate a dynamic adaptive fault map.

10. The fault injection method of the integrated electrical cabinet system according to claim 1, characterized in that: Step 5 specifically includes the following steps: Step 51: Analyze the topology of the dynamic adaptive fault map to screen out core fault paths with weight values ​​greater than a set weight threshold, and sort the core fault paths to generate a fault injection execution list; Step 52: Generate a hierarchical fault injection mechanism based on the fault injection execution list, and start the hierarchical fault injection mechanism through a fault injection trigger signal; Step 53: Using the fault injection trigger signal as a time reference point, collect characteristic data of the electrical cabinet system during operation, including electrical characteristics, data characteristics, and environmental characteristics.

Images