Space-based space target observation autonomous task planning method based on two-stage planning

Abstract

The invention relates to a space-based space target observation autonomous task planning method based on two-stage planning, and the method comprises the following specific steps: 1, carrying out the first-stage planning: calculating the visible duration of all targets, and forming an array visibletime; and according to the length of the visible time in the visibletime, according to the logic of the target of which the length of the visible time is planned firstly, carrying out first-section planning on each target once in sequence, and summarizing the planning results into a first-section planning result array restsfirstplan, and according to the length of the visible time in the visibletime, according to the logic of the target of which the length of the visible time is planned firstly. According to the method, by using a rule-based two-stage task planning thought, the problem that space-based space multi-target observation autonomous task planning calculation amount is large is solved, and the observation task planning problem can be solved by using limited computing power resources on a satellite.

Description

Technical Field

[0001] The invention belongs to the technical field of satellite mission planning, and in particular relates to a space-based space target observation autonomous mission planning method based on two-stage planning. Background Art

[0002] This technology is aimed at the problem of autonomous mission planning for space-based multi-target observation. Current research mainly focuses on space-based ground target observation, and there is less research on space observation problems. In this field, random optimization algorithms such as genetic algorithms and particle swarm algorithms are often used to solve this problem. Such methods can obtain better mission planning results, but require greater hardware computing power. The onboard computers on some satellites cannot provide the computing power required by such methods, making it difficult to use such methods for onboard autonomous observation mission planning. Summary of the invention

[0003] The purpose of the present invention is to address the problems existing in the above-mentioned prior art and to propose a method for autonomous task planning of space-based space target observation based on two-stage planning. The specific steps are as follows:

[0004] Step 1, first stage planning: calculate the visible duration of all targets to form an array visible_time; according to the length of the visible duration in visible_time, follow the logic of planning the targets with shorter visible duration first, perform the first stage planning for each target in turn, and summarize the planning results into the first stage planning result array results_first_plan; complete the first stage planning for each target once, check the time conflict between the result window selected by this planning and all the windows in all_wins, set the sign quantity sign1 of the conflicting windows in all_wins to false, and repeat until all targets complete the first stage planning once;

[0005] Step 2, second stage planning: Mix all windows in the first stage planning results_first_plan and all windows in the total window library all_wins and put them into the second stage planning window material array

[0006] original_wins_last_plan; using the windows in original_wins_last_plan as materials, perform a preliminary window screening for each target, and delete windows that do not meet the screening requirements; taking satellites as units, perform time conflict resolution and camera rotation constraint resolution for the windows belonging to each satellite in original_wins_last_plan in turn, and merge the remaining windows into the second planning result results_last_plan; balance the satellite working time for the windows in results_last_plan, and trim and delete some windows; all the remaining windows in results_last_plan are the planning results.

[0007] Preferably, the specific steps of step 1 are:

[0008] Step 1.1 Arrange all windows in all_wins in ascending order by start time; calculate the visible duration of each target in turn, and summarize the results to form the target visible duration array visible_time;

[0009] Step 1.2: According to the target visibility time in visible_time, select a target with the shortest visibility time that has not been planned in the first stage;

[0010] Step 1.3 performs the first stage planning for the target selected in step 1.2, and summarizes the planning results into the first stage planning result array results_first_plan;

[0011] Step 1.4: Determine the time conflict between the window in results_first_plan and the window in the total window library all_wins. If a conflict occurs, set the sign1 of the conflicting window in the total window library all_wins to false.

[0012] Step 1.5 If there are still goals that have not been planned in the first stage, return to step 1.1.

[0013] Preferably, the specific calculation method of the visible duration of a single target in step 1.1 is:

[0014] Initialize the variable time=0 to record the visible duration of the target;

[0015] Select the first window in the total window library all_wins where sign1 is true and the observed target is the target, and record the start time and end time of the window as start_time and end_time respectively;

[0016] Try to select the next window where sign1 is true and the observed target is the target from the total window library all_wins, and record the start time and end time of the window as start_time` and end_time` respectively;

[0017] (1) If start_time`≤end_time, let end_time=end_time`;

