Satellite mission planning method and apparatus

Abstract

The embodiment of the present specification provides a satellite task planning method and device, wherein the satellite task planning method comprises: in response to a task insertion request, obtaining a meta task corresponding to the task insertion request and a task queue of a task execution device, wherein the task queue comprises a plurality of planned tasks and a time window corresponding to each planned task; based on the meta task, determining at least one candidate time window, and constructing a candidate task corresponding to the at least one candidate time window; based on the candidate time window corresponding to the candidate task, determining two adjacent reference tasks from the plurality of planned tasks; comparing the time interval between the two reference tasks and the candidate time window, if the comparison result is that there is no time conflict, determining the insertion position of the candidate task in the task queue; and inserting the candidate task into the insertion position. While ensuring the determinacy and real-time of the scheduling result, the local optimization ability and adaptability of the scheduling scheme are enhanced without sacrificing the calculation efficiency.

Description

Technical Field

[0001] The embodiments in this specification relate to the field of mission management technology, and in particular to a satellite mission planning method and a satellite mission planning device. Background Technology

[0002] With the rapid growth in demand for Earth observation, imaging satellites are playing an increasingly important role in various fields such as ground monitoring, disaster emergency response, and environmental assessment. To efficiently utilize limited onboard resources, mission planning, as a core component of satellite autonomous operation, must rationally arrange the execution sequence of observation tasks under complex orbital dynamics constraints, energy limitations, and mission priority requirements to maximize observation efficiency. Especially in single-satellite or small-scale constellation scenarios, rapidly generating high-quality, executable mission scheduling schemes is crucial to ensuring the system's real-time performance and reliability.

[0003] Currently, for satellite mission scheduling problems, the academic community widely employs intelligent search algorithms such as genetic algorithms, ant colony optimization, and simulated annealing for global optimization. While these methods can improve scheduling efficiency to some extent, their reliance on random sampling and iterative mechanisms leads to lengthy solution processes and non-deterministic results, making them unsuitable for engineering applications in onboard or near-real-time ground systems. In contrast, rule-based scheduling methods, with their advantages of high computational efficiency, reproducible results, and clear control logic, have become the mainstream technical approach in current engineering practice, particularly suitable for single-satellite mission planning scenarios.

[0004] However, existing rule-based scheduling methods typically employ fixed-priority strategies, lacking in-depth analysis of the dynamic coupling relationships between tasks and the flexibility of time windows. This makes them prone to getting stuck in local optima when pursuing the maximization of overall observation gains, and they lack the ability to continuously optimize the scheduling scheme through feedback adjustments. Therefore, there is an urgent need for a satellite mission planning method that balances determinism, efficiency, and global optimization capabilities, ensuring the rapid generation of feasible solutions while improving the response quality and resource utilization efficiency of individual satellites for key tasks. Summary of the Invention

[0005] In view of this, embodiments of this specification provide a satellite mission planning method. One or more embodiments of this specification also relate to a satellite mission planning apparatus, a computing device, a computer-readable storage medium, and a computer program product, to address the technical deficiencies existing in the prior art.

[0006] According to a first aspect of the embodiments of this specification, a satellite mission planning method is provided, comprising: In response to a task insertion request, the meta-task corresponding to the task insertion request and the task queue of the task execution device are obtained. The task queue includes multiple planned tasks and the time window corresponding to each planned task. Based on the meta-task, at least one candidate time window is determined, and candidate tasks corresponding to at least one candidate time window are constructed. Based on the candidate time windows corresponding to the candidate tasks, two adjacent reference tasks are determined from multiple planned tasks; Compare the time interval between two reference tasks and the candidate time window. If the comparison result shows that there is no time conflict, determine the insertion position of the candidate task in the task queue. Insert the candidate task at the insertion position.

[0007] According to a second aspect of the embodiments of this specification, a satellite mission planning apparatus is provided, comprising: The request acquisition module is configured to, in response to a task insertion request, acquire the meta-task corresponding to the task insertion request and the task queue of the task execution device, wherein the task queue includes multiple planned tasks and the time window corresponding to each planned task. The task construction module is configured to determine at least one candidate time window based on the meta-task and construct candidate tasks corresponding to at least one candidate time window; The determination module is configured to identify two adjacent reference tasks from multiple planned tasks based on the candidate time windows corresponding to the candidate tasks. The comparison module is configured to compare the time interval and candidate time window between two reference tasks. If the comparison result shows that there is no time conflict, the insertion position of the candidate task in the task queue is determined. The Insert module inserts candidate tasks at the insertion position.

[0008] According to a third aspect of the embodiments of this specification, a computing device is provided, comprising: Memory and processor; The memory is used to store computer programs / instructions, and the processor is used to execute the computer programs / instructions, which, when executed by the processor, implement the steps of the satellite mission planning method described above.

[0009] According to a fourth aspect of the embodiments of this specification, a computer-readable storage medium is provided that stores a computer program / instructions that, when executed by a processor, implement the steps of the satellite mission planning method described above.

[0010] According to a fifth aspect of the embodiments of this specification, a computer program product is provided, including a computer program / instructions that, when executed by a processor, implement the steps of the satellite mission planning method described above.

[0011] The satellite mission planning method provided in one or more embodiments of this specification includes: responding to a mission insertion request, obtaining a meta-task corresponding to the mission insertion request and a mission queue of the mission execution device, wherein the mission queue includes multiple planned missions and time windows corresponding to each planned mission; determining at least one candidate time window based on the meta-task, and constructing candidate missions corresponding to at least one candidate time window; determining two adjacent reference missions from multiple planned missions based on the candidate time windows corresponding to the candidate missions; comparing the time interval between the two reference missions and the candidate time windows, and if the comparison result shows no time conflict, determining the insertion position of the candidate mission in the mission queue; and inserting the candidate mission at the insertion position.

[0012] By responding to task insertion requests, the system dynamically acquires meta-tasks and the current task queue, and determines corresponding candidate time windows and candidate tasks based on the meta-tasks. Then, using the time window information of planned tasks in the task queue, it accurately locates two adjacent reference tasks. By comparing their time intervals with the candidate time windows to determine if there are any conflicts, it determines the feasible insertion position of the candidate task. This process avoids replanning the entire task sequence, ensuring the determinism and real-time nature of the scheduling results while effectively utilizing the time gaps between tasks. This improves the utilization efficiency of onboard resources and the responsiveness to new tasks, thereby enhancing the local optimization capability and adaptability of the scheduling scheme without sacrificing computational efficiency. Attached Figure Description

[0013] Figure 1 A flowchart illustrating a satellite mission planning method provided in one embodiment of this specification; Figure 2 This is a schematic diagram illustrating a different type of task as provided in one embodiment of this specification; Figure 3 This is a schematic diagram illustrating a task sliding process provided in one embodiment of this specification; Figure 4 This is a schematic diagram of a task merging process provided as an embodiment of this specification; Figure 5 A flowchart illustrating the processing procedure of a satellite mission planning method provided in one embodiment of this specification; Figure 6 A schematic diagram of a satellite mission planning device provided in one embodiment of this specification; Figure 7 This is a structural block diagram of a computing device provided for one embodiment of this specification. Detailed Implementation

[0014] Many specific details are set forth in the following description to provide a full understanding of this specification. However, this specification can be implemented in many other ways than those described herein, and those skilled in the art can make similar extensions without departing from the spirit of this specification. Therefore, this specification is not limited to the specific implementations disclosed below.

[0015] The terminology used in one or more embodiments of this specification is for the purpose of describing particular embodiments only and is not intended to limit the scope of the one or more embodiments of this specification. The singular forms “a,” “described,” and “the” used in one or more embodiments of this specification and the appended claims are also intended to include the plural forms unless the context clearly indicates otherwise. It should also be understood that the term “and / or” used in one or more embodiments of this specification refers to and includes any or all possible combinations of one or more associated listed items. The term “at least one” in one or more embodiments of this application means “one or more,” and “a plurality of” means “two or more.” The term “comprising” is an open-ended description and should be understood as “including but not limiting,” and may include other content in addition to what has been described.

[0016] It should be understood that although the terms first, second, etc., may be used to describe various information in one or more embodiments of this specification, such information should not be limited to these terms. These terms are only used to distinguish information of the same type from one another. For example, first may also be referred to as second without departing from the scope of one or more embodiments of this specification, and similarly, second may also be referred to as first. Depending on the context, the word "if" as used herein may be interpreted as "when," "when," or "in response to a determination."

[0017] See Figure 1 , Figure 1 A flowchart of a satellite mission planning method provided in one embodiment of this specification specifically includes the following steps: Step 102: In response to the task insertion request, obtain the meta-task corresponding to the task insertion request and the task queue of the task execution device, wherein the task queue includes multiple planned tasks and the time window corresponding to each planned task.

[0018] A task insertion request is an operational command used to add a new, unscheduled observation task to the existing task queue. It can be initiated by the ground system, user terminal, or autonomous decision-making module. Task insertion requests typically carry a task list, a meta-task, or basic attribute information of the task to be inserted, such as the target area, expected execution time range, and imaging mode. This enables the task scheduling mechanism to have dynamic responsiveness, flexibly accepting new or urgent tasks without interrupting existing plans, thereby improving onboard resource utilization efficiency and overall system adaptability. One possible scenario is that the task insertion request carries a task list, as follows: The task list is a set of raw observation requirements generated by users or ground control systems and uploaded to the planning system. The task list is defined as follows: Table 1 Task List (Latitude and Longitude of Specified Target Points on the Ground)

[0019] Table 2 Task List (indexed by target library)

[0020] A meta-task is a set of raw input information describing an observation requirement, containing basic task attributes and execution constraints, serving as the foundational unit for generating specific executable tasks. It is used to uniformly manage observation requests from different sources, providing structured data support for task scheduling and facilitating operations such as time window matching, priority ranking, and resource allocation. For example, a meta-task could be an imaging requirement for a specific geographical area, an observation plan for a specific target point, a periodic environmental monitoring task, or a user-submitted remote sensing observation request with time constraints. Depending on the task type, a meta-task may include parameters such as task ID, priority, request time window, target location, working mode, and whether it is periodically executed, supporting subsequent task decomposition and scheduling decisions.

[0021] Please refer to the table below for details: Table 3. Point Target Meta-Task Structure

[0022] Table 4. Regional Target Meta-Task Structure

[0023] Mission execution equipment refers to the functional units within a satellite system that actually perform observation actions. It is capable of completing specific operations such as Earth imaging, data acquisition, and signal reception according to scheduling instructions. It is used to translate planned mission instructions into actual observation behaviors. For example, mission execution equipment can be a satellite, an optical imaging camera, a synthetic aperture radar (SAR), a multispectral scanner, an infrared detector, a hyperspectral imager, or a data transmission terminal used for satellite-to-ground communication and telemetry feedback, etc. Different devices have their own time response characteristics, conversion times, and observable window limitations; these factors collectively affect the feasibility assessment of mission insertion and time window matching.

[0024] A task queue is an ordered set used to organize and manage planned tasks, reflecting their arrangement along a timeline, with each planned task associated with a corresponding time window. It provides a structured time base and logical order for task insertion, adjustment, and execution, supporting dynamic tracking of resource occupancy and conflict detection. For example, a task queue can be a set of optical imaging tasks arranged chronologically, a mixed observation sequence, etc. This queue can be dynamically updated and locally optimized based on new insertion requests, changes in equipment status, or external commands.

