Spaceflight control event time slot solving and sequence time length filling method

Abstract

The application provides a spaceflight control event time slot solving and sequence length filling method, comprising: a time slot solving stage: after synthesizing a legal time interval, three-stage degradation solving is performed: a first stage of two-part anchoring expected time, hit, output; fail to enter the second stage of shunt solving; fail again to bottom out with a default time, ensuring that a single event will eventually have a solution output; write a degradation identifier after solving is completed; a sequence length filling stage: the difference between the event length and the fixed length is used as the remaining length to be allocated, and the weight is backfilled to the spring command. After consistency verification, a backfill identifier is written, and finally the time slot and command sequence with double identifiers are output. The application solves at least one of the technical problems in the prior art, such as single event non-classified rollback solving mechanism, low expected time retrieval efficiency and easy misjudgment of no solution, uncontrollable key point combination verification performance, command template cannot be reused across tasks, and solving result has no traceable identifier.

Description

Technical Field

[0001] This invention relates to the technical field of aerospace telemetry and flight control, and in particular to a method for solving time slots and filling sequence durations for aerospace flight control events. Background Technology

[0002] Aerospace telemetry, tracking, and command (TT&C) and flight control mission planning requires solving time slots for each flight control event. These time slots must simultaneously satisfy four types of constraints: available interval, key point offset, resource availability, and duration. Existing technologies have the following shortcomings: Pipeline-based simulations only verify the overall command chain, failing to autonomously solve time slots under multiple constraints for a single event, and lacking a tiered rollback mechanism; failure to solve a single event terminates the entire planning process. Global mathematical programming optimization methods are designed for other scenarios and are ill-suited for aerospace discrete dynamic constraints, lacking fallback logic for single-event solutions. Static instruction expansion schemes on general low-code platforms use fixed instruction durations; changes to event duration constraints at higher levels require manual adjustment of template durations, and templates cannot be reused across missions.

[0003] Furthermore, the existing flight control event time slot solution architecture has several shortcomings at the underlying logic level: it adopts a single-level, non-backoff solution logic, and if a single constraint has no solution, all planning tasks are interrupted; for the user's expected time, it only uses linear traversal to retrieve the key point sequence, which has low retrieval efficiency, and directly determines that there is no solution when the expected time deviates from the available range; when processing key point constraints, it first enumerates all Cartesian product combinations and then performs resource checks, resulting in a large number of invalid combinations causing computational redundancy, which can easily lead to combinatorial explosion and performance loss of control; the solution results lack degradation path markings, downstream modules cannot distinguish between regular solutions and fallback solutions, and the reliability of the results cannot be audited and traced.

[0004] Meanwhile, aerospace engineering has the business characteristics of "stable command sequence structure and dynamic change of event duration," which traditional command filling mechanisms cannot adapt to. Traditional solutions lack spring-loaded command placeholders and automatic weight allocation logic, requiring manual reallocation of command durations after event duration updates. They also lack a complete process for fixed duration accumulation, remaining duration judgment, and backfill consistency verification, failing to intercept abnormal operating conditions where the fixed total duration exceeds the limit, and easily outputting illegal command sequences. Furthermore, they do not set a backfill status Boolean flag, making it impossible for downstream systems to identify whether duration adaptation has taken effect, and lacking the traceability basis required for differentiated review and risk alarms. Summary of the Invention

[0005] The purpose of this invention is to provide a method for solving time slots and filling sequence durations for aerospace flight control events, which solves at least one of the following technical problems in existing aerospace flight control mission planning schemes: lack of hierarchical backoff mechanism for single events, low efficiency of expected time retrieval and easy misjudgment of no solution, uncontrollable performance of key point combination verification, inability to reuse instruction templates across missions, and lack of traceability identification for solution results.

