Multi-satellite cooperative task planning method based on behavior tree

Abstract

The invention discloses a multi-satellite cooperative task planning method based on a behavior tree. S101, the ground planning layer carries out modeling description of satellite tasks by combing satellite task requirements and sends a behavior tree task template to the high-orbit satellite layer; s102, after receiving the task, the high-orbit satellite layer plans the task according to the behavior tree task template; task decomposition is carried out to obtain meta-task sub-trees (tasks capable of being executed by a single satellite), specific satellite planning is carried out, satellites conforming to task constraints are planned to bear task execution, and the task sub-behavior trees are issued to a low-orbit execution layer; and S103, after receiving the task sub-behavior tree, the low-orbit execution layer binds a function according to a mechanism of the behavior tree and constructs code execution so as to realize execution of a specific task. According to the method, high flexibility, expandability and execution efficiency of task planning are remarkably improved, and the defects of a traditional method in the aspects of complex task decomposition, multi-satellite coordination and real-time response capability are effectively overcome.

Description

Technical Field

[0001] This invention belongs to the field of satellite mission planning technology, specifically relating to a multi-satellite collaborative mission planning method based on behavior trees. Background Technology

[0002] In multi-satellite systems, the core of mission planning lies in efficiently allocating tasks and executing them within the available time windows of the satellites. In large-scale satellite mission planning, complexity grows exponentially. For example, assuming four satellites can access six different missions, each with a different available time window, the possible combinations of mission arrangements reach 4096 (4 to the power of 6). As the number of satellites and missions increases, the possible combinations of mission allocation rise exponentially, leading to a dramatic increase in planning difficulty. Each additional satellite or mission can increase the overall number of combinations at the same exponential rate, significantly increasing the complexity of computation and optimization, and requiring more efficient algorithms and more powerful computing resources to ensure the optimality and feasibility of mission allocation.

[0003] Traditional planning methods primarily rely on centralized mission planning. However, as mission complexity and the number of satellites increase, this architecture has gradually revealed limitations such as excessive computational load, slow response speed, and poor scalability. Furthermore, rapidly adjusting mission planning in dynamic environments (such as orbital changes, unexpected missions, or resource fluctuations) remains a challenge.

[0004] Existing technical solutions include the following:

[0005] ① Finite state machine (FSM) achieves task sequence control and state management by defining a finite set of states and their transition rules.

[0006] ② Hierarchical Finite State Machine (HFSM): By introducing a hierarchical structure, complex states are decomposed into multiple sub-states, thereby improving the modularity and maintainability of the system. HFSM alleviates the scalability problem of FSM to some extent and is suitable for task management of moderate complexity.

[0007] ③ Hierarchical Task Networks (HTNs) effectively manage the hierarchical structure of complex tasks by decomposing high-level tasks into finer-grained subtasks, making them suitable for complex task planning needs. HTN methods excel in handling complex task decomposition and hierarchical management, improving the efficiency and structure of task planning.

[0008] ④ Decision trees (DT) use a tree structure to make task decisions, which can intuitively represent the task execution path and are suitable for well-defined decision-making processes. The advantages of decision trees are that their decision-making process is transparent, easy to understand and implement, and suitable for tasks with clear decision nodes and branching conditions.

[0009] However, existing technologies have the following drawbacks: When dealing with complex tasks, the state and transition rules of FSM grow exponentially, making the system difficult to maintain and expand; although HFSM improves modularity by introducing a hierarchical structure, it still lacks sufficient flexibility in highly dynamic and unpredictable environments; HTN relies on predefined task decomposition rules, making it difficult to quickly adapt to changes and sudden task requirements in real-time environments; when facing large-scale and highly complex decisions, the tree structure of DT may become too large and complex, increasing the cost of maintenance and optimization, and making it difficult to cope with dynamic changes and uncertainties during task execution. Summary of the Invention

[0010] To overcome the shortcomings of the existing technology, the present invention aims to provide a multi-satellite collaborative task planning method based on behavior tree, which achieves a high degree of flexibility, scalability and significantly improved execution efficiency in task planning, and effectively solves the shortcomings of traditional methods in complex task decomposition, multi-satellite coordination and real-time response capabilities.

[0011] To achieve the above objectives, the technical solution adopted by the present invention is as follows:

[0012] A multi-star collaborative task planning method based on behavior trees includes the following steps;

[0013] S101, the ground planning layer sorts out the satellite mission requirements, models and describes the satellite missions, and sends the behavior tree mission representation template to the high-orbit satellite layer.

[0014] S102, after receiving the mission, the high-orbit satellite layer plans the mission according to the behavior tree mission template; it decomposes the mission to obtain the mission subtree (the mission that a single satellite can execute) and performs specific satellite planning, planning satellites that meet the mission constraints to execute the mission and sending the mission subtree down to the low-orbit execution layer.

[0015] S103 After receiving the task sub-behavior tree, the low-orbit execution layer binds functions and constructs code to execute specific tasks according to the mechanism of the behavior tree.

[0016] In S101, the ground planning layer includes a mission requirement analysis module, which is used to analyze and organize the mission requirements of the satellite, and construct a mission behavior tree through the behavior tree mission construction module and upload it to the high-orbit satellite. The mission behavior tree describes in detail the hierarchical structure of the mission, the conditions of each sub-task, and the execution actions.