[0025] Each planned task's corresponding time window is an interval identifier assigned to each observation task included in the task queue, used to characterize its executable time range. It is usually defined by the start and end timestamps, and can be further refined into execution start time, execution end time, and flexible boundaries that allow for adjustments. It is used to characterize the feasible execution domain of the task in the time dimension, supporting scheduling operations such as conflict detection, insertion position determination, transition time reservation, and subsequent optimization adjustments.

[0026] There are several ways to obtain the meta-task corresponding to the task insertion request in response to the task insertion request. One possible way is to obtain the task list corresponding to the task insertion request in response to the task insertion request, perform requirement segmentation, and obtain multiple meta-tasks.

[0027] There are several ways to obtain the task queue of the task execution device in response to a task insertion request. One possible way is to obtain the task queue of the task execution device from the satellite management system in response to the task insertion request.

[0028] Another possible approach is to retrieve the task queue of the task execution device from the ground station in response to a task insertion request.

[0029] This step parses the externally input task list into standardized meta-tasks and simultaneously obtains the task queue of the current task execution device and the time windows corresponding to each of its planned tasks. This provides a complete, consistent, and timely data foundation for subsequent candidate time window generation, reference task location, and conflict determination. As a result, while ensuring the reproducibility of the scheduling logic, it significantly improves the accuracy of the system's response to dynamic observation needs and its context awareness.

[0030] Step 104: Based on the meta-task, determine at least one candidate time window and construct candidate tasks corresponding to at least one candidate time window.

[0031] Candidate time windows are time intervals that meet observable conditions, determined based on the observation requirements described in the meta-task. They can be derived by combining the observation requirements with the orbital coverage characteristics, attitude maneuvering capabilities, and energy constraints of the mission execution equipment. These windows are used to generate preliminary execution opportunities that are feasible for the equipment, serving as the starting point for subsequent insertion feasibility assessments and optimization adjustments. For example, a continuous imaging period for a target in a certain area under the coverage of the satellite's side-swing capability. This window does not yet consider the occupancy status of existing tasks in the queue; it represents a locally feasible but globally unverified time proposal. It will be compared with the time intervals of adjacent planned tasks to support the determination of the insertion position.

[0032] A candidate task is a schedulable task instance with complete execution elements, generated based on the observation requirements defined by the meta-task. These elements may include target parameters, operating mode, time window, and attitude commands. Candidate tasks transform abstract observation intentions into concrete, insertable scheduling objects, providing a conflict detection mechanism for finding suitable execution locations in the task queue. For example, a candidate task can be an observation task within an observable time window. Each candidate task is bound to a corresponding candidate time window and can further participate in steps such as transition time calculation, conflict detection, and window sliding optimization, thereby supporting dynamic, incremental task scheduling decisions.

[0033] In one possible real-world scenario, candidate tasks can be considered as follows: A candidate task (CT) is a task that meets the execution conditions after the meta-task has been calculated using the visible time window, including information such as the visible time window and observation angle. The candidate task structure is as follows: Table 5 Candidate Task Structure

[0034] Planned candidate tasks (planned tasks) Scheduled Candidate Tasks (SCTs) are candidate tasks that have been successfully added to the queue of successfully scheduled tasks. In addition to having all the information of a basic candidate task, they also have intermediate information generated during the scheduling process.

[0035] Table 6. Planned Candidate Task Structure

[0036] There are several ways to determine at least one candidate time window based on the meta-task. One possible way is to determine at least one candidate time window in each observable time period based on the meta-task.

[0037] The observable time period is the time interval within which effective observation of a specific target area can be carried out. This interval is jointly determined by the geometric relationship between the satellite and the target, the sensor's field of view coverage capability, the feasibility of attitude adjustment, and environmental conditions such as illumination and occlusion. It is used to define the physical feasible boundary of mission execution, providing equipment operation basis for generating candidate time windows for meta-missions, determining the timing of mission insertion, and assessing the feasibility of mission execution. For example, the observable time period can be a continuous visible arc segment of a point target within the satellite's side-swing range, a time window during which a target in a certain area can be imaged within the field of view of the optical camera, the echo acquisition period during which the radar payload meets the incident angle requirements, or the available illumination period when the nadir point passes through the target area and the solar altitude angle meets the imaging requirements, etc. This time period is usually used as an initial constraint in mission planning to screen candidate mission execution opportunities that meet the time requirements and to support subsequent comparison and coordination with the time windows of planned missions.

[0038] This step derives at least one candidate time window within multiple observable time periods associated with the meta-task, and constructs candidate tasks with execution parameters accordingly. This retains the flexibility and ambiguity of task insertion, while providing executable candidate tasks for subsequent insertion position determination. Deterministic deduction based on orbital mechanics and load capacity models ensures that each candidate task meets basic observability and equipment constraints. This ensures the reproducibility of scheduling results and computational efficiency, while laying a solid data foundation for subsequent steps such as conflict detection, transition time reservation, and window sliding optimization.

[0039] Step 106: Based on the candidate time windows corresponding to the candidate tasks, determine two adjacent reference tasks from multiple planned tasks.

[0040] Two adjacent reference tasks are a pair of planned tasks in the current task queue that are temporally located before and after the insertion position of the candidate task. Where possible, there should be no other planned tasks between the two adjacent reference tasks. This can be represented as one task immediately before the candidate time window (the preceding reference task) and the other immediately after the candidate time window (the following reference task). These tasks define the range of time intervals within which the candidate task can be inserted, providing contextual support for determining whether the candidate time window conflicts with existing tasks, meets equipment conversion requirements, and has sufficient leeway. For example, two adjacent reference tasks could be two consecutive optical imaging tasks. The two adjacent reference tasks are dynamically selected based on the position of the candidate time window, used to construct local time constraint boundaries, supporting incremental and localized scheduling decisions.

[0041] In one possible scenario, determining two adjacent reference tasks from multiple planned tasks based on the candidate time windows corresponding to the candidate tasks can be done by: determining two adjacent reference tasks starting from the end of the multiple planned tasks in the task queue based on the candidate time windows corresponding to the candidate tasks.

[0042] More specifically, based on the candidate time window corresponding to the candidate task, starting from the end of multiple planned tasks in the task queue, two adjacent reference tasks whose time intervals can be inserted into the candidate time window of the candidate task are determined.

[0043] This step uses candidate time windows as anchor points to dynamically locate a pair of time-nearest planned tasks in the task queue, achieving local focus and context extraction of the feasible insertion region. This avoids traversing the entire queue or global reordering, significantly reducing computational complexity. At the same time, it ensures that the selected reference tasks can truly reflect the actual resource usage and conversion constraints near the candidate window, providing accurate, lightweight, and timely local constraint boundaries for subsequent efficient and accurate time conflict determination, conversion time period calculation, and window sliding optimization.

[0044] Step 108: Compare the time interval between the two reference tasks and the candidate time window. If the comparison result shows that there is no time conflict, determine the insertion position of the candidate task in the task queue.

[0045] The time interval between two reference tasks is the time gap between them, or more specifically, the time gap between the termination timestamp of the preceding reference task and the start timestamp of the following reference task. The time interval between two reference tasks represents the unused available time resources of the currently planned task sequence within a local time period. It provides a potential insertion space benchmark for candidate tasks, serves as a direct basis for determining whether a candidate time window is physically feasible for insertion, and also forms the time constraint basis for subsequent computing device conversion time, assessment of maneuver margins, and window sliding optimization.

[0046] A time conflict occurs when the time window corresponding to a candidate task overlaps with or cannot accommodate the time interval between two reference tasks on the time axis. Specifically, this manifests as the start time of the candidate time window being earlier than the end time of the preceding reference task, the end time being later than the start time of the following reference task, or even if the entire time window falls within the time interval, there is still insufficient margin to complete the execution after deducting the time required for device conversion. Time conflicts are used to identify the infeasibility of insertion operations in the time dimension and are a criterion for triggering candidate task filtering, window sliding adjustment, or reselection of candidate solutions.

[0047] The insertion position is the time location determined for a candidate task in the task queue. It can be reflected in the sorting order or execution time interval within the task queue. It can also include its index position in the queue structure, such as being located between the nth and (n+1th)th planned tasks, as well as its actual executable time period, i.e., the start and end timestamps finally determined after time reservation and window sliding. This is used to organically integrate candidate tasks into the existing scheduling arrangement, ensuring that constraints such as equipment resources, energy supply, and attitude maneuverability are met while maintaining the integrity of the queue's timing. For example, the insertion position could be an imaging task scheduled within the time gap between two planned imaging tasks.

[0048] This step achieves rapid and localized verification of the feasibility of inserting a candidate task by deterministically comparing the time interval between the candidate time window and the two reference tasks, using the existence of time conflicts as the criterion. Under the premise of no conflict, the time execution interval of the candidate task in the task queue is directly established. This avoids the computational overhead caused by global replanning and ensures that the insertion result meets the basic scheduling requirements such as time continuity, device conversion constraints, and non-overlapping resource usage. This makes the process of determining the insertion position reproducible, low-latency, and engineering feasible, thereby supporting the single-satellite system to achieve a balance between high response speed and high scheduling robustness in dynamic task flow scenarios.

[0049] Step 110: Insert the candidate task at the insertion position.

[0050] Inserting a candidate task at the designated insertion position is the process of formally including a candidate task in the task queue, making it part of the planned task sequence. This operation updates the order of tasks in the queue and synchronously determines the time window information for the candidate task, thus completing the transition from candidate to planned state. Inserting a candidate task does not change the original time windows of other planned tasks; it only expands the structure within the time interval between the candidate's time window and the reference task. It is the final step in the entire task planning process to achieve dynamic response, possessing determinism and traceability.

[0051] In one possible scenario, after inserting the candidate task at the insertion position, the planned tasks in the task queue are merged based on the merging rules to obtain the atomic task.

[0052] For details on the atomic task, please see below: An atomic task (AT) is a specific, indivisible, and deterministic unit of scheduling. It can also be understood as one atomic task corresponding to one payload power-on / off cycle. An atomic task may contain multiple planned candidate tasks. An atomic task can be presented with the following structure: an atomic task contains a task ID (as a serial number used to track task status, incrementing sequentially according to processing order), and one or more planned candidate tasks. Each candidate task records its corresponding meta-task ID, imaging start time, and imaging end time. This structure allows one payload power-on / off cycle to be mapped to an atomic task, internally associating multiple specific imaging subtasks.

[0053] Furthermore, the relationship between the above task list, meta-tasks, candidate tasks, planned tasks, and atomic tasks can be found in [reference needed]. Figure 2 , Figure 2 The figure shows a schematic diagram of a different type of task provided for one embodiment of this specification: The relationship between the task list, meta-tasks, candidate tasks, planned tasks, and atomic tasks can be described as follows: A task list is a collection of raw observation requests submitted by users or ground systems. Each task list contains multiple specific observation targets and constraints, such as time windows, priorities, and target types. During processing, a task list is decomposed into several meta-tasks (MTs), each representing an independent observation unit within the list, such as an imaging request for a point target or a region target.

[0054] Meta-tasks (MT) are a refined product of the task list, retaining key parameters of the original requirements (such as task ID, priority, time window, target information, etc.) as the basic input for subsequent scheduling processing. After a visibility calculation phase, meta-tasks, combined with satellite orbit, sensor capabilities, and geometric constraints, generate corresponding candidate tasks (CTs). Candidate tasks are specific task instances that are feasible to execute within a specific observable time period. Each candidate task is bound to a candidate time window, representing its possible execution opportunity.