[0006] To solve the above-mentioned technical problems, the technical solution of the present invention is as follows: This invention provides a method for solving time slots and filling sequence durations for aerospace flight control events, including: Steps for solving time slots: Step S1: Calculate and output the set of legal time intervals based on the available and restricted intervals of flight control events; Step S2: Perform a three-level degradation solution and output a time slot containing the event duration. The three-level degradation solution includes, in sequence, a first-level expected time bisection anchoring, a second-level branch solution, and a third-level default time fallback. If the event is configured with an expected time, the first level is executed. If the first level fails or the event is not configured with an expected time, the second level is executed. If the second level fails, the third level is executed and the default time configured for the event is output as the solution. The second level is divided into two mutually exclusive branches for solving based on whether the event contains key point constraints. Step S3: After completing the three-level degradation solution, write the degradation identifier to clarify which level of path the solution comes from; Sequence duration padding steps: Step S4: Scan the instruction sequence to identify variable duration placeholder instruction nodes with spring prefixes, and record their position index and weight parameters; Step S5: Traverse all non-spring instructions in the sequence and sum them according to their type to obtain the fixed duration. Step S6: The difference between the event duration and the sum of the fixed durations is taken as the remaining duration to be allocated, and then filled back into each spring instruction according to the weight ratio of each spring instruction. Step S7: Perform a consistency check on the backfilled instruction sequence. If the check passes, write a backfill success flag; otherwise, write a backfill failure flag and retain the original placeholder. Step S8: Output the event time slot carrying the degradation flag and the instruction sequence carrying the backfill flag.

[0007] Furthermore, in step S1, the set of legal time intervals is obtained by performing arc intersection operations on each available interval and the restricted interval of the event.

[0008] Furthermore, in step S2, the first-level expected time bisection anchoring includes: using the expected time as the key to perform bisection positioning on the candidate time series of key points, taking the intersection of the candidate times with the set of legal time intervals in sequence along the preset search direction, performing resource sufficiency checks and checks that the duration is not less than the event duration, and outputting the first candidate time that passes all of them as the solution; the search direction includes forward, backward or bidirectional.

[0009] Furthermore, in step S2, the second level is solved by dividing the event into two mutually exclusive branches based on whether the event contains key point constraints. Specifically, this includes: No critical branch: Perform a linear scan of sub-intervals for each valid time interval, check for resource sufficiency and whether the duration is greater than or equal to the event duration, and return if a match is found; Keypoint Branch: Generate a set of available time points for each keypoint within each valid time interval. Generate time combinations by performing a Cartesian product on the set of available time points for each keypoint. For each combination, first perform a validity check that the time of adjacent keypoints increases and the interval is not less than the minimum offset. After the check passes, backtrack from the first keypoint to deduce the start time of the event and perform resource checks. Output the first combination that passes all checks as the second-level solution.

[0010] Furthermore, in step S4, the spring prefix is ​​a placeholder mark used to identify non-static command duration, and spring command nodes and non-spring command nodes are distinguished by identifying the spring prefix.

[0011] Furthermore, in step S5, the instruction types include sequential merge and bound merge, wherein sequential merge type instructions contribute to the mainline offset and their duration is included in the sum of the fixed durations; bound merge type instructions do not contribute to the mainline offset and their duration is not included in the sum of the fixed durations.

[0012] Furthermore, if the difference between the event duration and the sum of the fixed duration is negative, or if there is no spring instruction in the instruction sequence, then backfilling will not be performed and a backfilling failure flag will be written directly.

[0013] Furthermore, in step S6, the spring instructions are backfilled according to their weight ratios. Specifically, this includes: obtaining the weight parameters of each spring instruction, calculating the proportion of the weight parameters of each spring instruction in the total weight parameters of all spring instructions, and multiplying the proportion by the remaining time to be allocated as the backfilling time of the corresponding spring instruction.

[0014] Furthermore, in step S7, the consistency verification includes: re-accumulating the total duration of the instruction sequence after backfilling, comparing it with the event duration, and if the difference is within a preset threshold, the verification passes; otherwise, the verification fails.

[0015] Furthermore, in step S8, the downgrade flag is a Boolean flag, which indicates that the solution comes from the third-level default time fallback when the value is true, and that the solution comes from the first or second level when the value is false; the backfill flag is a Boolean flag, which indicates that the backfill is successful when the value is true, and that the backfill fails when the value is false.