[0017] The mission requirement analysis module is used to comprehensively receive, parse, and organize satellite mission requirements from users or command centers.

[0018] First, the task requirements analysis module uses intelligent algorithms (such as NER, LSTM, etc.) and a rule engine to automatically identify the subject, priority, resource requirements, time constraints and other key parameters of the task, and transform these requirements into a structured data format.

[0019] In addition, the task requirements analysis module has dynamic update capabilities, which can adjust and optimize task requirements in a timely manner based on changes in real-time input information, ensuring that the task modeling process is always based on the latest and most accurate requirement information. Through the task requirements analysis module, the ground planning layer can efficiently and accurately transform complex task requirements into operable behavior tree task templates, providing a solid data foundation and guarantee for subsequent task modeling and planning.

[0020] Then, the behavior tree task template construction module of the ground planning layer transforms the structured data parsed by the task requirements analysis module into a behavior tree structure, and uses the hierarchical and modular characteristics of the behavior tree to decompose the complex satellite mission into multiple sub-tasks (task subtrees).

[0021] Specifically, the behavior tree task template construction module defines the root node, control node, leaf node, and behavior subtree in the behavior tree, clarifies the execution conditions and actions of each subtask, and establishes the logical relationships between nodes to form a clear task hierarchy structure. In addition, the behavior tree template can adjust the behavior tree structure in a timely manner according to changes in task requirements to ensure the accuracy and executability of the task template. This module also provides a visual representation of the behavior tree, which is convenient for task planners to review and modify, ensuring the accuracy and completeness of the task template.

[0022] By using the behavior tree task template building module, the ground station can efficiently transform complex task requirements into structured behavior tree task templates, providing a solid foundation for subsequent task decomposition and planning at the high-orbit satellite level, and ensuring the orderliness and flexibility of task execution.

[0023] In S102, the behavior tree decomposition module of the high-orbit planning layer decomposes the received complex task behavior tree template in detail according to the predetermined decomposition principles and node types (including task subject, space, resource constraints and time constraints). The behavior tree is split layer by layer through a recursive decomposition algorithm, and the complex structure is split into multiple independent or low-dependency sub-behavior trees, thereby structuring the complex task into independently manageable sub-task units.

[0024] (1) Receive the overall behavior tree task template from the ground planning layer. The behavior tree task template fully describes the hierarchical structure of the complex satellite mission to be executed, the conditions of each sub-task, and the execution actions.

[0025] (2) The behavior tree decomposition module performs a comprehensive analysis of the received behavior tree template. Because the behavior tree nodes are divided into leaf nodes and control nodes, the leaf nodes are responsible for the execution of specific code, and the control nodes are responsible for the logical control between various modules. Therefore, the high-orbit satellite layer can identify each node in the behavior tree and the logical relationship between them, including key elements such as the task subject, spatial constraints, resource constraints and time constraints.

[0026] (3) The module adopts a recursive decomposition algorithm to split the overall behavior tree layer by layer. The recursive decomposition algorithm starts from the root node and decomposes each child node layer by layer. Through recursion, each behavior node is gradually decomposed until it is decomposed into the smallest independent sub-behavior tree. These sub-behavior trees run independently or work together with less dependence, effectively reducing the complexity of the system.

[0027] The specific recursive decomposition formula is expressed as T(n) = T(n-1) + S(n), where T(n) represents the complexity of the current behavior tree, T(n-1) is the subtree structure after the previous recursive decomposition, and S(n) is the complexity of the subtree structure generated at the current level. By recursively reducing the complexity of each level, the behavior tree is gradually decomposed. During each decomposition, sub-behavior trees with low dependencies are selected first to ensure the independence between each subtree. Through recursion, the original complex tree structure is continuously simplified into smaller, more manageable sub-behavior trees.

[0028] (4) Classify nodes according to predetermined decomposition principles and node types (including task subjects, spatial constraints, resource constraints, and time constraints, etc.);

[0029] (5) Based on the generated sub-behavior tree, the high-orbit planning layer uses the satellite planning module to rationally allocate sub-tasks to the most suitable low-orbit satellites according to the resource requirements, priorities and time constraints of each sub-task. The intelligent planning algorithm (such as greedy algorithm, genetic algorithm, deep learning algorithm, etc.) is used to ensure the efficiency and rationality of task allocation. The intelligent planning algorithm used in this invention will be described in detail later.

[0030] (6) Through the task distribution module, the high-orbit planning layer transmits the generated sub-behavior tree task instructions to the corresponding low-orbit satellite.

[0031] In step S102, the high-orbit satellite has a built-in satellite planning module. This module is responsible for formulating specific satellite mission planning schemes based on the decomposed task sub-behavior tree and mission constraints. The module comprehensively considers the orbital parameters of the satellite constellation, the resource status of each satellite (such as payload type and performance), and the priority and time requirements of the missions, employing intelligent planning algorithms for task allocation and resource scheduling. This module can intelligently select the most suitable satellite to carry out specific sub-tasks, ensuring the completeness and efficiency of task allocation. Furthermore, the satellite planning module has dynamic adjustment capabilities, enabling it to respond in real-time to environmental changes and unexpected mission demands, promptly optimizing and adjusting mission execution plans to maintain the flexibility and reliability of mission execution. Through this module, the high-orbit satellite can achieve efficient management and coordination of the entire satellite constellation's missions, maximizing resource utilization and improving overall mission execution efficiency.