[0055] After candidate tasks (CTs) enter the task scheduling and conflict resolution phase, their insertion position is determined and conflicts are detected based on factors such as time window matching, equipment conversion time, and resource consumption. Through scheduling decisions, some candidate tasks are confirmed as executable and transformed into planned tasks (SCTs), which are task instances with determined execution time, order, and resource allocation. These planned tasks are then sorted by time in a queue, forming a preliminary scheduling sequence.

[0056] Finally, during the task merging phase, adjacent and matching planned tasks (SCTs) can be merged into atomic tasks (ATs) to reduce task switching and improve execution efficiency. An atomic task is the smallest scheduling unit ultimately issued to the onboard execution system; it typically has continuous execution characteristics, effectively reducing equipment maneuvering frequency and energy consumption.

[0057] In summary, the entire process embodies a progressively refined process from high-level requirements (task list) to low-level execution (atomic tasks). Each step is selected and optimized based on physical feasibility, time constraints, and system status, achieving a complete closed loop from abstract requests to executable scheduling.

[0058] The main steps of a satellite mission planning method based on priority rules for key tasks can be described as follows: When the planning trigger flag Plan_Trigger_Flag is 1, the mission planning process is triggered. 1. Meta-task pre-sorting: The metatask list is sorted according to the following order: priority (high / low), request time window end (early / late), time window size (small / large), and task ID.

[0059] 2. Sequential Greedy Scheduling: Following the above order, process each metatask iteratively. For the current metatask: obtain all its candidate tasks and sort them by time; attempt to insert the candidate tasks of the current metatask into the planning success queue in order. Once a candidate task is successfully inserted, stop processing the current metatask and proceed to the processing of the next metatask.

[0060] 3. Update meta-task status: If no candidate task is successfully scheduled for the metatask, the metatask status is updated to planning failure; otherwise, the metatask status is updated to planning success.

[0061] 4. Merge and optimize: Sort the successfully planned queue by time, perform a merge check, and update the task merge ID; after all candidate tasks have been scheduled, attempt to perform observation and optimization on the planned candidate tasks.

[0062] 5. Generate atomic task sequences: The final atomic task sequence is obtained by processing the task merge ID; this task scheduling is complete.

[0063] The satellite mission planning method provided in this specification dynamically acquires the meta-mission and the current mission queue in response to mission insertion requests, and determines the corresponding candidate time window and corresponding candidate mission based on the meta-mission. Then, using the time window information of the planned missions in the mission queue, it accurately locates two adjacent reference missions and determines the feasible insertion position of the candidate mission by comparing their time interval with the candidate time window to see if there is a conflict. This process avoids replanning the entire mission sequence, effectively utilizing the time gaps between missions while ensuring the determinism and real-time nature of the scheduling results. This improves the utilization efficiency of onboard resources and the responsiveness to new missions, thereby enhancing the local optimization capability and adaptability of the scheduling scheme without sacrificing computational efficiency.

[0064] In one optional embodiment of this specification, the candidate time window includes a start timestamp and an end timestamp, and the two reference tasks include a preceding reference task and a succeeding reference task. Before determining the insertion position of a candidate task in the task queue by comparing the time interval between two reference tasks and the candidate time window, if the comparison result shows no time conflict, the following steps are also included: The time interval between two reference tasks is determined based on the termination timestamp of the preceding reference task and the start timestamp of the succeeding reference task.

[0065] The start timestamp is a time marker used to identify the beginning of a candidate time window on the timeline. It defines the earliest start time for the execution of a candidate task and provides a time reference for time conflict detection, scheduling order determination, and transition time reservation. The start timestamp can be determined based on the starting point of the observable time window for the candidate task by the satellite, or after sliding back the candidate time window, based on the starting point of the observable time window and the length of the slide back.

[0066] The termination timestamp is a time marker used to identify the end point of a candidate time window on the timeline. It defines the latest deadline for the execution of candidate tasks and, together with the start timestamp, forms the boundary of the candidate time window, supporting time interval calculation and feasibility analysis for subsequent task insertion. This timestamp reflects the planned time endpoint and may differ from the actual end time due to actual execution deviations. The termination timestamp can be determined based on the start timestamp and the task execution period.

[0067] The task execution time period, determined after observability analysis and equipment capability matching, is a physically feasible execution time interval for the candidate task, defined by a start timestamp and an end timestamp. It characterizes the actual time interval occupied by the candidate task from instruction triggering to action completion, and serves as the direct basis for subsequent queue insertion, comparison with reference task intervals, calculation of transition time, and window sliding optimization.

[0068] The preceding reference task is the planned task in the task queue that is closest in time to the insertion position of the candidate task and is adjacent to it. The preceding reference task is determined by sorting the planned tasks in the sequence of planned tasks according to the start time of the candidate time window, and whose end time is closest to but not greater than the start timestamp of the candidate task. It is used to provide upstream time boundaries and resource status references for the candidate task, to calculate the time interval between them, to evaluate the maneuver or restart time required for the device to switch from the candidate task, and to support the determination of the preceding transition period.

[0069] The immediate reference task is the planned task in the task queue that is temporally closest to and adjacent to the candidate task's insertion position. The immediate reference task is determined by time sorting within the planned task sequence based on the candidate task's end time window; it is the planned task whose start time is closest to, but not less than, the candidate task's end timestamp. It provides downstream time boundaries and subsequent resource usage references for candidate tasks, calculates the time interval between candidate tasks and the current task, assesses the maneuvering preparation or system restart time required for switching from a candidate task to the current task, and supports the determination of the immediate transition time period.

[0070] There are several ways to determine the time interval between two reference tasks based on the termination timestamp of the preceding reference task and the start timestamp of the following reference task. One possible way is to determine the time interval between the two reference tasks based on the absolute value of the difference between the termination timestamp of the preceding reference task and the start timestamp of the following reference task.

[0071] The embodiments in this specification obtain the time interval between the termination timestamp of the preceding reference task and the start timestamp of the following reference task by directly calculating the numerical difference between the two. This enables quantitative modeling of the gaps where candidate tasks can be inserted. The obtained time interval serves as the benchmark for subsequent conflict determination. It not only supports the rapid determination of whether the candidate time window falls entirely within the gap, but also provides a unified and traceable time measurement basis for reserving the transition time period between the preceding and following reference tasks, boundary constraints on window sliding, and observable optimization.

[0072] In one optional embodiment of this specification, the insertion position includes the insertion time period; If the comparison result indicates no time conflict, determine the insertion position of the candidate task in the task queue, including: If the comparison result shows that there is no time conflict, determine the preceding transition time period between the preceding reference task and the candidate task, and determine the following transition time period between the following reference task and the candidate task. Based on the preceding and succeeding transition time periods, the insertion time period for candidate tasks in the task queue is determined.

[0073] The insertion time period is the time interval within which a candidate task has a chance of being actually executed. It is defined by the updated start and end timestamps and serves as the basis for the formal integration of the candidate task into the task queue. The insertion time period is the result of local optimization and adjustment, possessing executability, context adaptability, and resource compatibility.

[0074] The preceding transition time period is the time resource reserved to ensure that the task execution device can reliably transition from the preceding reference task to the candidate task execution state. Its length depends on the coupling relationship between the two tasks at the device operation level, including one or more of the time required for processes such as attitude adjustment, mode switching, and device power-on / off. It is used to characterize the migration cost between tasks, serves as a key constraint for determining whether the candidate task can start in a timely manner after the preceding reference task ends, and is also an important input for calculating the insertion time period and performing window sliding optimization.

[0075] The successor transition time period is the time resource reserved to ensure that the equipment can smoothly and stably transition to the successor reference task. Its length depends on the connection requirements between the candidate task and the successor reference task at the equipment operation level, including one or more of the time required for processes such as attitude adjustment, mode switching, and equipment power-on and power-off. It is used to ensure that the candidate task will not squeeze the start-up preparation window of the successor task due to the late completion of the execution. It is a constraint condition for verifying the feasibility of insertion, determining the upper limit of the insertion time period, and supporting sliding optimization.

[0076] The transition time between the preceding reference task and the candidate task can be determined either by the equipment maneuver time between the two tasks or by the equipment restart time, depending on the specific circumstances.

[0077] The successor transition time between the successor reference task and the candidate task can be determined by either the equipment maneuver time between the successor reference task and the candidate task, or by the equipment restart time. The specific choice depends on the actual situation.

[0078] The insertion time of a candidate task in the task queue can be determined based on the preceding and following transition time periods. This can be achieved by sliding the candidate time window based on the preceding and following transition time periods, and then determining the insertion time of the candidate task in the task queue based on the slid-out candidate time window.

[0079] This specification's embodiments, based on the premise of confirming no time conflicts, further introduce bidirectional constraint modeling of the preceding and following transition time periods. This not only requires that the candidate time window fall entirely within the time gap between the two reference tasks, but also requires that the window can still be fully accommodated after deducting the transition time, thereby ensuring the physical feasibility of device state migration. The insertion time period determined on this basis is a comprehensive optimization result that takes into account observability and the coupling relationship between tasks, reserving flexibility for subsequent window sliding, task merging, and observation quality optimization. The entire process maintains determinism, low computational complexity, and strong engineering deployability, significantly improving the robustness, real-time response capability, and actual execution success rate of the scheduling scheme for a single satellite in dynamic task flow scenarios.

[0080] In one optional embodiment of this specification, the time window includes an execution start timestamp and an execution end timestamp; Based on the preceding and succeeding transition time periods, the insertion time period for candidate tasks in the task queue is determined, including: The preceding idle time window is determined based on the execution termination timestamp and execution start timestamp of the preceding reference task; If the preceding idle time window is smaller than the preceding transition time period, the preceding time difference is determined based on the difference between the preceding idle time window and the preceding transition time period. Based on the immediate preceding time difference, the time window is slid backward to obtain the updated time window; The immediate idle time window is determined based on the start timestamp and execution end timestamp of the immediate reference task. If the immediate idle time window is smaller than the immediate transition time period, the immediate time difference is determined based on the difference between the termination timestamp and the execution start timestamp of the immediate reference task. Based on the immediate time difference, the time window is slid backward to obtain the updated time window; The time window is defined as the period during which candidate tasks are inserted into the task queue.

[0081] The execution start timestamp is the moment when a planned task begins to perform operations on the device. It is used to characterize the actual start time of a task. During the scheduling process, it is used to support the feasibility judgment of task insertion, participate in the calculation of the preceding / following idle time window, assist in the modeling of time transition periods, and provide an initial offset reference for the time window sliding strategy, etc.

[0082] The execution termination timestamp is the moment when a planned task ends its execution on the device. It is used to characterize the actual time when a task stops. During the scheduling process, it is used to support the feasibility judgment of task insertion, participate in the calculation of the preceding / following idle time window, assist in the modeling of the transition time period, and provide an initial offset reference for the time window sliding strategy, etc.

[0083] A time window is a closed time interval defined by the execution start timestamp and the execution end timestamp. It describes the time range occupied by a planned task in the task queue. This time window is suitable for supporting the feasibility judgment of task insertion, participating in the calculation of the preceding / following idle time window, assisting in the modeling of time transition periods, providing an initial offset benchmark for the time window sliding strategy, etc., reflecting the position and duration of the task on the time axis.