[0016] Compared with the prior art, the present invention has at least the following beneficial effects: (1) Robustness improvement: The success rate of single-event solution is improved by a three-level degradation and rollback solution mechanism, overcoming the shortcomings of existing methods that only use single-level solution, directly determine no solution when the expected time deviates from the first available interval, and cause the overall planning to terminate when a single point fails; (2) High efficiency of expected time anchoring: The binary positioning mechanism is used to retrieve candidate time series of key points, which optimizes the O(n) search complexity of linear traversal to O(log n), greatly shortening the computation time of the expected time matching stage; (3) Effective key point combination pruning: Before resource occupation check, a lightweight pre-check of the legality of adjacent key point intervals is added to screen out a large number of invalid time combinations in advance, effectively suppressing the performance degradation problem caused by Cartesian product combination explosion; (4) The instruction template can be reused across tasks: Relying on the remaining time filling mechanism of spring instruction and weight ratio allocation, when the upper layer re-constrains the event duration, the duration of each instruction in the instruction sequence can be automatically adapted and adjusted without manual modification of the instruction template, which greatly speeds up the efficiency of task planning and deployment in aerospace engineering scenarios. (5) Results are traceable: Double Boolean identifiers are set to mark the solution degradation path and the spring command backfill status respectively. The downstream processing module can accurately identify the generation source and credibility of each result, supporting full-process auditing, differentiated review, and alarm processing. Attached Figure Description

[0017] To more clearly illustrate the specific embodiments of the present invention or the technical solutions in the prior art, the drawings used in the description of the specific embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are some embodiments of the present invention. For those skilled in the art, other drawings can be obtained from these drawings without creative effort.

[0018] Figure 1 A combined diagram of aerospace flight control event time slot solution and sequence duration filling method and system; Figure 2 A flowchart illustrating the specific methods for solving time slots and filling sequence durations in aerospace flight control events. Detailed Implementation

[0019] To make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, the technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0020] (I) Various Implementation Examples This embodiment provides a method for solving time slots and filling sequence durations for aerospace flight control events. Please refer to [the relevant documentation]. Figure 1-2As shown, this embodiment further defines the overall framework of the method, which is divided into two sequential stages: time slot solving and sequence duration filling. In the time slot solving stage, a set of valid time intervals is first synthesized, and then solved level by level through a three-level degradation mechanism of "expected time anchoring, branch solving, and default time fallback." Expected time anchoring is only executed when an expected time is configured for the event; if no expected time is configured or the previous level fails, it automatically proceeds to the next level. After the solution is completed, a degradation flag is written. In the sequence duration filling stage, spring placeholder instructions in the template are first identified, and the fixed instruction duration is accumulated. Then, the difference between the event duration and the fixed duration is backfilled into the spring instructions according to the weight. After consistency verification, a backfill flag is written, and finally, the event time slots with double flags and the complete instruction sequence are output synchronously. This scheme constructs a hierarchical fallback capability at the single-event level, avoiding the termination of the overall planning due to a single point of failure. It also achieves dynamic adaptation of the instruction template with the event duration and full path traceability, significantly improving the robustness, reusability, and auditability of task planning.

[0021] This embodiment further defines the specific method for synthesizing legal time intervals. Specifically, it involves performing arc intersection operations on each available interval generated from station visibility and energy forecasts, along with the event's own time-constrained interval, to obtain the final set of legal intervals. This step narrows the search range of candidate times before all solutions are initiated, filtering physically unreachable time segments in one go. This avoids subsequent solvers performing resource checks and constraint verifications on invalid time points, reducing invalid computations at the source and improving overall solution efficiency.

[0022] This embodiment further defines the implementation method of the first-level expected time binary anchoring: For events carrying expected times, binary positioning is performed on the candidate time series of key points arranged in ascending order using these as keys. After obtaining the nearest neighbor index, the interval legality, resource sufficiency, and duration satisfaction of each candidate time are verified one by one according to the preset search direction (forward, backward, or bidirectional). The first candidate that passes all constraints is the first-level solution; if all scans fail, the next level of solution is triggered. This mechanism reduces the search complexity of candidate times from linear O(n) to logarithmic O(log n), prioritizing the matching of user expected times while ensuring retrieval efficiency and avoiding direct determination of no solution when the expected time deviates from the first available interval.

[0023] This embodiment further defines two mutually exclusive paths for solving the second-level branch: When there are no keypoint constraints, it directly linearly scans each valid sub-interval and verifies resource and duration conditions; if a match is found, it returns. When there are keypoint constraints, it first generates a set of available time points for each keypoint within the valid interval. After generating all time combinations through Cartesian product, it first performs a lightweight check to prune invalid combinations beforehand, ensuring that "adjacent keypoint times are strictly increasing and the interval is not less than the minimum offset." Then, it reverse-engineers the event start time for the remaining combinations and performs resource checks, outputting the first valid solution. This design balances the simplicity and efficiency of scenarios without keypoints with performance control in scenarios with keypoints. The low-overhead pre-check significantly reduces the number of combinations entering high-overhead resource checks, effectively curbing the performance degradation caused by Cartesian product combination explosion.