[0032] In step (5), the intelligent planning algorithm combines the Variable Neighborhood Search (VNS) algorithm with the Backtracking Search Algorithm (BSA) algorithm for satellite intelligent planning. The VNS algorithm is a metaheuristic optimization algorithm widely used to solve combinatorial optimization problems. By dynamically changing the neighborhood structure of the solution, the VNS algorithm effectively escapes local optima and finds the global optimum or a better solution. The constraints involved are as follows:

[0033] (1) Time constraints

[0034] For each task T i and satellites j Assume task t i The time window requirement is [t] i,start ,t i,end ], s j For task T i The visible time window is [t j,start ,t j,end The planning relationship between the mission and the satellite must meet the following time constraints:

[0035]

[0036] Among them, Match i,j =1, indicating task T i and satellites j There are overlapping time windows, which allows for allocation; Match i,j =0 indicates task T i and satellites j The time window overlap condition is not met.

[0037] (2) Load capacity constraints

[0038] Each task T i Requires a certain load capacity And each satellite s j Maximum load capacity Task T i Assigned to satellites j The condition is that the satellite's payload capacity is sufficient to meet the mission requirements:

[0039]

[0040] If satellites s j The load capacity is less than that of mission T i The load requirements, Match i,j It will be set to 0;

[0041] The variable neighborhood algorithm optimizes task allocation by progressively adjusting the matching neighborhood between tasks and satellites. During each task allocation, it dynamically narrows down the set of available satellites based on the task's time window and payload requirements; Task T i optional satellite set It consists of satellites that meet the following conditions:

[0042]

[0043] In the satellite mission allocation problem, the matching between missions and satellites not only needs to meet basic constraints (such as time overlap, payload capacity, etc.), but also needs to consider how to select the optimal solution from multiple feasible options.

[0044] In order to effectively guide the algorithm to find the optimal solution and evaluate different schemes during the solution process, it is crucial to introduce a reward function. The reward function designed in this invention is evaluated based on the coverage of the task time by the planning scheme, and a penalty mechanism for the number of satellites and the overlap of satellite time windows is introduced to ensure that the minimum satellite time window resources are used while maximizing the completion of the task.

[0045] Given task T i The time interval is [t] i,start ,t i,end ] and satellites j Time interval [s] j,start ,s j,end The satellite's coverage of the mission time is calculated using the following formula:

[0046]

[0047] Coverage refers to the planned satellite coverage of the mission time.

[0048] Satellite overlap refers to the overlap between the time windows of all satellites allocated in the final plan. Specifically, the overlap between multiple satellites is calculated as the sum of the overlaps between each pair of satellites:

[0049]

[0050] Overlap(s k ,s k' ) = max(0, min(s) k,end ,s k',end )-max(s k,start ,s k',start ))

[0051] Taking into account penalties for coverage, overlap, and number of satellites, the final score function for the task can be expressed as:

[0052] Score(t i =Coverage(t) i )-Overlap(t i )-λ penalty

[0053] λ penalty =α×K

[0054] In the above formula, α is the penalty factor for the number of satellites, and K is the final number of satellites selected for the mission.

[0055] Backtracking search algorithms iteratively try various possible options during the solution construction process. When a current choice fails to lead to a valid solution, the algorithm backtracks to the previous step and selects another possible path. The optimization objective of backtracking search algorithms is to maximize the value of each task t. i The scoring function takes into account the coverage of the mission time window, the overlap of time windows between satellites, and the penalty for the number of satellites.

[0056] Specifically, the task score is determined by several factors: the higher the satellite time window coverage of the assigned task, the higher the score; simultaneously, the smaller the overlap between satellite time windows, the higher the score; and each additional satellite used increases the penalty and decreases the score. The backtracking search algorithm explores different satellite allocation schemes to gradually find the optimal satellite allocation method to maximize the task score (Score(t)). i ).

[0057] In step S102, the high-orbit satellite includes a mission monitoring and management module. This module is responsible for monitoring and managing the fulfillment of various constraints during mission execution, ensuring that mission planning and execution always meet predetermined limitations and requirements. The mission constraint management module first defines and maintains various constraints for mission execution, including time windows, resource usage limits, and mission priorities. Then, the module monitors the mission execution status in real time, detects potential constraint conflicts or violations, such as resource overload, time delays, or mission conflicts, and takes timely and appropriate measures.

[0058] In step S103, the low-Earth orbit (LEO) satellite receives mission instructions from the high-Earth orbit (HEO) satellite, including the sub-behavior trees to be executed. It receives the sub-behavior trees via a secure and reliable communication link and verifies their integrity and format to ensure no damage or tampering occurs during data transmission. After successful verification, the module stores the behavior tree data locally, providing a reliable data foundation for subsequent function binding and code construction.