[0084] The preceding idle time window is the time interval between the termination timestamp of the preceding reference task and the execution start timestamp of the candidate task in the task queue. It represents the available space, indicating the time resources available for the candidate task to perform device state transitions such as attitude adjustment, mode switching, and device restart after the preceding reference task ends and before it begins its own execution. It is a fundamental metric for determining whether the preceding transition time period can be satisfied. The size of the preceding idle time window directly determines whether the candidate task's time window needs to be adjusted backward, thus ensuring the physical feasibility of the device transition process and the stability of task execution.

[0085] The preceding transition period is a transitional time interval between the preceding reference task and the candidate task's time window, used to determine whether the candidate task can be successfully executed after the preceding reference task. The preceding transition period is determined by inter-task physical constraints, equipment state transition time, etc. Its functions include supporting the verification of insertion position feasibility, participating in the comparison calculation of the preceding idle time window and the actual available interval, and serving as the offset basis for time window backward adjustment. Its value can be dynamically generated in the rule engine by combining table lookup (optical satellite maneuverability table or SAR satellite maneuverability table), function mapping (such as L(x)), or equipment operation log backtracking.

[0086] The preceding time difference is the gap calculated when the preceding idle time window is insufficient to accommodate the preceding transition time period. It is used to satisfy the time connection constraints between the preceding reference task and the candidate task. It is dynamically derived from the numerical relationship between the termination timestamp of the preceding reference task, the execution start timestamp of the candidate task, and the preceding transition time period. It can be understood as the minimum time offset that the candidate task must be postponed backward in order to make it logically feasible to continue after it without changing the preceding reference task's time window. It is used to drive the backward adjustment of the corresponding time window of the candidate task, serve as the quantitative basis for the insertion position correction, and support the time elasticity adaptation of the task. This difference can be directly added to the execution start timestamp and execution end timestamp of the candidate task to generate an updated time window.

[0087] The immediate idle time window is the time interval between the execution termination timestamp of a candidate task and the start timestamp of the immediate reference task in the task queue. It represents the available gap, which is used to characterize the time resources available for equipment status recovery, mode switching, and other preparatory operations after the candidate task is completed and before the immediate reference task starts. It is the basic metric for determining whether the immediate transition time period has the capacity to accommodate the task. The immediate idle time window changes dynamically with the update of the execution termination timestamp. The length of the immediate idle time window directly determines whether the time window of the candidate task needs to be further pushed back to ensure that the start preparation margin of the immediate task is not squeezed, thereby ensuring the continuity, stability, and engineering executability of the entire task sequence in the time dimension.

[0088] The successor transition time period is the transitional time interval reserved between the two time windows to ensure that a candidate task can be smoothly connected to the successor reference task before execution. It is determined by the candidate task's ending state, the successor reference task's starting conditions, and the physical response characteristics of the equipment during the switching process between the two types of tasks. It can be understood as the actual time required to complete necessary state transitions or system restarts from the time the candidate task ends to the time the successor reference task begins. It is used to support the feasibility verification of the insertion position, participate in the comparison analysis of the successor idle time window and the available interval, serve as the offset basis for the other side of the time window sliding adjustment, and provide constraint input for the compact optimization of the overall time distribution of the task queue. Its value can be dynamically generated in the rule engine by combining table lookup (optical satellite maneuverability table or SAR satellite maneuverability table), function mapping (such as L(x)), or equipment operation log backtracking.

[0089] The successor time difference is the calculated gap between the candidate task and the successor reference task when the successor idle time window is insufficient to accommodate the successor transition time period. It is used to satisfy the time connection constraints between the candidate task and the successor reference task. It is dynamically derived from the difference between the candidate task's execution start timestamp and the successor reference task's execution end timestamp. It can be understood as the time offset that needs to be postponed to allow the candidate task to complete feasiblely without changing the successor reference task's time window. Its functions include driving further backward adjustment of the candidate task's corresponding time window, serving as a correction parameter for the final determination of the insertion position, and providing a quantitative basis for the allocation of time margins between adjacent tasks in the task queue. This difference can be directly added to the candidate task's execution start timestamp and execution end timestamp to generate an updated time window and determine the final insertion time period's location.

[0090] The process of calculating the predecessor task can be as follows: When found satisfy At the same time, calculations and preceding tasks Immediate idle time window: ; 1) If no preceding task can be found, then the interval is: ; in, The star time is the starting point of the entire planned task queue. 1. Calculate the preceding transition time period: 1) If a preceding reference task exists, check whether it can be merged with the preceding task according to the continuous imaging task constraints; If they can be merged, then the preceding conversion time period is: .

[0091] in, This indicates that the function value y is obtained by linear interpolation of the input x based on table T.

[0092] If merging is not possible, then the preceding time period will be converted: ; 2) If there is no preceding reference task, then the preceding transition time period is: ; 2. Determine whether the maneuver against the immediate reference mission can be completed: like < This indicates that the immediate idle time window is insufficient, and candidate tasks need to be considered. Conflict resolution is performed, and the immediate successor time difference is calculated. ; like ≥ The preceding task has been successfully assessed.

[0093] in For candidate tasks The immediate reference mission, This refers to selecting either the optical satellite maneuverability table or the SAR satellite maneuverability table based on the actual satellite type.

[0094] 1. Computation and successor tasks Immediate idle time window: ; 2. Calculate the successor transition time period: Check whether it can be merged with the immediate following task according to the continuous imaging task constraints; If they can be merged, then the transition time for the subsequent task will be: ; If merging is not possible, then the transition time for the subsequent task is: ; 3. Determine whether the maneuver can be completed in conjunction with the immediately following reference mission: 2) If < This indicates that the immediate idle time window is insufficient, and candidate tasks need to be considered. To resolve conflicts, calculate the immediate successor time difference: ; like ≥ The subsequent task was judged to be successful.

[0095] in For candidate tasks The immediate reference mission, This refers to selecting either the optical satellite maneuverability table or the SAR satellite maneuverability table based on the actual satellite type.

[0096] The optical satellite maneuverability table describes the maneuvering time required for optical satellites to perform attitude maneuvers at different angles (such as 5°, 10°, 15°, 20°), and is generally applicable to imaging missions that require precise orientation.

[0097] The SAR satellite maneuverability table describes the maneuver duration required for SAR satellites to perform attitude maneuvers at different angles (such as 30° and 60°), and is generally applicable to side-looking imaging or large-area scanning missions.

[0098] Continuous imaging task constraint checks include: In the candidate tasks When performing an insertion operation, a continuous imaging constraint check needs to be performed. Assume candidate tasks have been planned. For candidate tasks The immediate task, and The merge task ID is ,but Able to The criteria for merging are: or & ; Similarly, assuming candidate tasks have been planned For candidate tasks The immediate follow-up task, and The merge task ID is ,but Able to The criteria for merging are: or

[0099] & ; in Indicates candidate tasks. This indicates that the task has been planned. : Indicates candidate task The execution termination timestamp, SCT_{i}{Task_End_Time}: represents the execution termination timestamp of the i-th planned task SCT_i, used to determine whether it overlaps or connects with the candidate task in time.

[0100] CT{Task Start_Time}: Represents the execution start timestamp of the candidate task CT, that is, the precise moment when the core action of the task officially begins.

[0101] This represents the start timestamp of the execution of the i-th planned task SCT_i.

[0102] Sensor_Max_WorkTime: This indicates the maximum duration for which the sensor is allowed to work continuously. It serves as one of the constraints for determining whether tasks can be merged, thus preventing the device from overheating or experiencing performance degradation due to prolonged continuous operation.

[0103] mn..: Represents the index number of the planned task, used to identify the position of the task in the queue; where m represents the sequence number of the preceding task and n represents the sequence number of the succeeding task, used to establish the logical relationship between tasks.

[0104] For a detailed explanation of the backslide process, please refer to [link / reference]. Figure 3 , Figure 3 This is a schematic diagram illustrating a task sliding process according to one embodiment of this specification. It includes: slashes ( / / ): indicate a scheduled task, which is a task whose execution time has been determined in the task queue.

[0105] Grid filling (□□): Indicates pending tasks, i.e., candidate tasks that are currently being evaluated for insertion.

[0106] Cross-fill (××): Indicates a sliding task, which is a candidate task that is shifted backward due to a time conflict.

[0107] The gray shaded area represents the "Visible Time Window," which is the period during which the satellite has the ability to observe the target.

[0108] TransTime: Represents the time required for task transitions, such as the time spent on device state transitions like attitude adjustment and mode switching.

[0109] Timeline: From left to right, it indicates the direction of time flow.

[0110] First image: Initial state: Multiple planned tasks (diagonal rectangles) are distributed along the timeline. A task to be processed (grid rectangle) is located between two planned tasks, and its time window falls entirely within the "visible time window." There is a gap (marked as TransTime) between the preceding task and the candidate task, representing the transition time required for the device to switch from the preceding task to the candidate task. A TransTime gap is also reserved between the succeeding task and the candidate task. At this point, the candidate task's time window matches well with the gap between the preceding and succeeding tasks, with no time conflicts, and can be directly inserted.

[0111] Second image (middle image): Immediate conflict detection: The candidate task is still within the "visible time window," but its start time is too early, causing it to overlap with or be insufficiently spaced from the end time of its predecessor task. The graph shows that the idle time between the end of the predecessor task and the start of the candidate task is less than `TransTime`. Therefore, the system determines that there is a predecessor time conflict and the candidate task needs to be adjusted by sliding backward. The adjusted candidate task (cross-filled) moves to the right so that its start time meets the predecessor transition time requirement.

[0112] Third image (below): Immediate conflict detection: After being slid backward, the candidate task's termination time is close to or exceeds the start time of its successor task. The graph shows that the idle time between the candidate task's end and the successor task's start is less than `TransTime`. Therefore, the system determines there is a successor time conflict and the candidate task needs to be slid backward again. Ultimately, the candidate task (cross-filled) is slid to a position that satisfies both the predecessor and successor transition times, while the entire time window remains within the "visible time window".

[0113] In other words, the process first checks whether the candidate task is within the "visible time window"; then it determines whether the gap between the candidate task and its predecessor is sufficient to accommodate the device transition time (TransTime); if not, the candidate task is slid forward; next, it checks whether the gap between the slid task and its predecessor is sufficient; if still insufficient, it continues to slid until all constraints are met. Ultimately, this achieves dynamic optimization of the task time window and ensures physical feasibility, guaranteeing a smooth transition of device status, avoiding resource conflicts, and improving task execution success rate.

[0114] This specification's embodiments construct a time window with execution start and end timestamps as boundaries, and introduce a timing parameter system including preceding / following idle time windows, preceding / following transition time periods, and corresponding preceding / following time differences. This achieves dynamic adaptation of the task insertion process, supports positional and constraint-based feasibility verification and positioning of new task requests, and automatically completes flexible backsliding and multi-round correction of the time window while ensuring equipment physical constraints and system operation logic. This ensures that the generated insertion time period satisfies the state connection requirements between adjacent tasks while retaining operational space for subsequent observation optimization. Ultimately, in engineering scenarios with limited single-satellite resources, sensitive response time, and dynamic task influx, it balances the determinism of scheduling results, the efficiency of generation speed, and the rationality of time utilization, improving the robustness, reproducibility, and adaptability of task queue on-orbit or near-real-time ground planning.