[0024] This embodiment further defines the identification criteria for spring commands: by adding a uniform "spring prefix" mark to variable-duration placeholder commands in the command template, identifying this prefix during the duration filling stage can accurately distinguish between spring commands (variable-duration placeholder nodes) and non-spring commands (fixed-duration nodes). This identification method is simple and intuitive, compatible with existing command template editing habits in the aerospace field, and requires no modification to the overall template structure. Engineers can flexibly specify command nodes with duration scaling capabilities, providing a foundation for the accurate allocation of subsequent remaining duration.

[0025] This embodiment further defines the classification rules for fixed-duration accumulation: instructions are divided into two categories: sequential merging and bound merging. Sequential merging instructions are executed serially along the main timeline, and their entire duration is included in the fixed-duration sum. Bound merging instructions are executed in parallel with or embedded in the main timeline and do not contribute to the main timeline offset; they are excluded during accumulation. This classification mechanism ensures that the calculated fixed-duration sum accurately reflects the actual serial time consumption of the main event timeline, avoids distortion in the calculation of remaining unallocated time due to miscalculation of parallel instruction duration, and guarantees the accuracy of spring instruction backfill duration.

[0026] This embodiment further defines the exception handling rules for negative remaining duration: when the event duration is less than the sum of fixed instruction durations, the remaining duration to be allocated is negative, or there is no spring instruction in the instruction sequence, the spring instruction backfilling process is skipped directly, a backfilling failure flag is written, and the original placeholder is retained. This protection mechanism can avoid performing meaningless calculations in invalid scenarios where the fixed duration has exceeded the event duration, prevent the generation of unexecutable error instruction sequences, and allow downstream modules or manual intervention to handle exceptions, thereby enhancing the method's exception tolerance and overall robustness.

[0027] This embodiment further defines the allocation rules for the remaining time: the remaining time to be allocated is obtained by subtracting the sum of fixed durations from the event duration; the weight of each spring instruction is calculated as a proportion of the total weight of all spring instructions; and the remaining time is allocated to the corresponding spring instruction according to this proportion. This algorithm ensures that the total duration of the sequence after backfilling strictly matches the event duration, and also supports flexible adjustment of the duration scaling of different instructions by adjusting the weight parameters. This allows the same instruction template to adapt to task scenarios with different total durations without the need for manual reallocation of instruction durations, significantly improving the template's cross-task reuse capability.

[0028] This embodiment further defines the implementation method of backfill consistency verification: after completing the spring instruction duration backfill, the actual total duration of the entire instruction sequence is re-accumulated and compared with the event duration. If the difference is within a preset threshold, the backfill is considered successful and a success flag is written; otherwise, it is considered a failure. This mechanism, as the final verification line for duration filling, can quantitatively verify the accuracy of the backfill result, promptly intercept erroneous durations, prevent instruction sequences carrying erroneous durations from flowing into downstream execution stages, and improve the reliability of project deployment.

[0029] This embodiment further defines the specific form and meaning of the dual identifiers: the downgrade identifier is a Boolean type, indicating whether the time slot comes from the third-level default time fallback; the backfill identifier is a Boolean type, indicating whether the instruction sequence has been effectively backfilled. The dual identifiers are used independently and in combination, allowing downstream conflict detection, audit execution, and other modules to accurately identify the generation path of each result. Differential processing strategies such as alarms, automatic recalculation, and manual review are adopted for fallback solutions and backfill failure results. This solves the problems of untraceable solution paths and indistinguishable result reliability in traditional methods, supporting full-process auditing and hierarchical control.

[0030] (II) Specific Implementation 1. Detailed description of the technical solution of the present invention 1.1 Application Scenarios This invention is applied to mission planning scenarios in the field of aerospace telemetry, tracking, and command (TT&C) / flight control. In this scenario, an event is the basic scheduling unit for mission planning. Each event must satisfy three types of constraints: "start time belongs to the union of several available intervals", "optional key point offset relationship", and "resource occupancy compatibility". After the event is solved, it is further expanded into a sequence of one or more instructions (Dictates). The total duration of the sequence is given by the event solution result. Within the sequence, "spring instructions" of variable duration are allowed to take place to absorb changes in the total mission duration.