[0059] After receiving the mission instructions (which include a mission subtree) from the high-orbit satellite, the low-orbit execution layer parses the mission subtree.

[0060] First, task preparation is carried out according to the type of subtask; then, the current satellite status is analyzed to see if it supports the completion of the task. If the task requirements are not met, the high-orbit satellite is notified; if they are met, the behavior tree mechanism is used to automatically run the behavior tree to execute the task.

[0061] In the behavior tree mechanism, each behavior node in the received task sub-behavior tree will be dynamically bound to a predefined function; the predefined function usually refers to a set of standard function modules that have been set up, which provide execution logic for specific types of behavior nodes.

[0062] Specifically, these functionalities are defined based on node type and attributes, and typically include operations such as performing specific actions, updating system state, or making decisions. During the binding process, each behavioral node is associated with its corresponding functionality through a mapping relationship. This mapping relationship is constructed based on the node's type, attributes, and task requirements, enabling each node to call the appropriate functional module according to its own characteristics. The mapping process can be implemented using expressions, for example, by setting a mapping rule M:N. i →F j , where N i It is a certain behavior node, F j It is a predefined function. This expression indicates that node N... i Mapping to function F jThis ensures that each action node triggers the correct operation when it is executed.

[0063] During execution, the system traverses the behavior tree according to its logical structure and calls the corresponding functional modules based on the mapping relationship of each node to ensure the smooth execution of the task. Behavior tree execution involves traversing and executing according to the logical structure of the behavior tree.

[0064] First, the behavior tree execution unit starts from the root node and evaluates the condition judgments of each node in turn. The first step is to determine the execution path by judging the node type and node status. For example, if the child nodes of a sequential node have a failure status, the sequential node will also be in a failure status, and the subsequent branches of the sequential node will not be executed. For each executable node, the execution unit calls the bound function to complete the specific task operation. During the execution process, the behavior tree execution unit dynamically adjusts the execution flow according to the return status of the node (such as success, failure, or running) to ensure that the task is carried out in the predetermined logical order and conditions.

[0065] The beneficial effects of this invention are:

[0066] 1. It can flexibly respond to complex and ever-changing task requirements. Behavior trees allow for dynamic adjustment of task execution paths to adapt to real-time environmental changes and sudden task demands.

[0067] 2. Behavior trees decompose complex tasks into multiple independent or low-dependency sub-task units, facilitating management and expansion. When adding new task types or modifying existing tasks, only the corresponding sub-behavior tree modules need to be adjusted, greatly reducing the complexity of system maintenance and upgrades.

[0068] 3. Behavior trees provide intuitive task execution paths and logical relationships. Through visualization tools, task planners can easily review and modify task templates, reducing human error and improving the efficiency and accuracy of task management.

[0069] 4. Through the hierarchical and modular design of behavior trees, the system can quickly reconfigure the task execution order and resource allocation to adapt to dynamically changing task requirements and environmental conditions, thereby significantly improving the timeliness and reliability of overall task execution. Attached Figure Description

[0070] Figure 1 It is a flowchart of a multi-star collaborative task planning technology based on behavior trees.

[0071] Figure 2 This is a system architecture diagram of multi-star collaborative task planning technology based on behavior trees.

[0072] Figure 3 This is a ground planning layer model diagram of multi-star collaborative task planning technology based on behavior trees.

[0073] Figure 4 This is a high-orbit planning layer model diagram of multi-star collaborative task planning technology based on behavior trees.

[0074] Figure 5 This is a low-orbit execution layer model diagram of multi-star collaborative task planning technology based on behavior trees.

[0075] Figure 6 The simulation results are for behavior tree planning. Detailed Implementation

[0076] The present invention will now be described in further detail with reference to the accompanying drawings.

[0077] This invention utilizes behavior tree technology to decouple the three-layer structure involved in satellite mission planning, thereby achieving the de-management of satellite mission planning. Furthermore, by leveraging the hierarchical and modular characteristics of behavior trees and combining them with the behavior tree operation mechanism, the real-time performance of satellite mission planning is significantly improved.

[0078] like Figure 1 As shown, the behavior tree-based multi-star collaborative task planning technology provided in this embodiment of the invention includes the following steps:

[0079] S101, the ground planning layer sorts out the satellite mission requirements, models and describes the satellite missions, and sends the constructed behavior tree mission template to the high-orbit satellite;

[0080] S102, after receiving the task, the high-orbit planning layer decomposes the task to obtain the meta-task subtree (the task that a single satellite can execute independently) and performs specific satellite planning. It plans satellites that meet the task constraints to carry out the task execution and sends the task sub-behavior tree down to the low-orbit satellite.

[0081] S103 After receiving the task sub-behavior tree, the low-track execution layer binds functions and constructs code execution according to the mechanism of the behavior tree to realize the execution of specific tasks.