[0115] One optional embodiment of this specification determines the preceding transition time period between the preceding reference task and the candidate task, including: When the preceding reference task and the candidate task satisfy the continuous imaging task constraint, the preceding transition time period is determined based on the equipment maneuver time of the task execution equipment in executing the preceding reference task and the candidate task; If the preceding reference task and candidate task do not meet the continuous imaging task constraint, the preceding transition time period is determined based on the device restart time of the task execution device.

[0116] Continuous imaging mission constraints are compatibility conditions set for whether two adjacent missions can be directly executed consecutively. A continuous imaging mission constraint is satisfied when the equipment state after one mission concludes is still within the acceptable start-up tolerance range for the next mission, and the total duration of the merged missions is less than the maximum single-run duration of the equipment executing the mission. The functions of continuous imaging mission constraints include differentiating the calculation methods for transition time periods (e.g., using equipment maneuver time instead of restart time), supporting mission merging decisions, reducing resource idle time during non-imaging periods, improving the efficiency of onboard energy and time resource utilization, and providing a basis for differentiated adjustments to time window sliding strategies. Continuous imaging mission constraints can be dynamically determined through table lookups (e.g., optical satellite maneuverability tables or SAR satellite maneuverability tables), function mappings (e.g., L(x)), or real-time state comparisons.

[0117] Equipment maneuver time is the actual time consumed by the equipment to switch from one operating state to another. Its value is determined by the equipment's own dynamic characteristics, control accuracy requirements, and the degree of difference in the target state. Equipment maneuver time is used as a component of the transition time period and participates in the quantitative calculation of the offset in the time window sliding operation. That is, it is used to determine the immediate transition time period when the immediate reference task and the candidate task satisfy the continuous imaging task constraint, that is, when the immediate reference task and the candidate task can be executed together; and to determine the immediate transition time period when the immediate subsequent reference task and the candidate task satisfy the continuous imaging task constraint, that is, when the immediate subsequent reference task and the candidate task can be executed together.

[0118] Device restart time is the time it takes for a task-executing device to re-enter a ready-to-execute state after completely terminating its current operating state. The device restart time is affected by various factors such as device type, power recovery characteristics, storage media read speed, temperature environment, firmware version, and security policy level. It serves as a core component of the transition time period under non-continuous imaging task constraints, used to determine the immediate preceding / immediate following transition time period when the preceding / following task and candidate task do not meet the continuous imaging task constraints.

[0119] This specification's embodiments couple the logic for determining the immediate transition time period with the determination of continuous imaging task constraints. During task insertion scheduling, based on the time difference between adjacent tasks, either the equipment maneuver time or the equipment restart time is selected as the evaluation criterion for the transition time period. When two tasks can image continuously, a shorter equipment maneuver time is used to improve the density of time resource utilization; when there is a significant time gap, the equipment restart time is used to ensure execution reliability. This makes the generated insertion time period more closely match the actual response capability of the onboard equipment, significantly enhancing the adaptability and robustness of the scheduling scheme to multi-scenario task scheduling and dynamic task mixed sequences while maintaining the efficiency and determinism of the rule-based method.

[0120] An optional embodiment of this specification is characterized in that determining the successor transition time period between the successor reference task and the candidate task includes: When the successor reference task and the candidate task satisfy the continuous imaging task constraint, the successor transition time period is determined based on the equipment maneuver time of the task execution equipment in executing the successor reference task and the candidate task; If the successor reference task and candidate task do not meet the continuous imaging task constraint, the successor transition time period is determined based on the device restart time of the task execution device.

[0121] This specification's embodiments couple the logic for determining the immediate transition time period with the determination of continuous imaging task constraints. During task insertion scheduling, based on the time difference between adjacent tasks, either the equipment maneuver time or the equipment restart time is selected as the evaluation criterion for the transition time period. When two tasks can image continuously, a shorter equipment maneuver time is used to improve the density of time resource utilization; when there is a significant time gap, the equipment restart time is used to ensure execution reliability. This makes the generated insertion time period more closely match the actual response capability of the onboard equipment, significantly enhancing the adaptability and robustness of the scheduling scheme to multi-scenario task scheduling and dynamic task mixed sequences while maintaining the efficiency and determinism of the rule-based method.

[0122] In one optional embodiment of this specification, after inserting the candidate task at the insertion position, the method further includes: Remove the last scheduled task from the task queue; Based on the observable time period corresponding to the last planned task, determine the imaging front and side view time of the task execution device when executing the last planned task; Determine the task center timestamp of the last planned task based on the time window corresponding to the last planned task. Based on the difference between the imaging frontal and lateral viewing time and the mission center timestamp, the time window corresponding to the last planned mission is shifted to obtain the observation-optimized time window corresponding to the last planned mission.

[0123] The last planned task is the scheduled task in the task queue that is arranged chronologically and is in the latest execution position. It is the task with the largest execution termination timestamp among all planned tasks in the queue. It can be dynamically updated during task insertion, deletion, and optimization. It can be understood as the last planned task on the timeline with a definite start and end timestamp at any given time snapshot, and which has not yet been canceled or replaced. The last planned task can serve as the primary adjustment target for observation optimization strategies, support the alignment calculation of imaging front and side-view timestamps with the task center timestamp, trigger subsequent queue traversal optimization processes, and provide a right boundary reference for task merging logic.

[0124] The observable time period is the time interval within which the mission-executing equipment has the effective data acquisition capability for a specific target area and a specific mission. The observable time period dynamically evolves with changes in orbit prediction accuracy, target geographic coordinates, equipment pointing capability, solar illumination angle, shadow duration, power supply charging / discharging status, and real-time environmental parameters. It can be understood as the theoretically permissible set of time segments within a given mission planning cycle that the equipment can complete a single full observation operation, typically manifested as one or more continuous or discrete time segments. It serves as the initial input range for generating candidate mission time windows, the basis for calculating imaging front and side-view times, the upper and lower bound constraints for preceding / following idle time windows, and provides a reference benchmark for optimizing observation quality.

[0125] Imaging frontal and side-looking time is the time point within the observable time period when the line of sight of the mission execution equipment reaches the geometrically optimal pointing state relative to the target area. This time point usually corresponds to the moment when the equipment achieves the minimum observation zenith angle, the highest ground resolution, the shortest slant distance, or the best signal-to-noise ratio for the target center position. The role of imaging frontal and side-looking time includes serving as a core reference benchmark for optimizing observation quality and supporting the time window movement strategy of the last planned task and subsequent preceding tasks. The value of imaging frontal and side-looking time can be derived in real time on-orbit through an embedded geometry engine, or it can be pre-generated in the ground planning stage based on high-precision orbit prediction and target modeling.

[0126] The difference between the imaging frontal and side-view time and the mission center timestamp represents the offset between the actual optimal imaging time (imaging frontal and side-view time) and the point in the time window corresponding to the currently planned task on the time axis. In other words, it represents the degree of deviation of the task execution window from the geometrically optimal observation point in the time dimension. This difference reflects the dynamic deviation between the task scheduling result and the ideal observation conditions. The sign indicates the direction of the offset; a positive value indicates the mission center is later than the frontal and side-view time, and a negative value indicates it is earlier. The magnitude of the deviation is reflected by the value. The difference between the imaging frontal and side-view time and the mission center timestamp serves as a driving signal for observation quality optimization. When the difference is non-zero, it indicates that there is room to improve the geometric quality of the imaging by sliding the time window. This difference is directly used to calculate the shift time, thereby adjusting the task start and end timestamps. It is both a measure of the misalignment between the current scheduling scheme and the physical observable conditions, and a direct input to trigger subsequent flexible adjustments to the time window.

[0127] Observation optimization is a process of targeted adjustments to the observation quality during the execution period of a task, based on the initial scheduling of the task time window. By fine-tuning the start and end timestamps, observation optimization aims to bring the actual imaging time closer to ideal observation conditions, such as the frontal and side-view times, while ensuring orbital visibility, energy supply, and seamless transitions between tasks. The logic of observation optimization is to iteratively approach the scheduling results, which were originally primarily focused on feasibility, towards high-quality feasibility, thereby extending the proportion of effective imaging time within the observable window and freeing up more time for subsequent tasks. Observation optimization employs a local sliding strategy, for example, starting from the last planned task and advancing step by step. It calculates a safe and feasible movement amount by combining the difference between the frontal and side-view imaging timestamps and the task center timestamp, the immediate preceding / immediate following transition constraints, and the capacity of the idle time window. This is a refined time calibration implemented on the existing queue structure, aimed at improving observation efficiency.

[0128] The embodiments in this specification, after the candidate task insertion operation is completed, immediately initiate an observation optimization procedure starting from the last planned task. Without increasing the global replanning overhead, the geometric computability of the observable time period and the imaging front and side view time is used to quantify the deviation between the task center timestamp and the optimal imaging time into an executable movement amount. Quality calibration is completed by the overall translation of the time window. In the end, a single task insertion not only meets the basic feasibility constraints, but also ensures the imaging quality, and enhances the observation robustness and response adaptability of the task queue in complex orbital environments.

[0129] In one optional embodiment of this specification, after determining the difference between the first imaging frontal side-view time and the mission center timestamp of the last planned task, and shifting the time window corresponding to the last planned task based on the difference to obtain the observation-optimized time window corresponding to the last planned task, the method further includes: According to the order of the planned tasks in the task queue, retrieve the other planned tasks in sequence except for the last planned task. For any other planned task, determine the immediate successor task to be executed after the other planned task, and determine the task transition time between the other planned task and the immediate successor task; The observable optimization time between other planned tasks and the successor task is determined based on the start timestamp of the successor task, the end timestamp of other planned tasks, and the task transition time between other planned tasks and the successor task. Based on the observable time periods corresponding to other planned tasks, determine the imaging front and side view time of the task execution equipment when performing other planned tasks; Determine the task center timestamps of other planned tasks based on the time windows corresponding to other planned tasks; The minimum value between the difference between other imaging front and side viewing times, the task center timestamps of other planned tasks, and the task transition times of other planned tasks and their successors, and the observable optimization times corresponding to other planned tasks is used to move the time window corresponding to the planned tasks in the region, thereby obtaining the second time window corresponding to the planned tasks after observation optimization.

[0130] Other planned tasks are all scheduled tasks in the task queue except for the last planned task, and are to be optimized by being traversed and processed in chronological order. After the last planned task completes the first round of observation optimization, the system selects the planned tasks that have not yet participated in observation optimization as other planned tasks according to the time execution order of each planned task in the queue, such as ascending or descending start time.

[0131] The task transition time between other planned tasks and their successors is the transition time necessary for the device to complete the state switch after the other planned tasks have ended and before the successors of the other planned tasks have started to execute. It can be obtained according to the task transition time calculation method mentioned above. In other words, the task transition time between other planned tasks and their successors can also be based on the time taken for the task execution device to switch between the state of executing other planned tasks and the state of executing successors, or the time taken for the device to restart.

[0132] The imaging frontal and lateral viewing times for other planned tasks are the specific moments when the line of sight of the task execution device reaches the geometrically optimal observation state relative to the target area of ​​other planned tasks.

[0133] The task center timestamp for other planned tasks is the midpoint of the time window set for that task, which is the arithmetic mean of its execution start timestamp and execution end timestamp.

[0134] One possible practical scenario is that the above process can be explained as follows: After scheduling all candidate tasks, attempt to move the imaging time of the planned candidate tasks to the frontal / side-view to optimize the observation angle. Let the queue of successfully planned tasks be denoted as . (Nsc represents the number of tasks in the successful queue).