[0031] The core of this invention is to introduce a hierarchical processing flow with explicit marking in the two stages of "time slot solving" and "instruction sequence duration filling", so that the whole method is robust at the single event level and the instruction template can be reused without modification between different event durations.

[0032] 1.2 Module Function Description (e.g.) Figure 1 (As shown) The valid time interval synthesis module (M1) is responsible for finding the intersection of arc segments between each available interval and the event's restricted interval (denoted as the phaseAnd operation), and outputting the set of valid time intervals LP. Its function is to ensure that candidate times fall within physically reachable arc segments before all subsequent solutions begin.

[0033] Level 1 Expected Time Anchoring Module (M2): Enabled when the event configuration includes an expected time T_d. It performs binary search on the candidate time series of key points using T_d as the key to obtain the nearest candidate index. It then scans the first candidate that satisfies all constraints according to the user-configured search direction (forward / backward / bidirectional); if all fail, it backtracks to the next level.

[0034] The second-level branch solution module (M3) is divided into two mutually exclusive branches based on whether the event contains keypoint constraints: No key branch: For each valid time interval, linearly scan the sub-interval, perform resource sufficiency checks and checks whether the duration is greater than or equal to the event duration, and return if a match is found; Including key point branches: First, generate a set of available time points for each key point within each valid time interval. Then, generate time combinations by performing a Cartesian product on each key point set. For each combination, first perform a lightweight validity check that "adjacent key point times are strictly increasing and the intervals are sufficient". After the check passes, deduce the event start time from the first key point and perform resource checks.

[0035] The third-level default time fallback module (M4) is activated when both M2 and M3 fail, using the default time in the event configuration as the final solution to avoid overall planning failure.

[0036] Degradation flag writing module (M5): Writes the defaultTime flag into the solution result object to specify which level of path the solution comes from, for downstream auditing and credibility tracing.

[0037] Spring command recognition module (M6): Scan command sequences to identify all nodes with a "spring prefix" (i.e., a non-static placeholder command of a specific duration), and record their position index, weight parameters, and upstream and downstream adjacency relationships.

[0038] Fixed-duration accumulation module (M7): Iterates through all non-spring instructions in the sequence and accumulates them according to their type (sequential merge / bound merge) to obtain the fixed-duration sum S_fix; among them, "bound merge" type instructions do not contribute to the mainline offset.

[0039] Remaining Duration Weight Allocation Module (M8): The difference between the event durations S_total and S_fix output by the solver is ΔS = S_total S_fix is ​​the duration to be allocated; when the number of spring commands is k≥1, they are allocated according to the weight w_i. The duration of a single spring allocation is denoted as d_i=ΔS×w_i / Σw_j.

[0040] Backfill Consistency Verification Module (M9): After backfilling is completed, the total sequence duration is accumulated again and compared with S_total. If the difference is within the threshold ε, it is considered successful. Otherwise, a backfilling failure flag is written to the result object and the original placeholder is retained to prevent incorrect durations from being executed downstream.

[0041] 1.3 System Flow Description (e.g.) Figure 2 (As shown) 1.3.1 First-level expected time anchoring binary positioning Let the candidate time series of key points be arranged in ascending order of timestamps as K=(k_1,k_2…,k_n), the expected time be T_d, and the search direction be dir∈{forward, backward, bidirectional}.

[0042] Anchoring process: (a) Using T_d as the key, perform binary search on K to obtain the first index idx that satisfies k_idx≥T_d, with a time complexity of O(log n); (b) If dir is "backward", verify each sequence from idx towards the end of the sequence; if dir is "forward", verify each sequence from idx-1 towards the beginning of the sequence; if dir is "bidirectional", scan alternately to both sides. (c) Single verification content: Take the intersection of candidate k_p and LP, and perform two checks in sequence: resource sufficiency (resources are available and there is no conflict of use) and duration ≥ event duration; (d) The first k_p that passes all the steps is the first-level solution; if the sequence end is not hit, the first-level solution is recorded as a failure and the second level is triggered.