[0018] (2) If start_time`>end_time, then let time=time+end_time-start_time, start_time=start_time`, end_time=end_time`;

[0019] After traversing all the windows in the total window library all_wins, let time = time + end_time - start_time; at this time, time is the visible duration of this target.

[0020] Preferably, the specific calculation method for performing the first stage planning for a single target in step 1.3 is:

[0021] Select all windows whose observed target is the target and whose sign1 is true from the total window library all_wins, and put them into the window array to be filtered comb_list;

[0022] Start window filtering, compare all windows in comb_list with the filtering rules. The filtering rules include three items. Windows that do not meet the filtering conditions are deleted from comb_list until any two windows in comb_list meet filtering rule one, and any three windows meet filtering rules two and three.

[0023] (1) Rule 1: Delete completely overlapping windows

[0024] Assume that the start time and end time of window 1 are start_time1, end_time1 respectively, and the start time and end time of window 2 are start_time2, end_time2 respectively; if Then delete window 2;

[0025] (2) Rule 2: Delete time windows with partial overlap (>80%) and subsequent observation time interval (<30s)

[0026] Assume that the start time and end time of window 1 are start_time1, end_time1 respectively, the start time and end time of window 2 are start_time2, end_time2 respectively, and the start time and end time of window 3 are start_time3, end_time3 respectively; if Delete window 2;

[0027] (3) Rule 3: The subsequent window does not overlap with the previous window. If the observation interval of the subsequent window is less than 30 seconds, the subsequent window with a longer observation time is selected;

[0028] Assume that the start time and end time of window 1 are start_time1, end_time1 respectively, the start time and end time of window 2 are start_time2, end_time2 respectively, and the start time and end time of window 3 are start_time3, end_time3 respectively; if Delete window 2;

[0029] Combine partially overlapping time windows in comb_list into a large observation arc. The merging method is as follows: compare all windows in comb_list in pairs, set the window with the earlier start time as window 1, and the other as window 2, and their start and end times are start_time1, end_time1, start_time2, end_time2 respectively; if end_time1≥start_time2, and the two windows partially overlap in time, then set end_time1=end_time2, replace the end time of the first window with the end time of the second window, and delete the second window; until any two windows in comb_list do not overlap in time;

[0030] Sort the windows in comb_list in ascending order by start time, from front to back, and select the first window with a duration greater than 5 minutes. If no window is greater than 5 minutes, select the longest window.

[0031] Select all windows belonging to the target that are temporally included in the window selected in the previous step from the total window library, and the sign1 of the window must be true; the window is used as the result window of the first stage planning of the target and is put into the first stage planning result array results_first_plan; the method for judging whether it is temporally included is as follows:

[0032] Assume that the start and end time of the window to be judged in the total window library is start_time1, end_time1, and the start and end time of the window selected in the previous step is start_time2, end_time2. If It is considered that the windows that are judged in the total window library are included in time.

[0033] Preferably, the specific calculation method for determining whether the window in results_first_plan has a time conflict with the window in the total window library all_wins in step 1.4 is:

[0034] Assume that the start and end time of the window accepted for judgment in the total window library is start_time1, end_time1, and the start and end time of the window accepted for judgment in results_first_plan is start_time2, end_time2. If start_time2≥end_time1 or start_time1≥end_time2 is not satisfied, it is considered that there is a time conflict.

[0035] Preferably, the specific steps of step 2 are:

[0036] Step 2.1 Set the sign1 of all windows in the first planning result results_first_plan to true, indicating that they are windows of the first round of planning results and old windows, and then put them all into the second planning window material array original_wins_last_plan. Set the sign1 of all windows in the total window library all_wins to false, indicating that they may be new windows that will be added to the planning results, and then put them all into the second planning window material array original_wins_last_plan.

[0037] Step 2.2 Perform a preliminary window screening on the windows belonging to each target in original_wins_last_plan, and delete the windows that do not meet the screening requirements;

[0038] Step 2.3 Clear the conflict resolution array conflict_list, select a satellite that has not yet been planned for the second stage, and put all the windows in original_wins_last_plan that are the satellite into the conflict resolution array conflict_list;

[0039] Step 2.4: Determine whether the new window and the old window in conflict_list contain time conflicts. If there is a conflict, trim or delete the window.

[0040] Step 2.5: Determine whether the new windows in conflict_list contain time conflicts. If so, trim or delete the windows.

[0041] Step 2.6 checks the window with the earliest start time in conflict_list to see whether it satisfies the camera rotation constraint at the start of the scene. If not, trim or delete the window.

[0042] Step 2.7 Check all windows in conflict_list to see if they satisfy the camera rotation constraint. If not, trim or delete the windows.

[0043] Step 2.8 puts all windows in conflict_list into the second stage planning results_last_plan. If there are still satellites that have not yet been planned for the second stage, return to step 2.3;

[0044] Step 2.9 balances the satellite working time of all windows in the second planning result results_last_plan. After the balancing is completed, all windows in results_last_plan are the final planning results.

[0045] Preferably, in step 2.4, the new window and the old window are judged in pairs to see whether there is a time conflict. If there is a conflict, the specific calculation method for trimming or deleting the window is:

[0046] Set the start and end time of the new window to start_time new ,end_time new The start and end times of the old window are start_time old ,end_time old , the minimum duration of the window is During min There are four types of conflicts, and the resolution methods are as follows:

[0047] Conflict 1:

[0048]

[0049] Conflict situation 1 solution:

[0050] If start_time old -start_time new ≥During min , let end_time new =start_time old , otherwise delete the new window new.

[0051] Conflict Scenario 2:

[0052]

[0053] Conflict situation 2 solution:

[0054] If end_time new -end_time old ≥During min , let end_time old =start_time new , otherwise delete the new window new.

[0055] Conflict 3:

[0056]

[0057] Conflict situation 3 solution:

[0058] Delete the new window new.

[0059] Conflict Scenario 4:

[0060]

[0061] Conflict situation 4 solution:

[0062] If start_time old -start_time new ≥During min , create a new window new1, whose start time and end time are Its observed satellite number and observed target number are the same as the new window new, and the new window new1 is saved in conflict_list; if

[0063] end_time new -end_time old ≥During min , create a new window new2, whose start time and end time are Its observed satellite number and observed target number are the same as the new window new, and the new window new2 is saved in conflict_list; after completing the above two judgments, the new window new is deleted.

[0064] Preferably, in step 2.5, the new windows are judged in pairs to determine whether they contain time conflicts. If there are conflicts, the specific calculation method for trimming or deleting the windows is:

[0065] Set the start and end time of the new window 1 to start_time new1 ,end_time new1 , the start and end times of the new window 2 are start_time new2 ,end_time new2 , the minimum duration of the window is During min There are two types of conflicts, which can be resolved as follows:

[0066] Conflict 1:

[0067]

[0068] Conflict situation 1 solution:

[0069] If start_time new2 -start_time new1 ≥During min , let end_time new1 =start_time new2 , otherwise delete the new window new1.

[0070] Conflict Scenario 2:

[0071]

[0072] Conflict situation 2 solution:

[0073] Delete the new window new1.

[0074] Preferably, in step 2.6, all windows are checked in pairs to see whether they satisfy the camera rotation constraint. If not, the specific calculation method for trimming or deleting the windows is:

[0075] Assume that the start and end time of the window are start_time1 and end_time1 respectively, the initial time of the scene is zero_time, the time required for the camera to rotate from the high and low azimuth angles at the initial time of the scene to the high and low azimuth angles at the start time of the window is rotate_time, and the shortest duration of the window is During min , the conflicts and their resolution methods are as follows:

[0076] start_time1-zero_time<rotate_time

[0077] Conflict Resolution:

[0078] If end_time1-zero_time≥rotate_time 0→1 +Duringmin , let start_time1 = zero_time + rotate_time, otherwise delete the window.

[0079] Preferably, in step 2.7, the window with the earliest start time is checked to see whether it satisfies the camera rotation constraint at the start time of the scene. If not, the specific calculation method for trimming or deleting the window is as follows:

[0080] Assume that in the two windows, the start and end times of the window with the earlier start time are start_time1 and end_time1 respectively, and the start and end times of the other window are start_time2 and end_time2 respectively. The time required for the camera to rotate from the high and low azimuth angles at the end time of the window with the earlier start time to the high and low azimuth angles at the start time of the later window is rotate_time 1→2 , the minimum duration of the window is During min , the conflicts and their resolution methods are as follows:

[0081] start_time2-start_time1<rotate_time 1→2

[0082] Conflict Resolution:

[0083] If end_time2-end_time1≥rotate_time 1→2 +During min , let start_time2=end_time1+rotate_time 1→2 , otherwise if start_time2-start_time1≥rotate_time 1→2 +During min , let end_time1=start_time2-rotate_time 1→2 , otherwise the window with a shorter duration is deleted.

[0084] The specific calculation method for satellite working time balance in step 2.9 is:

[0085] According to all windows in results_last_plan, calculate the working time of each satellite by adding the duration of all windows of the satellite;

[0086] Select a target that has not been selected in the satellite working time balance process, traverse all the windows of the target in results_last_plan, and compare them two by two to see if there is a partial time overlap. The time overlap determination method is:

[0087] Suppose that among the two windows, the window with the earlier start time has start_time1 and end_time1 respectively, and the start and end time of the other window are start_time2 and end_time2 respectively. If start_time2<end_time1, there is time overlap;

[0088] Determine whether two windows with time overlap need to be pruned. The determination method is as follows:

[0089] Assume that the observation satellite of the window with an earlier start time is sat1, and its working time is work_time1; the observation satellite of another window is sat2, and its working time is work_time2; the average working time of all satellites is aver_work_time;

[0090] Case 1:

[0091]

[0092] Solution 1:

[0093] Do nothing

[0094] Case 2:

[0095]

[0096] Solution 2:

[0097] end_time1=start_time2

[0098] Case 3:

[0099]

[0100] Solution 3:

[0101] Do nothing

[0102] Case 4:

[0103]

[0104] Solution 4:

[0105] start_time2=end_time1

[0106] If the window is trimmed, the satellite working time and average satellite working time are updated;

[0107] Repeat the above steps until all targets have been selected.

[0108] Beneficial Effects

[0109] This method solves the problem of large amount of computation in autonomous mission planning for space-based multi-target observation by using a rule-based two-stage mission planning approach, and can utilize the limited computing power resources on board to solve the observation mission planning problem.

[0110] Through a two-stage planning method, in the first stage, a long continuous observation window is planned for each target. In the subsequent second-stage expansion planning, the observation window of the first-stage planning result is supplemented and the satellite working time is balanced without deleting or modifying the window planned in the first stage. This meets the planning goal of each target having a minimum observation time, while also meeting the planning goals of making the total observation time of each target as long as possible and the working time of each satellite as balanced as possible.

[0111] Compared with the common task planning method of unified planning, the two-stage planning method of the present invention greatly simplifies the planning logic, effectively reduces the amount of planning calculations, and meets the three types of planning goals by consuming a smaller amount of calculations. BRIEF DESCRIPTION OF THE DRAWINGS

[0112] Figure 1 The original time window Gantt chart (target-time) before tracking task planning in the present invention;

[0113] Figure 2 The original time window Gantt chart (satellite-time) before the tracking task planning in the present invention;

[0114] Figure 3 A Gantt chart (target-time) chart for planning a time window for tracking tasks in the present invention;

[0115] Figure 4 A Gantt chart (satellite-time) is provided for planning the time window for the tracking mission in the present invention. DETAILED DESCRIPTION

[0116] The following combination Figures 1 to 4 This embodiment will be described in detail.

[0117] The present invention provides a space-based space target observation autonomous task planning method based on two-stage planning, and the specific steps are as follows:

[0118] Step 1, first stage planning: calculate the visible duration of all targets to form an array visible_time; according to the length of the visible duration in visible_time, follow the logic of planning the targets with shorter visible duration first, perform the first stage planning for each target in turn, and summarize the planning results into the first stage planning result array results_first_plan; complete the first stage planning for each target once, check the time conflict between the result window selected by this planning and all the windows in all_wins, set the sign quantity sign1 of the conflicting windows in all_wins to false, and repeat until all targets complete the first stage planning once;

[0119] Step 2, second stage planning: Mix all windows in the first stage planning results_first_plan and all windows in the total window library all_wins and put them into the second stage planning window material array

[0120] original_wins_last_plan; using the windows in original_wins_last_plan as materials, perform a preliminary window screening for each target, and delete windows that do not meet the screening requirements; taking satellites as units, perform time conflict resolution and camera rotation constraint resolution for the windows belonging to each satellite in original_wins_last_plan in turn, and merge the remaining windows into the second planning result results_last_plan; balance the satellite working time for the windows in results_last_plan, and trim and delete some windows; all the remaining windows in results_last_plan are the planning results.

[0121] Step 1 The specific steps are:

[0122] Step 1.1 Arrange all windows in all_wins in ascending order by start time; calculate the visible duration of each target in turn, and summarize the results to form the target visible duration array visible_time; Step 1.1 The specific calculation method of the visible duration of a single target is:

[0123] Initialize the variable time=0 to record the visible duration of the target;

[0124] Select the first window in the total window library all_wins where sign1 is true and the observed target is the target, and record the start time and end time of the window as start_time and end_time respectively;

[0125] Try to select the next window where sign1 is true and the observed target is the target from the total window library all_wins, and record the start time and end time of the window as start_time` and end_time` respectively;

[0126] (1) If start_time`≤end_time, let end_time=end_time`;

[0127] (2) If start_time`>end_time, then let time=time+end_time-start_time, start_time=start_time`, end_time=end_time`;