[0135] 1. Process sequentially from back to front, starting with moving the object. : 1) Calculate the time for both frontal and lateral vision: ; 2) Calculate the current imaging center time: ; 3) Calculate the travel time: ; 4) If If so, the observation time window will be moved; otherwise, no action will be taken.

[0136] 2. Try moving them one by one. : 1) Calculate according to sub-steps 1) to 3) in step 1. The time of direct and lateral viewing, the time of image center, and the time of movement, when This indicates that there is a possibility of movement; proceed to step 2). 2) Calculate the remaining time for the successor task: If the current task and its successor task can be merged:

[0137] Then the conversion time: ; If the current task and its successor task cannot be merged: ; 3) Calculate the travel time: ; 4) Shift the observation time window: ; .

[0138] 3. After traversing all planned candidate tasks, the observation and optimization process ends.

[0139] This specification's embodiments, through the construction of a chain-like observation optimization mechanism, achieve progressive quality enhancement of the task queue from the end inwards. While ensuring scheduling determinism and real-time performance, it not only performs initial front-side alignment on the last planned task, but also traverses all other planned tasks in chronological order. For each other planned task, it dynamically identifies its successor task, calculates the task transition time between them constrained by the physical characteristics of the equipment, and derives a safe and usable observable optimization time window. Based on this, the minimum value of the deviation between the task's own imaging front-side time and its current task center timestamp, and the differences between other imaging front-side times, the task center timestamps of other planned tasks, and the task transition times between other planned tasks and their successors, is taken as the final movement amount. This ensures that each time window shift pursues geometric quality improvement while strictly avoiding squeezing successor tasks and violating the latency constraints of equipment state switching, significantly improving overall imaging consistency, resolution stability, and emergency response reliability in multi-task mixed scenarios.

[0140] One optional embodiment of this specification involves determining two adjacent reference tasks from a plurality of planned tasks based on candidate time windows corresponding to candidate tasks, including: Extract a first candidate task from at least one candidate task, wherein the first candidate task is any candidate task among the candidate tasks that has not undergone conflict checking; Based on the candidate time window corresponding to the first candidate task, two adjacent reference tasks are determined from multiple planned tasks.

[0141] Compare the time interval between two reference tasks and the candidate time window. If the comparison result shows no time conflict, determine the insertion position of the candidate task in the task queue, including: The comparison results are obtained by comparing the time interval between the two reference tasks with the candidate time window corresponding to the first candidate task. If the comparison result shows that there is no time conflict, determine the insertion position of the first candidate task in the task queue; If the comparison result indicates a time conflict, return to the step of extracting the first candidate task from at least one candidate task, until the comparison result indicates no time conflict, and determine the insertion position of the first candidate task in the task queue.

[0142] The first candidate task is a candidate task selected from multiple candidate tasks in a certain traversal order, which has not yet undergone time conflict checking and is awaiting conflict checking. This selection can be based on descending priority, ascending deadline, ascending window width, or random selection. Whenever a candidate task is extracted and conflict checking is completed, if it fails, the system automatically switches to the next unchecked candidate task and uses it as the new first candidate task for subsequent evaluation. The first candidate task is the starting point for triggering all insertion logic, including reference task location, idle window calculation, conversion time matching, and time window sliding. It is used to structure the search process in multi-candidate scenarios into a repeatable, interpretable, lightweight iterative process, avoiding the computational burden of exhaustive search or global sorting.

[0143] Conflict checking is a systematic verification process to determine whether there are irreconcilable overlaps in time resources or constraints between the time window of a candidate task and its potential insertion location and surrounding planned tasks. First, it determines whether the candidate time window falls entirely within the time gap between two adjacent planned tasks, i.e., the immediate predecessor and immediate successor reference tasks. Second, it calculates whether this gap, after deducting the immediate predecessor / immediate successor transition time periods, is still sufficient to accommodate the candidate task's own execution time. Then, considering equipment mobility, energy budget, and task transition logic, it confirms whether the adjusted time window satisfies all physical and operational constraints. The result is either a conflict exists or no conflict exists.

[0144] This specification's embodiments introduce an iterative insertion mechanism to achieve efficient, deterministic, and low-overhead scheduling decisions in multi-candidate task scenarios. It transforms the candidate combination verification problem into a linear process of sequential single-point verification, focusing on only one first candidate task at a time. Based on its candidate time window, it quickly locates the preceding / following reference task, performs hierarchical conflict checks, and the results are clear and interpretable. If a conflict occurs, it automatically advances to the next candidate without backtracking or state saving. The entire process avoids complex sorting, redundant calculations, and unpredictable delays, significantly reducing the load on the onboard processor and ground planning response latency, ensuring high reliability and robustness of the scheduling results.

[0145] In one optional embodiment of this specification, obtaining the meta-task corresponding to the task insertion request includes: Get the meta-task list corresponding to the task insertion request. The meta-task list consists of multiple candidate meta-tasks sorted according to a preset sorting criterion. The preset sorting criterion includes one or more of the following: preset task priority, request deadline, request time window, and task identifier. Extract the candidate metatasks that have not been executed and are at the top of the metatask list, and use them as metatasks.

[0146] The meta-task list is an ordered set of multiple candidate meta-tasks organized according to preset sorting criteria, used to support structured processing of task insertion requests. The composition and sorting logic of the meta-task list can be dynamically configured according to actual needs, such as sorting in ascending, descending, or composite weighted order based on one or more dimensions such as task priority, request deadline, observable window width, geographical urgency, user identifier weight, or historical response deviation. Each meta-task itself does not directly correspond to the final execution unit, but rather carries basic observation requirements and possible extensible attributes, serving as the raw input for generating specific candidate tasks.

[0147] Preset task priority is a numerical or level label that is assigned to a meta-task in advance during the task generation or reception phase. It is used to reflect the relative importance of the task in the competition for system resources. Its value can come from user instructions, emergency event level, scientific value assessment or contractual agreement, etc. It does not directly determine the execution time, but affects the sorting order among tasks of the same level.

[0148] The deadline is the latest time that a task must be completed, reflecting the time sensitivity of the task—an earlier deadline usually means a higher timeliness requirement, and it is often used as a secondary sorting criterion when priorities are the same.

[0149] The request time window is the start and end time interval specified by the task proposer that is allowed to be executed (i.e., "soft" or "hard" time constraints). Its width (end minus start) reflects the time flexibility of the task: the narrower the window, the more difficult it is to insert and the fewer opportunities to execute.

[0150] Task identifiers are codes or strings used to uniquely distinguish different meta-tasks, and can help implement fine-grained sorting or grouping strategies in multi-candidate scenarios.

[0151] In one possible example, the scheduling order of metatasks adopts a priority-first greedy strategy. In order to solve the "draw-and-win" problem of metatasks with the same priority, a multi-level sorting rule can be used for optimization.

[0152] First-level prioritization: Tasks with higher priority are listed first; this is the core requirement.

[0153] Second-level sorting: Among tasks with the same priority, the task with the earlier the deadline (the end of the request time window) is ranked higher. This is because we generally believe that the earlier a task's deadline, the smaller its "survival space" and the fewer choices it has.

[0154] The third level of sorting is based on the time window size, which is the smaller the difference between the end of the request time window and the beginning of the request time window. Tasks with smaller time windows have less flexibility and fewer opportunities to be executed.

[0155] Fourth-level sorting: Task ID, a final deterministic rule.

[0156] This specification's embodiments construct a multi-level configurable meta-task list mechanism. While ensuring that high-priority tasks receive priority resource guarantees, a greedy sorting strategy based on early deadlines, narrow windows, and small IDs systematically alleviates the scheduling tie problem among tasks of the same priority. This allows time-sensitive tasks with low execution flexibility to enter the conflict checking and insertion process earlier, significantly improving the responsiveness of urgent tasks and the insertion success rate of narrow-window tasks. In complex task flows with multi-source concurrency, heterogeneous windows, and intertwined priorities, the interpretability and engineering robustness of scheduling decisions are maintained.

[0157] In one optional embodiment of this specification, after inserting the candidate task at the insertion position, the method further includes: Based on the time window corresponding to the planned tasks in the task queue and the maximum single running time of the task execution device, the planned tasks in the task queue are merged to obtain the merged task queue.

[0158] The maximum single-run time period of a task execution device is the longest duration during which the device is allowed to execute a task under continuous power-on or continuous operation. The maximum single-run time period of a task execution device serves as a termination condition for task merging operations, an upper bound constraint supporting time window sliding and backward adjustment, and a safety pruning mechanism for movement in observable optimization, among other things.

[0159] One example can be seen Figure 4 , Figure 4 A schematic diagram of a task merging process provided for one embodiment of this specification includes: Based on the merge ID of the planned candidate tasks, the planned candidate tasks in the successful planning queue are finally merged to obtain the atomic task sequence.

[0160] 1. Atomic task IDs are generated sequentially according to time. 2. The atomic task should record the imaging start and end time information of all subtasks and execute the corresponding delay instruction table at the corresponding time.

[0161] 3. Set the planning trigger flag Plan_Trigger_Flag to 0.

[0162] This specification's embodiments introduce a queue merging mechanism based on the maximum single running time period after candidate task insertion. Under the premise of equipment physical boundaries, it automatically identifies planned tasks that are close in time, compatible in type, and continuous in state, and seamlessly stitches or merges their corresponding time windows with the minimum interval. This reduces the number of equipment start-ups and shutdowns, reduces energy and time consumption during non-imaging periods, increases the proportion of total single-track observation time, enhances the time utilization density of resources and system-level task throughput, and provides scheduling enhancement capabilities to extend effective observation time and support task scheduling.

[0163] The following is in conjunction with the appendix Figure 5 , Figure 5 This document provides a flowchart illustrating the processing steps of a satellite mission planning method as an embodiment of the present specification, further explaining the satellite mission planning method.

[0164] Startup and initialization phase: The process starts from the start node, sets the planning start flag to 1, performs pre-sorting of meta-tasks, then obtains the list of meta-tasks to be inserted, and sorts the candidate meta-tasks contained therein according to the preset multi-level sorting rules (priority → deadline → window width → task ID); initializes index variables i = 0 (for traversing the meta-task list) and j = 0 (for traversing candidate tasks), and begins traversing the queue of planned candidate tasks.

[0165] Outer loop: Processes meta-tasks one by one (controlled by i): Has all candidate tasks been traversed? — If not, proceed to inner candidate task processing; if yes, check if the entire meta-task list has been processed; if not, update the meta-task status and set i = i+1, then return to continue processing the next meta-task; if completed, proceed to the final optimization and termination process.

[0166] Inner loop: Try inserting candidate tasks one by one (controlled by j): For the current meta-task, generate at least one candidate task (such as variations of different time windows or different imaging modes), extract the j-th first candidate task, and calculate its achievement time (i.e., the theoretical executable interval: Task_Start_Time = Task_Visible_Start_Time, Task_End_Time = Task_Start_Time + Task_Visible_WorkTime). Entering the core judgment: Step ①: Check if the visible time window constraint is met—that is, whether the execution period of the candidate task falls within its observable time period; if not, skip the candidate, j = j+1, and continue to the next candidate; Step 2: Conflict Check – Locate the preceding / following reference task, calculate the idle interval between them, and compare whether it can accommodate the candidate task and its required preceding / following transition time; if there is a conflict (such as insufficient idle time or inability to meet the transition time requirement), then j = j+1, and try the next candidate task. If there is no conflict, the insertion position is determined, and subsequent processing begins.