[0082] A behavior tree is a directed tree from the root node to the leaf nodes, which can be represented by a tuple <V, E>, where V represents the set of nodes in the behavior tree, and E represents the edges. Its nodes are divided into two main categories: control nodes and execution nodes. Control nodes are non-leaf nodes, responsible for receiving the execution results of their child nodes and applying their own node rules to determine the subsequent execution logic of the behavior tree based on these results; execution nodes are leaf nodes, representing the specific actions that can be executed. Therefore, the complete set of nodes in a behavior tree can be represented as V = A∪C∪N∪τ, where A is the set of action nodes, C is the set of condition nodes, N is the set of logical nodes (control nodes), and τ is the root node; the set of edges in the behavior tree is represented as E = V × V. Here v i It is v jThe parent node, whose state is determined by the execution result of the child node.

[0083] Table 1. Description of Commonly Used Nodes in Behavior Tree

[0084]

[0085] Behavior trees possess significant characteristics such as modularity, hierarchy, flexibility, and scalability. These features stem from their unique structural design and execution mechanism. First, the modularity of behavior trees originates from their node execution mechanism, where each node independently executes a specific function, facilitating reuse and individual debugging. Second, the hierarchical structure allows complex tasks to be progressively decomposed into simpler subtasks or operation nodes through higher-level nodes, enhancing the clarity of task management. Third, the flexibility of behavior trees benefits from the flexible task flow control mechanism provided by their control nodes (such as sequence nodes and selection nodes), enabling dynamic adjustments to the execution flow based on runtime states. Furthermore, the recursive traversal mechanism of behavior trees (Tick signals) ensures real-time monitoring and decision-making capabilities, allowing them to efficiently adapt to changes in dynamic environments.

[0086] Figure 2 This is a schematic diagram of the architecture of the multi-satellite collaborative mission planning technology based on behavior trees provided in this embodiment of the invention. As shown in the figure, the architecture consists of three layers: a ground control station, high-orbit satellites, and low-orbit satellites. The first layer, the ground control station, serves as the system's mission command center, responsible for receiving and analyzing mission requests. Through mission requirement analysis, the ground control station can extract key elements of the mission, such as the mission subject, mission time, mission space, mission status, and mission payload constraints, to ensure that the mission accurately meets expectations. A behavior tree representation model of the mission is constructed using behavior trees, decomposing complex tasks into logically clear sub-task processes, thereby achieving efficient mission management and scheduling. After completing the behavior tree construction, the ground control station uploads the mission to the high-orbit satellite in a standardized XML format, ensuring the structured and readable instructions and providing precise guidance for the satellite to execute the mission. The main function of this layer is to model and characterize the mission while ensuring the flexibility and controllability of the mission execution process. The second layer involves the high-orbit satellite receiving complex behavior tree mission instructions (represented in XML file form) from the ground control station and performing more detailed decomposition and planning of the mission. Through the mission planning and monitoring module, the high-orbit satellite triggers and sends specific mission subtrees to the low-orbit satellite for execution. The high-orbit satellite layer acts as the central coordinator throughout the process, responsible for overall mission planning, coordination, and status monitoring. The third layer, the low-orbit satellite, receives the sub-tasks from the high-orbit satellite, executes them through the mission parsing and execution module, collects data, and feeds it back to the high-orbit satellite. The low-orbit satellite layer directly undertakes mission execution and adjusts the mission execution plan in real time based on the feedback mechanism to ensure accurate mission completion.

[0087] Figure 3 This is an example diagram of a task template for the behavior tree-based multi-satellite collaborative task planning technology provided in this embodiment of the invention. The top-level analysis identifies the characteristics of common satellite missions, and a five-tuple is used to model the mission.

[0088] task=<subject, time, space, payload, status>

[0089] Where subject is the task body, subject = <number, type>, where number and type are the task number and task type, respectively; time is the task time, time = <start_time, end_time>, where start_time and end_time are the start and end times of the task, respectively; space is the task space, which contains the spatial information of the current task, namely the latitude and longitude of the task target; payload = <type, performance>, where payload is the satellite payload information required by the task, type is the satellite payload type, and performance is the payload performance requirements; status is the task status, which has three states: incomplete, in progress, and completed.

[0090] like Figure 4 The figure shown is a high-orbit planning layer model diagram of multi-star collaborative task planning technology based on behavior trees.

[0091] ①Task Receiving Node: The task receiving node is used to receive task intent, objectives, and environmental information transmitted from the top-level planning model. This node is responsible for parsing and obtaining the basic parameters and requirements of the task, transforming the top-level information into a task description suitable for the intermediate layer, in order to support subsequent decomposition and planning.

[0092] ②Task decomposition node: Parses the received XML file, identifies the task information contained therein, and decomposes the task into several smaller, executable subtasks.

[0093] ③ Task Planning Node: After task decomposition, the task planning node is responsible for planning each sub-task. Based on task requirements and satellite resources, this node selects the most suitable low-Earth orbit satellite executor. This selection process considers factors such as satellite performance, location, and current status to ensure efficient task completion. This node involves an intelligent planning algorithm that combines a variable neighborhood search algorithm with a backtracking search algorithm. The Variable Neighborhood Search (VNS) algorithm is a metaheuristic optimization algorithm widely used to solve combinatorial optimization problems. This algorithm is based on a core idea: by dynamically changing the neighborhood structure of the solution, it can effectively escape local optima, thereby finding the global optimum or a better solution. The constraints involved are as follows:

[0094] ①Time constraints

[0095] For each task T i and satellites j Assume task t i The time window requirement is [t] i,start ,t i,end ], s j For task T i The visible time window is [t j,start ,t j,end The planning relationship between the mission and the satellite must meet the following time constraints:

[0096]

[0097] Among them, Match i,j =1, indicating task T i and satellites j There are overlapping time windows, which allows for allocation; Match i,j =0 indicates task T i and satellites j The time window overlap condition is not met.

[0098] ② Load capacity constraints

[0099] Each task T i Requires a certain load capacity And each satellite s j Maximum load capacity Task T i Can be assigned to satellites s j The condition is that the satellite's payload capacity is sufficient to meet the mission requirements:

[0100]

[0101] If satellites s j The load capacity is less than that of mission T i The load requirements, Match i,j It will be set to 0.

[0102] The variable neighborhood algorithm optimizes task allocation by progressively adjusting the matching neighborhood between tasks and satellites. During each task allocation, it dynamically narrows down the set of available satellites based on the task's time window and payload requirements. Task T i optional satellite set It consists of satellites that meet the following conditions:

[0103]

[0104] In the satellite mission allocation problem, matching missions and satellites not only needs to meet basic constraints (such as time overlap and payload capacity), but also needs to consider how to select the optimal solution from multiple feasible options. Introducing a reward function is crucial to effectively guide the algorithm in finding the optimal solution and evaluating different options during the solution process. In this study, the designed reward function is evaluated based on the coverage of mission time by the planned scheme, and a penalty mechanism for the number of satellites and overlapping satellite time windows is introduced to ensure that the minimum satellite time window resources are used while maximizing mission completion.

[0105] Given task T i The time interval is [t] i,start ,t i,end ] and satellites j Time interval [s] j,start ,s j,end The satellite's coverage of the mission time is calculated using the following formula:

[0106]

[0107] Coverage refers to the planned satellite coverage of the mission time.

[0108] Satellite overlap refers to the overlap between the time windows of all satellites allocated in the final plan. Specifically, the overlap between multiple satellites can be calculated as the sum of the overlaps between each pair of satellites:

[0109]