[0128] After traversing all the windows in the total window library all_wins, let time = time + end_time - start_time; at this time, time is the visible duration of this target.

[0129] Step 1.2: According to the target visibility time in visible_time, select a target with the shortest visibility time that has not been planned in the first stage;

[0130] Step 1.3 performs the first stage planning for the target selected in step 1.2, and summarizes the planning results into the first stage planning result array results_first_plan;

[0131] Step 1.3 The specific calculation method for the first stage planning of a single target is:

[0132] Select all windows whose observed target is the target and whose sign1 is true from the total window library all_wins, and put them into the window array to be filtered comb_list;

[0133] Start window filtering, compare all windows in comb_list with the filtering rules. The filtering rules include three items. Windows that do not meet the filtering conditions are deleted from comb_list until any two windows in comb_list meet filtering rule one, and any three windows meet filtering rules two and three.

[0134] (1) Rule 1: Delete completely overlapping windows

[0135] Assume that the start time and end time of window 1 are start_time1, end_time1 respectively, and the start time and end time of window 2 are start_time2, end_time2 respectively; if Then delete window 2;

[0136] (2) Rule 2: Delete time windows with partial overlap (>80%) and subsequent observation time interval (<30s)

[0137] Assume that the start time and end time of window 1 are start_time1, end_time1 respectively, the start time and end time of window 2 are start_time2, end_time2 respectively, and the start time and end time of window 3 are start_time3, end_time3 respectively; if Delete window 2;