[0167] Insertion and feedback processing: Execute "Task Scheduling and Conflict Resolution": Insert the candidate task into the corresponding position in the queue and return the insertion result. If Return=0 (insertion successful), then: update the time window of the task in the queue (including possible backward adjustment); add it to the queue of planned candidate tasks; sort the queue of successfully planned tasks by time; execute "Task Merge ID Update" (prepare the identifier for subsequent merge operations); trigger "Planned Candidate Task Observation Optimization" (optimize the last task first, then traverse other planned tasks in sequence, and fine-tune the time window according to the front-side alignment principle); finally, execute "Executable Atomic Task Sequence" generation, ready for delivery and execution.

[0168] If Return=1 (insertion failed), then: according to the logic in the diagram, the time window of the candidate task is adjusted backward. , ), where Δ_slide is derived from the predecessor / follower time difference or observable optimization time, etc.; then instead of increasing j, it returns to the conflict checking phase and tries to insert again with the corrected time window - reflecting the lightweight feedback mechanism of "correction upon failure and retry after correction".

[0169] Termination Phase: Once all meta-tasks have been processed (i has traversed the list), the process enters the "End" node, outputting the final, inserted, optimized, and merged sequence of executable tasks.

[0170] The satellite mission planning method provided in one or more embodiments of this specification includes: responding to a mission insertion request, obtaining a meta-task corresponding to the mission insertion request and a mission queue of the mission execution device, wherein the mission queue includes multiple planned missions and time windows corresponding to each planned mission; determining at least one candidate time window based on the meta-task, and constructing candidate missions corresponding to at least one candidate time window; determining two adjacent reference missions from multiple planned missions based on the candidate time windows corresponding to the candidate missions; comparing the time interval between the two reference missions and the candidate time windows, and if the comparison result shows no time conflict, determining the insertion position of the candidate mission in the mission queue; and inserting the candidate mission at the insertion position.

[0171] By responding to task insertion requests, the system dynamically acquires meta-tasks and the current task queue, and determines corresponding candidate time windows and candidate tasks based on the meta-tasks. Then, using the time window information of planned tasks in the task queue, it accurately locates two adjacent reference tasks. By comparing their time intervals with the candidate time windows to determine if there are any conflicts, it determines the feasible insertion position of the candidate task. This process avoids replanning the entire task sequence, ensuring the determinism and real-time nature of the scheduling results while effectively utilizing the time gaps between tasks. This improves the utilization efficiency of onboard resources and the responsiveness to new tasks, thereby enhancing the local optimization capability and adaptability of the scheduling scheme without sacrificing computational efficiency.

[0172] Corresponding to the above method embodiments, this specification also provides embodiments of a satellite mission planning apparatus. Figure 6 This is a schematic diagram of a satellite mission planning device provided as an embodiment of this specification. Figure 6 As shown, the device includes: The request acquisition module 602 is configured to, in response to a task insertion request, acquire the meta-task corresponding to the task insertion request and the task queue of the task execution device, wherein the task queue includes multiple planned tasks and the time window corresponding to each planned task. The task construction module 604 is configured to determine at least one candidate time window based on the meta-task and construct candidate tasks corresponding to at least one candidate time window; The determination module 606 is configured to determine two adjacent reference tasks from multiple planned tasks based on the candidate time windows corresponding to the candidate tasks. The comparison module 608 is configured to compare the time interval and candidate time window between two reference tasks. If the comparison result shows that there is no time conflict, the insertion position of the candidate task in the task queue is determined. Insertion module 610 is configured to insert candidate tasks at the insertion position.

[0173] The comparison module 608 is further configured to determine the time interval between two reference tasks based on the termination timestamp of the preceding reference task and the start timestamp of the succeeding reference task.

[0174] The comparison module 608 is further configured to determine the preceding transition time period between the preceding reference task and the candidate task, and the following transition time period between the following reference task and the candidate task, if the comparison result shows that there is no time conflict; and to determine the insertion time period of the candidate task in the task queue based on the preceding and following transition time periods.

[0175] The comparison module 608 is further configured to: determine the preceding idle time window based on the termination timestamp and execution start timestamp of the preceding reference task; if the preceding idle time window is smaller than the preceding transition time period, determine the preceding time difference based on the difference between the preceding idle time window and the preceding transition time period; slide the time window backward based on the preceding time difference to obtain an updated time window; determine the following idle time window based on the execution start timestamp and execution end timestamp of the following reference task; if the following idle time window is smaller than the following transition time period, determine the following time difference based on the difference between the termination timestamp and execution start timestamp of the following reference task; slide the time window backward based on the following time difference to obtain an updated time window; and determine the time window as the insertion time period of the candidate task in the task queue.

[0176] The comparison module 608 is further configured to determine the preceding transition time period based on the device maneuver time of the task execution device when the preceding reference task and the candidate task meet the continuous imaging task constraint; and to determine the preceding transition time period based on the device restart time of the task execution device when the preceding reference task and the candidate task do not meet the continuous imaging task constraint.

[0177] If the successor reference task and the candidate task satisfy the continuous imaging task constraint, the successor transition time period is determined based on the equipment maneuver time of the task execution equipment during the execution of the successor reference task and the candidate task; if the successor reference task and the candidate task do not satisfy the continuous imaging task constraint, the successor transition time period is determined based on the equipment restart time of the task execution equipment.

[0178] The satellite mission planning device also includes an observation optimization module, which is configured to extract the last planned mission from the mission queue; determine the imaging front and side-view time of the mission execution equipment when executing the last planned mission based on the observable time period corresponding to the last planned mission; determine the mission center timestamp of the last planned mission based on the time window corresponding to the last planned mission; and shift the time window corresponding to the last planned mission based on the difference between the imaging front and side-view time and the mission center timestamp to obtain the observation-optimized time window corresponding to the last planned mission.

[0179] The observation optimization module is further configured to sequentially acquire all planned tasks except the last planned task in the task queue according to their order; for any other planned task, determine the immediate successor task to be executed after the other planned task, and determine the task transition time between the other planned task and the immediate successor task; determine the observable optimization time between the other planned task and the immediate successor task based on the start timestamp of the immediate successor task, the end timestamp of the other planned task, and the task transition time between the other planned task and the immediate successor task; determine the imaging front and side view time of the task execution device when executing the other planned task according to the observable time period corresponding to the other planned task; determine the task center timestamp of the other planned task according to the time window corresponding to the other planned task; determine the minimum value between the difference between the other imaging front and side view time, the task center timestamp of the other planned task, and the task transition time between the other planned task and the immediate successor task, and the observable optimization time corresponding to the other planned task, and move the time window corresponding to the planned task in the region to obtain the second time window corresponding to the planned task after observation optimization.

[0180] The determination module 606 is further configured to extract a first candidate task from at least one candidate task, wherein the first candidate task is any candidate task among the candidate tasks that has not undergone conflict checking; and to determine two adjacent reference tasks from multiple planned tasks based on the candidate time window corresponding to the first candidate task.

[0181] The comparison module 608 is further configured to compare the time interval between two reference tasks and the candidate time window corresponding to the first candidate task to obtain the comparison result; if the comparison result is that there is no time conflict, the insertion position of the first candidate task in the task queue is determined; if the comparison result is that there is a time conflict, the step of extracting the first candidate task from at least one candidate task is returned until the comparison result is that there is no time conflict and the insertion position of the first candidate task in the task queue is determined.

[0182] The request acquisition module 602 is further configured to acquire the meta-task list corresponding to the task insertion request. The meta-task list consists of multiple candidate meta-tasks sorted according to a preset sorting criterion, which includes one or more of the following: preset task priority, request deadline, request time window, and task identifier. The candidate meta-tasks that have not been executed and are at the top of the meta-task list are extracted as meta-tasks.

[0183] The satellite mission planning device also includes a merging module, which is configured to merge the planned tasks in the mission queue according to the time window corresponding to the planned tasks in the mission queue and the maximum single operation time of the mission execution equipment, so as to obtain a merged mission queue.

[0184] The satellite mission planning apparatus provided in one or more embodiments of this specification includes: a request acquisition module 602, configured to acquire, in response to a mission insertion request, a meta-task corresponding to the mission insertion request and a mission queue of a mission execution device, wherein the mission queue includes multiple planned missions and time windows corresponding to each planned mission; a mission construction module 604, configured to determine at least one candidate time window based on the meta-task and construct candidate missions corresponding to at least one candidate time window; a determination module 606, configured to determine two adjacent reference missions from multiple planned missions based on the candidate time windows corresponding to the candidate missions; a comparison module 608, configured to compare the time interval between the two reference missions and the candidate time windows, and if the comparison result shows no time conflict, determine the insertion position of the candidate mission in the mission queue; and an insertion module 610, configured to insert the candidate mission at the insertion position.

[0185] By responding to task insertion requests, the system dynamically acquires meta-tasks and the current task queue, and determines corresponding candidate time windows and candidate tasks based on the meta-tasks. Then, using the time window information of planned tasks in the task queue, it accurately locates two adjacent reference tasks. By comparing their time intervals with the candidate time windows to determine if there are any conflicts, it determines the feasible insertion position of the candidate task. This process avoids replanning the entire task sequence, ensuring the determinism and real-time nature of the scheduling results while effectively utilizing the time gaps between tasks. This improves the utilization efficiency of onboard resources and the responsiveness to new tasks, thereby enhancing the local optimization capability and adaptability of the scheduling scheme without sacrificing computational efficiency.

[0186] The above is a schematic scheme of a satellite mission planning device according to this embodiment. It should be noted that the technical solution of this satellite mission planning device and the technical solution of the satellite mission planning method described above belong to the same concept. For details not described in detail in the technical solution of the satellite mission planning device, please refer to the description of the technical solution of the satellite mission planning method described above.

[0187] Figure 7 This is a structural block diagram of a computing device according to one embodiment of this specification. The components of the computing device 700 include, but are not limited to, a memory 710 and a processor 720. The processor 720 is connected to the memory 710 via a bus 730, and a database 750 is used to store data.

[0188] The computing device 700 also includes an access device 740, which enables the computing device 700 to communicate via one or more networks 760. Examples of these networks include Public Switched Telephone Network (PSTN), Local Area Network (LAN), Wide Area Network (WAN), Personal Area Network (PAN), or combinations of communication networks such as the Internet. The access device 740 may include one or more of any type of wired or wireless network interface (e.g., Network Interface Card (NIC)), such as an IEEE 802.11 Wireless Local Area Networks (WLAN) interface, a Wi-MAX (World Interoperability for Microwave Access) interface, an Ethernet interface, a Universal Serial Bus (USB) interface, a cellular network interface, a Bluetooth interface, a Near Field Communication (NFC) interface, and so on.

[0189] In one embodiment of this specification, the above-described components of the computing device 700 and Figure 7 Other components, not shown, can also be connected to each other, for example, via a bus. It should be understood that... Figure 7 The block diagram of the computing device shown is for illustrative purposes only and is not intended to limit the scope of this specification. Those skilled in the art can add or replace other components as needed.

[0190] The computing device 700 can be any type of stationary or mobile computing device, including mobile computers or mobile computing devices (e.g., tablet computers, personal digital assistants, laptop computers, notebook computers, netbooks, etc.), mobile phones (e.g., smartphones), wearable computing devices (e.g., smartwatches, smart glasses, etc.) or other types of mobile devices, or stationary computing devices such as desktop computers or personal computers (PCs). The computing device 700 can also be a mobile or stationary server.