[0043] 1.3.2 Lightweight Pre-verification of Key Point Cartesian Product The conventional approach for the second level containing keypoint branches is to first generate all time combinations and then perform resource checks, resulting in a number of combinations that can reach Π|K_i|. This invention inserts a validity check that "adjacent keypoint times strictly increase and the interval is greater than or equal to the minimum offset of the constraint" after generating each time combination and before performing resource checks, so that most invalid combinations are pruned in O(m) time.

[0044] 1.3.3 Weighting of Remaining Duration of Spring Commands Let the instruction sequence D = (d_1, d_2, ..., d_L), where k are spring commands, L are spring commands, and L are spring commands. k are fixed instructions; the event duration is S_total, and the sum of the fixed instruction durations is S_fix.

[0045] Allocation formula (using notation consistent with 1.4): Remaining time to be allocated: ΔS = S_total S_fix The refill time for the i-th spring command: d_i = ΔS × w_i / Σ_{j=1..k} w_j Where w_i is the preset weight parameter of the spring command in the template, which defaults to 1. When ΔS<0 (i.e., the fixed duration has exceeded the event duration), no backfilling is performed, and a backfilling failure flag is directly written.

[0046] 1.3.4 Traceable Identification of Degradation and Backfill Paths The final result object contains at least two boolean bits: defaultTime: True indicates that it comes from the third level of fallback, False indicates that it comes from the first / second level; springBackfilled: True indicates that all spring commands have been successfully backfilled, while False indicates that backfilling was not performed because ΔS < 0 or the consistency check failed.

[0047] Downstream execution modules can use this information to differentiate the reliability of the solution (such as alarms, automatic recalculation, manual verification, etc.).

[0048] 1.4 Key Technical Parameters

[0049] Note: The parameters above are for illustrative purposes only and do not constitute a limitation on the claims.

[0050] 2. Case Description Implementation Background: A certain aerospace telemetry and control mission planning scenario includes several flight control events, each event having 0 to several key points; the available range is synthesized from station visibility forecast and energy availability forecast; the command templates are pre-edited by domain engineers according to event type, with some commands using spring prefixes as placeholders.

[0051] Implementation process: (1) Planner loads event configuration, available interval set, key point candidate time series, and instruction template; (2) Each event is sequentially entered into the time slot solver: when the event configuration includes the expected time, it enters the first level and performs binary positioning + directional scanning; if the first level fails, it enters the second level and is divided according to whether it contains key points; if the second level fails, the default time is used as a fallback. (3) The solver outputs a time slot object, identified as defaultTime; (4) Pass the event duration output by the solver to the sequence duration filler; (5) The filler scans a copy of the instruction template, identifies the spring instruction, accumulates a fixed duration to obtain S_fix, and assigns ΔS to the spring instruction according to formula 1.3.3; (6) The filler performs backfill consistency verification and marks springBackfilled; (7) Output objects with dual identifiers to downstream conflict detection, uploading review and other modules.

[0052] Technical effects (illustrative, not constituting a limitation of the claims): In a planning batch containing 100 events, compared to the traditional single-level solution process, the third-level fallback increases the success rate of a single event to nearly 100%; the spring command backfill allows the same command template to adapt to three types of events with different total durations without the need for manual modification of the template content.

[0053] Example of parameter settings (not intended as a limitation on the technical solution): The search direction dir should be set to "backward"; The spring weights w_i are all set to 1 (equally distributed); The backfill consistency threshold ε is set to 1 millisecond. The minimum interval g_min between key points is given by the event configuration, typically on the order of seconds.

[0054] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention, and not to limit them; although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some or all of the technical features; and these modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the scope of the technical solutions of the embodiments of the present invention.

Claims