[0138] (3) Rule 3: The subsequent window does not overlap with the previous window. If the observation interval of the subsequent window is less than 30 seconds, the subsequent window with a longer observation time is selected;

[0139] Assume that the start time and end time of window 1 are start_time1, end_time1 respectively, the start time and end time of window 2 are start_time2, end_time2 respectively, and the start time and end time of window 3 are start_time3, end_time3 respectively; if Delete window 2;

[0140] Combine partially overlapping time windows in comb_list into a large observation arc. The merging method is as follows: compare all windows in comb_list in pairs, set the window with the earlier start time as window 1, and the other as window 2, and their start and end times are start_time1, end_time1, start_time2, end_time2 respectively; if end_time1≥start_time2, and the two windows partially overlap in time, then set end_time1=end_time2, replace the end time of the first window with the end time of the second window, and delete the second window; until any two windows in comb_list do not overlap in time;

[0141] Sort the windows in comb_list in ascending order by start time, from front to back, and select the first window with a duration greater than 5 minutes. If no window is greater than 5 minutes, select the longest window.

[0142] Select all windows belonging to the target that are temporally included in the window selected in the previous step from the total window library, and the sign1 of the window must be true; the window is used as the result window of the first stage planning of the target and is put into the first stage planning result array results_first_plan; the method for judging whether it is temporally included is as follows:

[0143] Assume that the start and end time of the window to be judged in the total window library is start_time1, end_time1, and the start and end time of the window selected in the previous step is start_time2, end_time2. If It is considered that the windows that are judged in the total window library are included in time.