[0191] The processor 720 is used to execute computer programs / instructions, which, when executed by the processor, implement the steps of the satellite mission planning method described above.

[0192] The above is a schematic representation of a computing device according to this embodiment. It should be noted that the technical solution of this computing device and the technical solution of the satellite mission planning method described above belong to the same concept. Details not described in detail in the technical solution of the computing device can be found in the description of the technical solution of the satellite mission planning method described above.

[0193] An embodiment of this specification also provides a computer-readable storage medium storing a computer program / instructions that, when executed by a processor, implement the steps of the satellite mission planning method described above.

[0194] The above is an illustrative scheme of a computer-readable storage medium according to this embodiment. It should be noted that the technical solution of this storage medium belongs to the same concept as the technical solution of the satellite mission planning method described above. Details not described in detail in the technical solution of the storage medium can be found in the description of the technical solution of the satellite mission planning method described above.

[0195] An embodiment of this specification also provides a computer program product, including a computer program / instructions that, when executed by a processor, implement the steps of the satellite mission planning method described above.

[0196] The above is an illustrative scheme of a computer program product according to this embodiment. It should be noted that the technical solution of this computer program product and the technical solution of the satellite mission planning method described above belong to the same concept. For details not described in detail in the technical solution of the computer program product, please refer to the description of the technical solution of the satellite mission planning method described above.

[0197] The foregoing has described specific embodiments of this specification. Other embodiments are within the scope of the appended claims. In some cases, the actions or steps recited in the claims may be performed in a different order than that shown in the embodiments and may still achieve the desired result. Furthermore, the processes depicted in the drawings do not necessarily require the specific or sequential order shown to achieve the desired result. In some embodiments, multitasking and parallel processing are possible or may be advantageous.

[0198] The computer instructions include computer program code, which may be in the form of source code, object code, executable file, or certain intermediate forms. The computer-readable medium may include: any entity or device capable of carrying the computer program code, recording media, USB flash drive, portable hard drive, magnetic disk, optical disk, computer memory, read-only memory (ROM), random access memory (RAM), electrical carrier signals, telecommunication signals, and software distribution media, etc. It should be noted that the content included in the computer-readable medium may be appropriately added or removed according to the requirements of patent practice. For example, in some regions, according to patent practice, computer-readable media may not include electrical carrier signals and telecommunication signals.

[0199] It should be noted that, for the sake of simplicity, the foregoing method embodiments are all described as a series of actions. However, those skilled in the art should understand that the embodiments in this specification are not limited to the described order of actions, because according to the embodiments in this specification, some steps can be performed in other orders or simultaneously. Furthermore, those skilled in the art should also understand that the embodiments described in this specification are all preferred embodiments, and the actions and modules involved are not necessarily essential to the embodiments in this specification.

[0200] In the above embodiments, the descriptions of each embodiment have different focuses. For parts not described in detail in a certain embodiment, please refer to the relevant descriptions of other embodiments.

[0201] The preferred embodiments disclosed above are merely illustrative of this specification. The optional embodiments do not exhaustively describe all details, nor do they limit the invention to the specific implementations described. Clearly, many modifications and variations can be made based on the embodiments described herein. These embodiments are selected and specifically described in this specification to better explain the principles and practical applications of the embodiments, thereby enabling those skilled in the art to better understand and utilize this specification. This specification is limited only by the claims and their full scope and equivalents.

Claims

1. A satellite mission planning method, characterized in that, include: In response to a task insertion request, the meta-task corresponding to the task insertion request and the task queue of the task execution device are obtained, wherein the task queue includes multiple planned tasks and time windows corresponding to each planned task. Based on the meta-task, at least one candidate time window is determined, and candidate tasks corresponding to the at least one candidate time window are constructed. Based on the candidate time window corresponding to the candidate task, two adjacent reference tasks are determined from the plurality of planned tasks; Compare the time interval between two reference tasks with the candidate time window. If the comparison result shows that there is no time conflict, determine the insertion position of the candidate task in the task queue. Insert the candidate task into the insertion position.

2. The method according to claim 1, characterized in that, The candidate time window includes a start timestamp and an end timestamp, and the two reference tasks include a preceding reference task and a succeeding reference task. In the process of comparing the time interval between two reference tasks and the candidate time window, if the comparison result indicates no time conflict, and determining the candidate task's insertion position in the task queue, the process further includes: The time interval between the two reference tasks is determined based on the termination timestamp of the preceding reference task and the start timestamp of the succeeding reference task.

3. The method according to claim 2, characterized in that, The insertion position includes the insertion time period; If the comparison result indicates no time conflict, determining the insertion position of the candidate task in the task queue includes: If the comparison result shows that there is no time conflict, determine the preceding transition time period between the preceding reference task and the candidate task, and determine the following transition time period between the following reference task and the candidate task. Based on the preceding and following transition time periods, the insertion time period of the candidate task in the task queue is determined.

4. The method according to claim 3, characterized in that, The time window includes an execution start timestamp and an execution end timestamp; Determining the insertion time of the candidate task in the task queue based on the preceding and succeeding transition time periods includes: The preceding idle time window is determined based on the termination timestamp of the preceding reference task and the execution start timestamp. If the preceding idle time window is smaller than the preceding transition time period, the preceding time difference is determined based on the difference between the preceding idle time window and the preceding transition time period; Based on the immediate preceding time difference, the time window is slid backward to obtain the updated time window; The immediate idle time window is determined based on the execution start timestamp and execution end timestamp of the immediate reference task. If the immediate idle time window is less than the immediate transition time period, the immediate time difference is determined based on the difference between the termination timestamp of the immediate reference task and the execution start timestamp. Based on the immediate successor time difference, the time window is slid backward to obtain the updated time window; The time window is determined as the time period during which the candidate task is inserted into the task queue.

5. The method according to claim 3, characterized in that, Determining the preceding transition time period between the preceding reference task and the candidate task includes: When the preceding reference task and the candidate task satisfy the continuous imaging task constraint, the preceding transition time period is determined based on the device maneuver time of the task execution device in executing the preceding reference task and the candidate task; If the preceding reference task and the candidate task do not meet the continuous imaging task constraint, the preceding transition time period is determined based on the device restart time of the task execution device.

6. The method according to claim 3, characterized in that, Determining the successor transition time period between the successor reference task and the candidate task includes: When the successor reference task and the candidate task satisfy the continuous imaging task constraint, the successor transition time period is determined based on the device maneuver time of the task execution device in executing the successor reference task and the candidate task; If the successor reference task and the candidate task do not satisfy the continuous imaging task constraint, the successor transition time period is determined based on the device restart time of the task execution device.

7. The method according to any one of claims 1-6, characterized in that, After inserting the candidate task at the insertion position, the method further includes: Extract the last planned task from the task queue; Based on the observable time period corresponding to the last planned task, determine the imaging frontal and side-view time of the task execution device when executing the last planned task; Based on the time window corresponding to the last planned task, determine the task center timestamp of the last planned task; Based on the difference between the imaging frontal and lateral viewing time and the task center timestamp, the time window corresponding to the last planned task is moved to obtain the observation-optimized time window corresponding to the last planned task.

8. The method according to claim 7, characterized in that, After determining the difference between the first imaging frontal side view time and the task center timestamp of the last planned task, and shifting the time window corresponding to the last planned task based on the difference to obtain the observation-optimized time window corresponding to the last planned task, the method further includes: According to the order of the planned tasks in the task queue, retrieve the other planned tasks in sequence except for the last planned task. For any other planned task, determine the immediate successor task to be executed after the other planned task, and determine the task transition time between the other planned task and the immediate successor task; The observable optimization time between the other planned tasks and the successor task is determined based on the start timestamp of the successor task, the end timestamp of the other planned tasks, and the task transition time between the other planned tasks and the successor task. Based on the observable time periods corresponding to the other planned tasks, determine the imaging front and side view time of the task execution device when executing the other planned tasks; Based on the time windows corresponding to the other planned tasks, determine the task center timestamps of the other planned tasks; The minimum value between the other imaging front and side viewing times, the task center timestamps of the other planned tasks, and the task transition times between the other planned tasks and the successor tasks, and the observable optimization time corresponding to the other planned tasks is determined. The time window corresponding to the planned tasks in the region is then shifted to obtain the time window corresponding to the other planned tasks after observation optimization.

9. The method according to claim 1, characterized in that, The step of determining two adjacent reference tasks from the plurality of planned tasks based on the candidate time windows corresponding to the candidate tasks includes: Extract a first candidate task from at least one candidate task, wherein the first candidate task is any candidate task among the candidate tasks that has not undergone conflict checking; Based on the candidate time window corresponding to the first candidate task, two adjacent reference tasks are determined from the plurality of planned tasks; The comparison of the time interval between two reference tasks and the candidate time window, if the comparison result indicates no time conflict, determines the insertion position of the candidate task in the task queue, including: The comparison results are obtained by comparing the time interval between the two reference tasks with the candidate time window corresponding to the first candidate task. If the comparison result shows that there is no time conflict, determine the insertion position of the first candidate task in the task queue; If the comparison result indicates a time conflict, return to the step of extracting the first candidate task from at least one candidate task until the comparison result indicates no time conflict, and determine the insertion position of the first candidate task in the task queue.

10. The method according to claim 1, characterized in that, The step of obtaining the meta-task corresponding to the task insertion request includes: Obtain the meta-task list corresponding to the task insertion request, wherein the meta-task list consists of multiple candidate meta-tasks sorted according to a preset sorting criterion, the preset sorting criterion including one or more of the following: preset task priority, request deadline, request time window, and task identifier. Extract the candidate metatasks that have not been executed and are at the top of the metatask list, and use them as metatasks.

11. The method according to claim 1, characterized in that, After inserting the candidate task at the insertion position, the method further includes: Based on the time window corresponding to the planned tasks in the task queue and the maximum single running time of the task execution device, the planned tasks in the task queue are merged to obtain the merged task queue.

12. A satellite mission planning device, characterized in that, include: The request acquisition module is configured to, in response to a task insertion request, acquire the meta-task corresponding to the task insertion request and the task queue of the task execution device, wherein the task queue includes multiple planned tasks and time windows corresponding to each planned task. The task construction module is configured to determine at least one candidate time window based on the meta-task, and construct candidate tasks corresponding to the at least one candidate time window; The determination module is configured to determine two adjacent reference tasks from the plurality of planned tasks based on the candidate time windows corresponding to the candidate tasks. The comparison module is configured to compare the time interval between two reference tasks with the candidate time window. If the comparison result shows that there is no time conflict, the module determines the insertion position of the candidate task in the task queue. An insertion module is configured to insert the candidate task into the insertion position.

13. A computing device, characterized in that, include: Memory and processor; The memory is used to store computer programs / instructions, and the processor is used to execute the computer programs / instructions, which, when executed by the processor, implement the steps of the method according to any one of claims 1 to 11.

14. A computer-readable storage medium, characterized in that, The device stores a computer program / instructions that, when executed by a processor, implement the steps of the method according to any one of claims 1 to 11.

15. A computer program product comprising a computer program / instructions, characterized in that, When the computer program / instructions are executed by the processor, they implement the steps of the method according to any one of claims 1 to 11.

Images