[0110] Overlap(s k ,s k' ) = max(0, min(s) k,end ,s k',end )-max(s k,start ,s k',start ))

[0111] Taking into account penalties for coverage, overlap, and number of satellites, the final score function for the task can be expressed as:

[0112] Score(t i =Coverage(t) i )-Overlap(t i )-λ penalty

[0113] λ penalty =α×K

[0114] In the above formula, α is the penalty factor for the number of satellites, and K is the final number of satellites selected for the mission.

[0115] The optimization objective of the backtracking search algorithm is to maximize the value of each task T. i The scoring function comprehensively considers the coverage of the task's time window, the overlap of time windows between satellites, and the penalty for the number of satellites. Specifically, the task's score is determined by the following factors: the higher the coverage of the satellite time window assigned to the task, the higher the score; simultaneously, the smaller the overlap between satellite time windows, the higher the score; and each additional satellite increases the penalty and decreases the score. The backtracking search algorithm explores different satellite allocation schemes to gradually find the optimal satellite allocation method to maximize the task's score, Score(t). i ).

[0116] ④ Task Assignment Node: This node assigns specific subtasks to the low-Earth orbit (LEO) satellite executors. It distributes detailed task information to the selected satellites and monitors task execution via an interface. The goal of the task assignment node is to ensure that each subtask is correctly assigned to the appropriate executor to guarantee the completion of the overall mission.

[0117] like Figure 5 The diagram shows a low-orbit execution layer model of a multi-satellite collaborative task planning technology based on behavior trees. Starting from the root node, the left branch checks if a task has been received (condition node). If successfully received, the task is stored (execution node). Then, the right branch reads the task from storage (execution node), executes the task (execution node), and checks if the task is complete (condition node). If the task is complete, the result is finally reported (execution node). First, the file is parsed to construct the behavior tree structure, including node types (condition nodes, sequence nodes, execution nodes, etc.) and node hierarchy. Each parsed node is bound to a specific functional module (such as a function, script, or interface). After binding, the behavior tree automatically runs from the root node according to a triggering mechanism (such as event-driven or periodic scheduling). Condition nodes determine the status, sequence nodes coordinate the execution order, and execution nodes call functional modules, ultimately completing the dynamic processing and feedback of the task.

[0118] like Figure 6The figure shows the simulation results. The simulation results of the high-Earth orbit (HEO) and low-Earth orbit (LEO) satellite behavior tree demonstrate the execution process of the satellite mission. The left and right sides of the figure show the XML configuration files and simulation log outputs of the HEO and LEO satellite behavior trees, respectively. On the left, the behavior tree describes the sequence and conditions of the mission through a series of nodes, such as receiving target information, calculating target points, broadcasting mission instructions, and receiving mission commands. Each node represents a specific behavior or judgment condition; for example, the condition node "receive_target_info" indicates waiting to receive target information and continuing subsequent operations when the condition is met. The combination of these conditions and actions forms a hierarchical execution flow. These results show that the design of the entire behavior tree meets the requirements of mission execution and can accurately ensure the smooth execution of the mission through the collaborative work of different satellite modules. The execution status and state transitions of each mission node are clearly recorded, facilitating analysis and debugging. During the simulation, the system's behavior nodes are executed sequentially, each step accurately performs the predetermined task, and provides status feedback based on the actual situation, reflecting the efficiency and stability of the HEO and LEO satellite behavior tree simulation system in actual operation.

Claims

1. A multi-star collaborative task planning method based on behavior trees, characterized in that, Includes the following steps; S101, the ground planning layer sorts out the satellite mission requirements, models and describes the satellite missions, and sends the behavior tree mission representation template to the high-orbit satellite layer. S102, after receiving the mission from the high-orbit satellite layer, the mission is planned according to the behavior tree mission template; The task is decomposed to obtain a task subtree and specific satellite planning is carried out. Satellites that meet the task constraints are planned to perform the task and the task subtree is sent down to the low Earth orbit execution layer. S103 After receiving the task sub-behavior tree, the low-orbit execution layer binds functions and constructs code to execute specific tasks according to the mechanism of the behavior tree.

2. The multi-star collaborative task planning method based on behavior tree according to claim 1, characterized in that, In S101, the ground planning layer includes a mission requirement analysis module. The mission requirement analysis module is used to parse and organize the mission requirements of the satellite, and construct a mission behavior tree through the behavior tree mission construction module and upload it to the high-orbit satellite. The mission behavior tree describes in detail the hierarchical structure of the mission, the conditions of each sub-task, and the execution actions.

3. The multi-star collaborative task planning method based on behavior tree according to claim 2, characterized in that, The mission requirement analysis module is used to comprehensively receive, parse, and organize satellite mission requirements from users or command centers. First, the task requirements analysis module uses intelligent algorithms and a rule engine to automatically identify the subject, priority, resource requirements, and time constraints of a task, and transforms these requirements into a structured data format. The task requirements analysis module has dynamic update capabilities, which can adjust and optimize task requirements in a timely manner based on changes in real-time input information, ensuring that the task modeling process is always based on the latest and most accurate requirements information; Through the task requirements analysis module, the ground planning layer can efficiently and accurately transform complex task requirements into operable behavior tree task templates, providing a solid data foundation and guarantee for subsequent task modeling and planning. Then, the behavior tree task template construction module of the ground planning layer transforms the structured data parsed by the task requirements analysis module into a behavior tree structure, and uses the hierarchical and modular characteristics of the behavior tree to decompose the complex satellite mission into multiple sub-tasks.

4. The multi-star collaborative task planning method based on behavior tree according to claim 3, characterized in that, The behavior tree task template building module defines the root node, control node, leaf node, and behavior subtree in the behavior tree, clarifies the execution conditions and actions of each subtask, and establishes the logical relationship between nodes to form a clear task hierarchy structure. The behavior tree template adjusts its structure promptly based on changes in task requirements, ensuring the accuracy and feasibility of the task template. This module also provides a visual representation of the behavior tree, facilitating review and modification by task planners to ensure the accuracy and completeness of the task template.

5. The multi-star collaborative task planning method based on behavior tree according to claim 4, characterized in that, In S102, the behavior tree decomposition module of the high-orbit planning layer decomposes the received complex task behavior tree template in detail according to the predetermined decomposition principle and node type. The behavior tree is split layer by layer through the recursive decomposition algorithm, and the complex structure is split into multiple independent or low-dependency sub-behavior trees, thereby structuring the complex task into independently manageable sub-task units. The implementation steps are as follows: (1) Receive the overall behavior tree task template from the ground planning layer. The behavior tree task template fully describes the hierarchical structure of the complex satellite mission to be executed, the conditions of each sub-task, and the execution actions. (2) The behavior tree decomposition module performs a comprehensive analysis of the received behavior tree template. The high-orbit satellite layer identifies each node in the behavior tree and the logical relationships between them, including key elements such as the task subject, spatial constraints, resource constraints and time constraints. (3) The module adopts a recursive decomposition algorithm to split the overall behavior tree layer by layer. The recursive decomposition algorithm starts from the root node and decomposes each child node layer by layer. Through recursion, each behavior node is decomposed step by step until it is decomposed into the smallest independent sub-behavior tree. (4) Classify according to the predetermined decomposition principles and node types; (5) Based on the generated sub-behavior tree, the high-orbit planning layer uses the satellite planning module to rationally allocate sub-tasks to the most suitable low-orbit satellites according to the resource requirements, priorities and time constraints of each sub-task; (6) Through the task distribution module, the high-orbit planning layer transmits the generated sub-behavior tree task instructions to the corresponding low-orbit satellite.

6. The multi-star collaborative task planning method based on behavior tree according to claim 5, characterized in that, In step (3), the recursive decomposition formula is expressed as T(n) = T(n-1) + S(n), where T(n) represents the complexity of the current behavior tree, T(n-1) is the subtree structure after the previous recursive decomposition, and S(n) is the complexity of the subtree structure generated in the current layer. By recursively reducing the complexity of each layer, the behavior tree is eventually split into smaller subtrees. During each decomposition, the sub-behavior trees with lower dependencies are selected first to ensure the independence between each subtree. The original complex tree structure is continuously simplified into smaller sub-behavior trees that are easier to manage through recursion.

7. The multi-star collaborative task planning method based on behavior tree according to claim 5, characterized in that, In step (5), the intelligent planning algorithm combines the variable neighborhood search algorithm with the backtracking search algorithm for satellite intelligent planning. The variable neighborhood search algorithm effectively escapes local optima by dynamically changing the neighborhood structure of the solution, thereby finding the global optimal solution or a better solution. The constraints involved are as follows: (1) Time constraints For each task T i and satellites j Assume task t i The time window requirement is [t] i,start ,t i,end ], s j For task T i The visible time window is [t j,start ,t j,end The planning relationship between the mission and the satellite must meet the following time constraints: Among them, Match i,j =1, indicating task T i and satellites j There are overlapping time windows, which allows for allocation; Match i,j =0 indicates task T i and satellites j The time window overlap condition is not met; (2) Load capacity constraints Each task T i Requires a certain load capacity And each satellite s j Maximum load capacity Task T i Assigned to satellites j The condition is that the satellite's payload capacity is sufficient to meet the mission requirements: If satellites s j The load capacity is less than that of mission T i The load requirements, Match i,j It will be set to 0; The variable neighborhood algorithm optimizes task allocation by progressively adjusting the matching neighborhood between tasks and satellites. During each task allocation, it dynamically narrows down the set of available satellites based on the task's time window and payload requirements; Task T i optional satellite set It consists of satellites that meet the following conditions: Given task T i The time interval is [t] i,start ,t i,end ] and satellites j Time interval [s] j,start ,s j,end The satellite's coverage of the mission time is calculated using the following formula: Coverage refers to the planned satellite coverage of the mission time. Satellite overlap refers to the overlap between the time windows of all satellites allocated in the final plan; the overlap between multiple satellites is calculated as the sum of the overlaps between each pair of satellites. Taking into account penalties for coverage, overlap, and number of satellites, the final score function for the task is expressed as: Score(t i )=Coverage(t i )-Overlap(t i )-λ penalty l penalty =α×K In the above formula, α is the penalty factor for the number of satellites, and K is the final number of satellites selected for the mission; In the backtracking search algorithm, the task score is determined by several factors: the higher the coverage of the assigned satellite time window, the higher the score; the smaller the overlap between satellite time windows, the higher the score; and each additional satellite used increases the penalty and decreases the score. The backtracking search algorithm explores different satellite allocation schemes to gradually find the optimal satellite allocation method to maximize the task score (Score(t)). i ).