[0144] Step 1.4: Determine the time conflict between the window in results_first_plan and the window in the total window library all_wins. If a conflict occurs, set the sign1 of the conflicting window in the total window library all_wins to false.

[0145] Step 1.4 The specific calculation method for determining whether the window in results_first_plan has a time conflict with the window in the total window library all_wins is:

[0146] Assume that the start and end time of the window accepted for judgment in the total window library is start_time1, end_time1, and the start and end time of the window accepted for judgment in results_first_plan is start_time2, end_time2. If start_time2≥end_time1 or start_time1≥end_time2 is not satisfied, it is considered that there is a time conflict.

[0147] Step 1.5 If there are still goals that have not been planned in the first stage, return to step 1.1.

[0148] Step 2 The specific steps are:

[0149] Step 2.1 Set the sign1 of all windows in the first planning result results_first_plan to true, indicating that they are windows of the first round of planning results and old windows, and then put them all into the second planning window material array original_wins_last_plan. Set the sign1 of all windows in the total window library all_wins to false, indicating that they may be new windows that will be added to the planning results, and then put them all into the second planning window material array original_wins_last_plan.

[0150] Step 2.2 Perform a preliminary window screening on the windows belonging to each target in original_wins_last_plan, and delete the windows that do not meet the screening requirements;

[0151] Step 2.3 Clear the conflict resolution array conflict_list, select a satellite that has not yet been planned for the second stage, and put all the windows in original_wins_last_plan that are the satellite into the conflict resolution array conflict_list;

[0152] Step 2.4 determines whether the new window and the old window in conflict_list contain time conflicts. If so, the windows are pruned or deleted. The specific calculation method for determining whether the new window and the old window contain time conflicts and if so, the windows are pruned or deleted is as follows:

[0153] Set the start and end time of the new window to start_time new ,end_time new The start and end times of the old window are start_time old ,end_time old , the minimum duration of the window is During min There are four types of conflicts, and the resolution methods are as follows:

[0154] Conflict Scenario 1:

[0155]

[0156] Conflict situation 1 solution:

[0157] If start_time old -start_time new ≥During min , let end_time new =start_time old , otherwise delete the new window new.

[0158] Conflict Scenario 2:

[0159]

[0160] Conflict situation 2 solution:

[0161] If end_time new -end_time old ≥During min , let end_time old =start_time new , otherwise delete the new window new.

[0162] Conflict 3:

[0163]

[0164] Conflict situation 3 solution:

[0165] Delete the new window new.

[0166] Conflict Scenario 4:

[0167]

[0168] Conflict situation 4 solution:

[0169] If start_time old -start_time new ≥During min , create a new window new1, whose start time and end time are Its observed satellite number and observed target number are the same as the new window new, and the new window new1 is saved in conflict_list; if

[0170] end_time new -end_time old ≥During min , create a new window new2, whose start time and end time are Its observed satellite number and observed target number are the same as the new window new, and the new window new2 is saved in conflict_list; after completing the above two judgments, the new window new is deleted.

[0171] Step 2.5 determines whether the new windows in conflict_list contain time conflicts. If so, the windows are pruned or deleted. The specific calculation method for determining whether the new windows contain time conflicts and if so, the windows are pruned or deleted is as follows:

[0172] Set the start and end time of the new window 1 to start_time new1 ,end_time new1 , the start and end times of the new window 2 are start_time new2 ,end_time new2 , the minimum duration of the window is During min There are two types of conflicts, which can be resolved as follows:

[0173] Conflict 1:

[0174]

[0175] Conflict situation 1 solution:

[0176] If start_time new2 -start_time new1 ≥During min , let end_time new1 =start_time new2 , otherwise delete the new window new1.

[0177] Conflict Scenario 2:

[0178]

[0179] Conflict situation 2 solution:

[0180] Delete the new window new1.

[0181] Step 2.6 checks the window with the earliest start time in conflict_list to see if it satisfies the camera rotation constraint at the start of the scene. If not, trim or delete the window. In step 2.6, all windows are checked in pairs to see if they satisfy the camera rotation constraint. If not, trim or delete the window. The specific calculation method is as follows:

[0182] Assume that the start and end time of the window are start_time1 and end_time1 respectively, the initial time of the scene is zero_time, the time required for the camera to rotate from the high and low azimuth angles at the initial time of the scene to the high and low azimuth angles at the start time of the window is rotate_time, and the shortest duration of the window is During min , the conflicts and their resolution methods are as follows:

[0183] start_time1-zero_time<rotate_time

[0184] Conflict Resolution:

[0185] If end_time1-zero_time≥rotate_time 0→1 +During min , let start_time1 = zero_time + rotate_time, otherwise delete the window.

[0186] Step 2.7 checks all windows in conflict_list in pairs to see if they satisfy the camera rotation constraint. If not, trim or delete the windows. In step 2.7, the window with the earliest start time is checked to see if it satisfies the camera rotation constraint at the start of the scene. If not, trim or delete the windows. The specific calculation method is as follows:

[0187] Assume that in the two windows, the start and end times of the window with the earlier start time are start_time1 and end_time1 respectively, and the start and end times of the other window are start_time2 and end_time2 respectively. The time required for the camera to rotate from the high and low azimuth angles at the end time of the window with the earlier start time to the high and low azimuth angles at the start time of the later window is rotate_time 1→2 , the minimum duration of the window is During min , the conflicts and their resolution methods are as follows:

[0188] start_time2-start_time1<rotate_time 1→2

[0189] Conflict Resolution:

[0190] If end_time2-end_time1≥rotate_time 1→2 +During min , let start_time2=end_time1+rotate_time 1→2 , otherwise if start_time2-start_time1≥rotate_time 1→2 +During min , let end_time1=start_time2-rotate_time 1→2 , otherwise the window with a shorter duration is deleted.

[0191] Step 2.8 puts all windows in conflict_list into the second stage planning results_last_plan. If there are still satellites that have not yet been planned for the second stage, return to step 2.3;

[0192] Step 2.9 balances the satellite working time of all windows in the second planning result results_last_plan. After the balancing is completed, all windows in results_last_plan are the final planning results.

[0193] The specific calculation method for satellite working time balance is:

[0194] According to all windows in results_last_plan, calculate the working time of each satellite by adding the duration of all windows of the satellite;

[0195] Select a target that has not been selected in the satellite working time balance process, traverse all the windows of the target in results_last_plan, and compare them two by two to see if there is a partial time overlap. The time overlap determination method is:

[0196] Suppose that among the two windows, the window with the earlier start time has start_time1 and end_time1 respectively, and the start and end time of the other window are start_time2 and end_time2 respectively. If start_time2<end_time1, there is time overlap;

[0197] Determine whether two windows with time overlap need to be pruned. The determination method is as follows:

[0198] Assume that the observation satellite of the window with an earlier start time is sat1, and its working time is work_time1; the observation satellite of another window is sat2, and its working time is work_time2; the average working time of all satellites is aver_work_time;

[0199] Case 1:

[0200]

[0201] Solution 1:

[0202] Do nothing

[0203] Case 2:

[0204]

[0205] Solution 2:

[0206] end_time1=start_time2

[0207] Case 3:

[0208]

[0209] Solution 3:

[0210] Do nothing

[0211] Case 4:

[0212]

[0213] Solution 4:

[0214] start_time2=end_time1

[0215] If the window is trimmed, the satellite working time and average satellite working time are updated;

[0216] Repeat the above steps until all targets have been selected.

[0217] Example

[0218] In this embodiment, the space-based space target observation autonomous task planning method based on two-stage planning of the present invention is used for actual operation.

[0219] The scenario of this embodiment is to plan a 6-hour observation mission of six satellites to five targets. The CPU used for planning is i7-12700H. The total planning time is 0.3183929 seconds. The time taken to plan the same scenario using the random optimization algorithm is 22.1556356 seconds, which is only 1.44% of the latter.

[0220] The two-stage planning method of the present invention greatly simplifies the planning logic, effectively reduces the amount of planning calculations, and meets three types of planning objectives by consuming a relatively small amount of calculations.

[0221] The above contents of the present invention are only preferred embodiments of the present invention and are not intended to limit the implementation scheme of the present invention. A person skilled in the art can easily make corresponding changes or modifications based on the main concept and spirit of the present invention. Therefore, the protection scope of the present invention shall be based on the protection scope required by the claims.

Claims

1. A two-stage planning-based autonomous mission planning method for space-based space target observation, characterized in that: The steps include: Step 1, first stage planning: calculate the visible duration of all targets to form an array visible_time; according to the length of the visible duration in visible_time, follow the logic of planning the targets with short visible duration first, perform the first stage planning for each target in turn, and summarize the planning results into the first stage planning result array results_first_plan; After completing the first stage planning for each target, check the time conflict between the result window selected by this planning and all windows in all_wins, set the sign quantity sign1 of the conflicting window in all_wins to false, and repeat until all targets complete the first stage planning once; Step 2, second stage planning: Mix all windows in the first stage planning results_first_plan and all windows in the total window library all_wins and put them into the second stage planning window material array original_wins_last_plan; using the windows in original_wins_last_plan as materials, perform a preliminary window screening for each target, and delete windows that do not meet the screening requirements; taking satellites as units, perform time conflict resolution and camera rotation constraint resolution for the windows belonging to each satellite in original_wins_last_plan in turn, and merge the remaining windows into the second planning result results_last_plan; balance the satellite working time for the windows in results_last_plan, and trim and delete some windows; all the remaining windows in results_last_plan are the planning results.

2. The method for autonomous task planning of space-based space target observation based on two-stage planning according to claim 1 is characterized in that: Step 1 The specific steps are: Step 1.1 Arrange all windows in all_wins in ascending order by start time; calculate the visible duration of each target in turn, and summarize the results to form the target visible duration array visible_time; Step 1.2: According to the target visibility time in visible_time, select a target with the shortest visibility time that has not been planned in the first stage; Step 1.3 performs the first stage planning for the target selected in step 1.2, and summarizes the planning results into the first stage planning result array results_first_plan; Step 1.4: Determine the time conflict between the window in results_first_plan and the window in the total window library all_wins. If a conflict occurs, set the sign1 of the conflicting window in the total window library all_wins to false. Step 1.5 If there are still goals that have not been planned in the first stage, return to step 1.