1. A method for solving time slots and filling sequence durations of aerospace flight control events, characterized in that, include: Steps for solving time slots: Step S1: Calculate and output the set of legal time intervals based on the available and restricted intervals of flight control events; Step S2: Perform a three-level degradation solution and output a time slot containing the event duration. The three-level degradation solution includes, in sequence, a first-level expected time bisection anchoring, a second-level branch solution, and a third-level default time fallback. If the event is configured with an expected time, the first level is executed. If the first level fails or the event is not configured with an expected time, the second level is executed. If the second level fails, the third level is executed and the default time configured for the event is output as the solution. The second level is divided into two mutually exclusive branches for solving based on whether the event contains key point constraints. Step S3: After completing the three-level degradation solution, write the degradation identifier to clarify which level of path the solution comes from; Sequence duration padding steps: Step S4: Scan the instruction sequence to identify variable duration placeholder instruction nodes with spring prefixes, and record their position index and weight parameters; Step S5: Traverse all non-spring instructions in the sequence and sum them according to their type to obtain the fixed duration. Step S6: The difference between the event duration and the sum of the fixed durations is taken as the remaining duration to be allocated, and then filled back into each spring instruction according to the weight ratio of each spring instruction. Step S7: Perform a consistency check on the backfilled instruction sequence. If the check passes, write a backfill success flag; otherwise, write a backfill failure flag and retain the original placeholder. Step S8: Output the event time slot carrying the degradation flag and the instruction sequence carrying the backfill flag.

2. The method for solving time slots and filling sequence durations of aerospace flight control events according to claim 1, characterized in that, In step S1, the set of legal time intervals is obtained by performing arc intersection operation on each available interval and the restricted interval of the event.

3. The method for solving time slots and filling sequence durations of aerospace flight control events according to claim 1, characterized in that, In step S2, the first-level expected time bisection anchoring includes: using the expected time as the key to perform bisection positioning on the candidate time series of key points, taking the intersection of the candidate times with the set of legal time intervals in sequence along the preset search direction, performing resource sufficiency checks and checks that the duration is not less than the event duration, and outputting the first candidate time that passes all of them as the solution; the search direction includes forward, backward or bidirectional.

4. The method for solving time slots and filling sequence durations of aerospace flight control events according to claim 1, characterized in that, In step S2, the second level is solved by dividing the event into two mutually exclusive branches based on whether the event contains key point constraints. Specifically, this includes: No critical branch: Perform a linear scan of sub-intervals for each valid time interval, check for resource sufficiency and whether the duration is greater than or equal to the event duration, and return if a match is found; Keypoint Branch: Generate a set of available time points for each keypoint within each valid time interval. Generate time combinations by performing a Cartesian product on the set of available time points for each keypoint. For each combination, first perform a validity check that the time of adjacent keypoints increases and the interval is not less than the minimum offset. After the check passes, backtrack from the first keypoint to deduce the start time of the event and perform resource checks. Output the first combination that passes all checks as the second-level solution.

5. The method for solving time slots and filling sequence durations of aerospace flight control events according to claim 1, characterized in that, In step S4, the spring prefix is ​​a placeholder mark used to identify non-static command duration. The spring command node and the non-spring command node are distinguished by identifying the spring prefix.

6. The method for solving time slots and filling sequence durations for aerospace flight control events according to claim 1, characterized in that, In step S5, the instruction types include sequential merge and bound merge. Sequential merge type instructions contribute to the mainline offset, and their duration is included in the sum of the fixed durations. Bound merge type instructions do not contribute to the mainline offset, and their duration is not included in the sum of the fixed durations.

7. The method for solving time slots and filling sequence durations of aerospace flight control events according to claim 1, characterized in that, In step S6, if the difference between the sum of the event duration and the fixed duration is negative, or if there is no spring instruction in the instruction sequence, then backfilling is not performed and a backfilling failure flag is written directly.

8. The method for solving time slots and filling sequence durations of aerospace flight control events according to claim 1, characterized in that, In step S6, the spring instructions are backfilled according to their weight ratios. Specifically, this includes: obtaining the weight parameters of each spring instruction, calculating the proportion of the weight parameters of each spring instruction in the total weight parameters of all spring instructions, and multiplying the proportion by the remaining time to be allocated as the backfilling time of the corresponding spring instruction.

9. The method for solving time slots and filling sequence durations of aerospace flight control events according to claim 1, characterized in that, In step S7, the consistency check includes: re-accumulating the total duration of the instruction sequence after backfilling, comparing it with the event duration, and if the difference is within a preset threshold, the check passes; otherwise, the check fails.

10. The method for solving time slots and filling sequence durations of aerospace flight control events according to claim 1, characterized in that, In step S8, the downgrade flag is a Boolean flag, which indicates that the solution comes from the third-level default time fallback when the value is true, and that the solution comes from the first or second level when the value is false; the backfill flag is a Boolean flag, which indicates that the backfill is successful when the value is true, and that the backfill fails when the value is false.

Images