8. The multi-star collaborative task planning method based on behavior tree according to claim 7, characterized in that, In step S103, the low-Earth orbit satellite receives the task instructions transmitted from the high-Earth orbit satellite, including the sub-behavior trees to be executed. The low-Earth orbit satellite receives the task sub-behavior trees transmitted from the high-Earth orbit satellite and verifies the integrity and format of the received behavior tree data to ensure that no damage or tampering occurs during data transmission. After the verification is successful, the module stores the behavior tree data locally, providing a reliable data foundation for subsequent function binding and code construction. After receiving the mission instructions from the high-orbit satellite, the low-orbit execution layer parses the mission subtree. First, then prepare the task according to the type of subtask; Then, the current satellite status is analyzed to determine if it supports the completion of the mission. If the mission requirements are not met, the information is reported to the high-orbit satellite. If the requirements are met, the mission is executed automatically by relying on the behavior tree mechanism.

9. The multi-star collaborative task planning method based on behavior tree according to claim 8, characterized in that, In the behavior tree mechanism, each behavior node in the received task sub-behavior tree will be dynamically bound to a predefined function; the predefined function refers to a set of standard function modules that have been set up, which provide execution logic for specific types of behavior nodes. Functions are defined based on node type and attributes, including performing specific actions, updating system state, or making decision-making operations; During the binding process, each behavior node is associated with its corresponding function through a mapping relationship. This mapping relationship is constructed based on the node's type, attributes, and task requirements, enabling each node to call the corresponding functional module according to its own characteristics. The mapping process is implemented through expressions, defining a mapping rule M:N. i →F j , where N i It is a certain behavior node, F j It is a predefined function; this expression indicates that node N will be... i Mapping to function F j This ensures that each action node triggers the correct operation when it is executed.

10. The multi-star collaborative task planning method based on behavior tree according to claim 9, characterized in that, During execution, the system traverses the behavior tree according to its logical structure and calls the corresponding functional modules based on the mapping relationship of each node to ensure the smooth execution of the task; behavior tree execution is the traversal and execution according to the logical structure of the behavior tree. First, the behavior tree execution unit starts from the root node and evaluates the condition judgments of each node in turn. The first step is to determine the execution path by judging the node type and node state. For example, if the child nodes of a sequential node have a failure state, the sequential node will also be in a failure state, and the subsequent branches of the sequential node will not be executed. For each executable node, the execution unit calls the bound function to complete the specific task operation. During the execution process, the behavior tree execution unit dynamically adjusts the execution flow according to the return status of the nodes to ensure that the task is carried out in the predetermined logical order and conditions.

Images