1.

3. The method for autonomous task planning of space-based space target observation based on two-stage planning according to claim 2 is characterized in that: Step 1.1 The specific calculation method for the visible duration of a single target is: Initialize the variable time=0 to record the visible duration of the target; Select the first window in the total window library all_wins where sign1 is true and the observed target is the target, and record the start time and end time of the window as start_time and end_time respectively; Try to select the next window where sign1 is true and the observed target is the target from the total window library all_wins, and record the start time and end time of the window as start_time` and end_time` respectively; (1) If start_time`≤end_time, let end_time=end_time`; (2) If start_time`>end_time, then let time=time+end_time-start_time, start_time=start_time`, end_time=end_time`; After traversing all the windows in the total window library all_wins, let time = time + end_time - start_time; at this time, time is the visible duration of this target.

4. The method for autonomous task planning of space-based space target observation based on two-stage planning according to claim 2 is characterized in that: Step 1.3 The specific calculation method for the first stage planning of a single target is: Select all windows whose observed target is the target and whose sign1 is true from the total window library all_wins, and put them into the window array to be filtered comb_list; Start window filtering, compare all windows in comb_list with the filtering rules. The filtering rules include three items. Windows that do not meet the filtering conditions are deleted from comb_list until any two windows in comb_list meet filtering rule one, and any three windows meet filtering rules two and three. (1) Rule 1: Delete completely overlapping windows Assume that the start time and end time of window 1 are start_time1, end_time1 respectively, and the start time and end time of window 2 are start_time2, end_time2 respectively; if Then delete window 2; (2) Rule 2: Delete partially overlapping time windows with subsequent observation time intervals Assume that the start time and end time of window 1 are start_time1, end_time1 respectively, the start time and end time of window 2 are start_time2, end_time2 respectively, and the start time and end time of window 3 are start_time3, end_time3 respectively; if Delete window 2; (3) Rule 3: The subsequent window does not overlap with the previous window. If the observation interval of the subsequent window is less than 30 seconds, the subsequent window with a longer observation time is selected; Assume that the start time and end time of window 1 are start_time1, end_time1 respectively, the start time and end time of window 2 are start_time2, end_time2 respectively, and the start time and end time of window 3 are start_time3, end_time3 respectively; if Delete window 2; Combine partially overlapping time windows in comb_list into a large observation arc. The merging method is as follows: compare all windows in comb_list in pairs, set the window with the earlier start time as window 1, and the other as window 2, and their start and end times are start_time1, end_time1, start_time2, end_time2 respectively; if end_time1≥start_time2, and the two windows partially overlap in time, then set end_time1=end_time2, replace the end time of the first window with the end time of the second window, and delete the second window; until any two windows in comb_list do not overlap in time; Sort the windows in comb_list in ascending order by start time, from front to back, and select the first window with a duration greater than 5 minutes. If no window is greater than 5 minutes, select the longest window. Select all windows belonging to the target that are temporally included in the window selected in the previous step from the total window library, and the sign1 of the window must be true; the window is used as the result window of the first stage planning of the target and is put into the first stage planning result array results_first_plan; the method for judging whether it is temporally included is as follows: Assume that the start and end time of the window to be judged in the total window library is start_time1, end_time1, and the start and end time of the window selected in the previous step is start_time2, end_time2. If It is considered that the windows that are judged in the total window library are included in time.

5. The method for autonomous mission planning of space-based space target observation based on two-stage planning according to claim 2 is characterized in that: Step 1.4 The specific calculation method for determining whether the window in results_first_plan has a time conflict with the window in the total window library all_wins is: Assume that the start and end time of the window accepted for judgment in the total window library is start_time1, end_time1, and the start and end time of the window accepted for judgment in results_first_plan is start_time2, end_time2. If start_time2≥end_time1 or start_time1≥end_time2 is not satisfied, it is considered that there is a time conflict.

6. The method for autonomous mission planning of space-based space target observation based on two-stage planning according to claim 1 is characterized in that: Step 2 The specific steps are: Step 2.1 Set the sign1 of all windows in the first planning result results_first_plan to true, indicating that they are windows of the first round of planning results and old windows, and then put them all into the second planning window material array original_wins_last_plan. Set the sign1 of all windows in the total window library all_wins to false, indicating that they may be new windows that will be added to the planning results, and then put them all into the second planning window material array original_wins_last_plan. Step 2.2 Perform a preliminary window screening on the windows belonging to each target in original_wins_last_plan, and delete the windows that do not meet the screening requirements; Step 2.3 Clear the conflict resolution array conflict_list, select a satellite that has not yet been planned for the second stage, and put all the windows in original_wins_last_plan that are the satellite into the conflict resolution array conflict_list; Step 2.4: Determine whether the new window and the old window in conflict_list contain time conflicts. If there is a conflict, trim or delete the window. Step 2.5: Determine whether the new windows in conflict_list contain time conflicts. If so, trim or delete the windows. Step 2.6 checks the window with the earliest start time in conflict_list to see whether it satisfies the camera rotation constraint at the start of the scene. If not, trim or delete the window. Step 2.7 Check all windows in conflict_list to see if they satisfy the camera rotation constraint. If not, trim or delete the windows. Step 2.8 puts all windows in conflict_list into the second stage planning results_last_plan. If there are still satellites that have not yet been planned for the second stage, return to step 2.3; Step 2.9 balances the satellite working time of all windows in the second planning result results_last_plan. After the balancing is completed, all windows in results_last_plan are the final planning results.

7. The method for autonomous mission planning of space-based space target observation based on two-stage planning according to claim 6 is characterized in that: In step 2.4, the new window and the old window are judged in pairs to see whether there is a time conflict. If there is a conflict, the specific calculation method for window pruning or deletion is as follows: Set the start and end time of the new window to start_time new ,end_time new The start and end times of the old window are start_time old ,end_time old , the shortest window duration is During min There are four types of conflicts, and the resolution methods are as follows: Conflict 1: Conflict situation 1 solution: If start_time old -start_time new ≥During min , let end_time new =start_time old , otherwise delete the new window new. Conflict Scenario 2: Conflict situation 2 solution: If end_time new -end_time old ≥During min , let end_time old =start_time new , otherwise delete the new window new. Conflict 3: Conflict situation 3 solution: Delete the new window new. Conflict Scenario 4: Conflict situation 4 solution: If start_time old -start_time new ≥During min , create a new window new1, whose start time and end time are The number of the observed satellite and the number of the observed target are the same as the new window new, and the new window new1 is saved in conflict_list; if end_time new -end_time old ≥During min , create a new window new2, whose start time and end time are Its observed satellite number and observed target number are the same as the new window new, and the new window new2 is saved in conflict_list; after completing the above two judgments, the new window new is deleted.

8. The method for autonomous mission planning of space-based space target observation based on two-stage planning according to claim 6 is characterized in that: In step 2.5, the new windows are judged in pairs to see whether they contain time conflicts. If there are conflicts, the specific calculation method for window pruning or deletion is as follows: Set the start and end time of the new window 1 to start_time new1 ,end_time new1 , the start and end times of the new window 2 are start_time new2 ,end_time new2 , the shortest window duration is During min There are two types of conflicts, which can be resolved as follows: Conflict 1: Conflict situation 1 solution: If start_time new2 -start_time new1 ≥During min , let end_time new1 =start_time new2 , otherwise delete the new window new1. Conflict Scenario 2: Conflict situation 2 solution: Delete the new window new1.

9. The method for autonomous mission planning of space-based space target observation based on two-stage planning according to claim 6 is characterized in that: In step 2.6, all windows are checked in pairs to see if they satisfy the camera rotation constraint. If not, the specific calculation method for trimming or deleting the windows is as follows: Assume that the start and end time of the window are start_time1 and end_time1 respectively, the initial time of the scene is zero_time, the time required for the camera to rotate from the high and low azimuth angles at the initial time of the scene to the high and low azimuth angles at the start time of the window is rotate_time, and the shortest duration of the window is During min , the conflicts and their resolution methods are as follows: start_time1-zero_time<rotate_time Conflict Resolution: If end_time1-zero_time≥rotate_time 0→1 +During min , let start_time1 = zero_time + rotate_time, otherwise delete the window.

10. The method for autonomous mission planning of space-based space target observation based on two-stage planning according to claim 6, characterized in that: In step 2.7, the window with the earliest start time is checked to see if it meets the camera rotation constraint at the start time of the scene. If not, the window is trimmed or deleted. The specific calculation method is: Assume that in the two windows, the start and end times of the window with the earlier start time are start_time1 and end_time1 respectively, and the start and end times of the other window are start_time2 and end_time2 respectively. The time required for the camera to rotate from the high and low azimuth angles at the end time of the window with the earlier start time to the high and low azimuth angles at the start time of the later window is rotate_time 1→2 , the shortest window duration is During min , the conflicts and their resolution methods are as follows: start_time2-start_time1<rotate_time 1→2 Conflict Resolution: If end_time2-end_time1≥rotate_time 1→2 +During min , let start_time2=end_time1+rotate_time 1→2 , otherwise if start_time2-start_time1≥rotate_time 1→2 +During min , let end_time1=start_time2-rotate_time 1→2 , otherwise the window with a shorter duration is deleted. The specific calculation method for satellite working time balance in step 2.9 is: According to all windows in results_last_plan, calculate the working time of each satellite by adding the duration of all windows of the satellite; Select a target that has not been selected in the satellite working time balance process, traverse all the windows of the target in results_last_plan, and compare them two by two to see if there is a partial time overlap. The time overlap determination method is: Suppose that among the two windows, the window with the earlier start time has start_time1 and end_time1 respectively, and the start and end time of the other window are start_time2 and end_time2 respectively. If start_time2<end_time1, there is time overlap; Determine whether two windows with time overlap need to be pruned. The determination method is as follows: Assume that the observation satellite of the window with an earlier start time is sat1, and its working time is work_time1; the observation satellite of another window is sat2, and its working time is work_time2; the average working time of all satellites is aver_work_time; Case 1: Solution 1: Do nothing Case 2: Solution 2: end_time1=start_time2 Case 3: Solution 3: Do nothing Case 4: Solution 4: start_time2=end_time1 If the window is trimmed, the satellite working time and average satellite working time are updated; Repeat the above steps until all targets have been selected.

Images