Multi-robot collaborative distributed online task allocation algorithm

Abstract

The invention belongs to the technical field of robot collaborative operation. The invention provides a distributed online task allocation algorithm based on multi-robot cooperation. According to the embodiment of the invention, the method comprises the steps: processing a sub-task and a task condition of the sub-task through LTL, and obtaining a first sc-LTL formula; processing the first sc-LTL formula by using NBA to obtain a first feasible path; processing the first feasible path by utilizing a task dependency relationship generation algorithm to obtain a corresponding first task dependency relationship; issuing the sub-tasks in the first task dependency relationship by using an online task issuing algorithm, and allocating the issued sub-tasks by the unmanned aerial vehicle by using a negotiation allocation algorithm; and when tasks are continuously increased, original subtasks and newly increased subtasks are merged by utilizing a task dependency relationship merging algorithm, and the original subtasks and the newly increased subtasks are published online and then are negotiated and distributed by a robot, so that the purpose of optimizing the dynamic task distribution process is achieved.

Description

Technical Field

[0001] The disclosed embodiments relate to the technical field of robot collaborative work, and in particular to a distributed online task allocation algorithm for multi-robot collaboration. Background Art

[0002] In the field of robotics, complex task allocation is still a direction that needs further research. In recent years, scholars in the field of task allocation have mostly used Linear Temporal Logic (LTL) as a top-level tool to describe complex multi-robot task scenarios. Temporal logic can not only encapsulate traditional point-to-point Boolean goals, but also encapsulate complex timing requirements. However, at present, temporal logic still faces some problems to be solved. For example, temporal logic only encapsulates task requirements, which is extremely complex. How to find the optimal solution is a problem worth studying. Most existing methods are static optimization, which converts temporal logic into an automaton or linear constraint for linear solution. The above methods are difficult to adapt to dynamic task environments, can only handle a type of pre-set tasks, and cannot handle dynamic uncertain task requirements. Summary of the invention

[0003] In order to avoid the shortcomings of the prior art, the present invention provides a distributed online task allocation algorithm for multi-robot collaboration to solve the problems in the prior art that it is difficult to adapt to dynamic task environments, can only handle one type of pre-set tasks, and cannot handle dynamic uncertain task requirements.

[0004] According to an embodiment of the present disclosure, a distributed online task allocation algorithm for multi-robot collaboration is provided, the method comprising:

[0005] Processing a number of subtasks and their task conditions using a linear temporal logic formula to obtain a first sc-LTL formula;

[0006] Processing the first sc-LTL formula using a non-deterministic Butch automaton to obtain a first feasible path;

[0007] Processing the first feasible path using a task dependency generation algorithm to obtain a corresponding first task dependency;

[0008] The subtasks in the first task dependency are published using an online task publishing algorithm, and the drone allocates the published subtasks using a negotiation allocation algorithm.

[0009] Furthermore, the step of processing the plurality of subtasks and their task conditions using a linear temporal logic formula to obtain a first sc-LTL formula includes:

[0010] All the subtasks and the task conditions are represented by using the atomic propositions and a plurality of Boolean and temporal operators in the linear temporal logic formula to obtain the first sc-LTL formula.

[0011] Furthermore, the step of processing the first sc-LTL formula using a non-deterministic Butch automaton to obtain a first feasible path includes:

[0012] Setting the non-deterministic Butch automaton;

[0013] The non-deterministic Butch automaton is used to find the shortest path from the first sc-LTL formula to obtain the first feasible path.

[0014] Furthermore, the task dependency generation algorithm includes:

[0015] The order of each two subtasks is determined in turn; wherein,

[0016] For the priority relationship, if the two subtasks can be executed after being exchanged, then there is no priority relationship between the two subtasks; if the two subtasks cannot be executed after being exchanged, then there is a priority relationship between the two subtasks; all the subtasks are compared, and a determined priority relationship set is obtained;

[0017] Regarding the conflict relationship, if the two subtasks can be executed after being exchanged, then there is no conflict relationship between the two subtasks; if the two subtasks cannot be executed after being exchanged, then there is a conflict relationship between the two subtasks; all the subtasks are compared, and a determined conflict relationship set is obtained.

[0018] Furthermore, the step of processing the first feasible path using a task dependency generation algorithm to obtain a corresponding first task dependency includes:

[0019] Analyzing every two of the subtasks in the first feasible path using the task dependency generation algorithm to obtain a first priority relationship set and a first conflict relationship set between all the subtasks;

[0020] The first task dependency relationships of all the subtasks are obtained according to the first priority relationship set and the first conflict relationship set.

[0021] Furthermore, the method also includes:

[0022] Get the newly added subtask;

[0023] Processing the newly added subtask and its task conditions using the linear temporal logic formula to obtain a second sc-LTL formula;

[0024] Processing the second sc-LTL formula using the non-deterministic Butch automaton to obtain a second feasible path;

[0025] Processing the second feasible path using the task dependency generation algorithm to obtain a corresponding second task dependency;

[0026] Merging the first task dependency with the second task dependency using a task dependency merging algorithm to obtain a merged task dependency;

[0027] The subtasks in the combined task dependency are published using the online task publishing algorithm, and the drone distributes the published subtasks using the negotiation distribution algorithm.

[0028] Further, the step of merging the first task dependency and the second task dependency using a task dependency merging algorithm to obtain a merged task dependency includes:

[0029] Acquire all the subtasks and their first priority relationship set and the first conflict relationship set from the first task dependency relationship;

[0030] Acquire all the newly added subtasks and their second priority relationship sets and second conflict relationship sets from the second task dependency relationship;

[0031] Obtaining a merged subtask set according to the subtask and the newly added subtask;

[0032] Merging the first priority relationship set and the second priority relationship set to obtain an initial priority relationship set, and expanding the initial priority relationship set to obtain a merged priority relationship set;

[0033] Merging the first conflict relationship set and the second conflict relationship set to obtain an initial conflict relationship set, and expanding the initial conflict relationship set to obtain a merged conflict relationship set;

[0034] A merge task dependency relationship is obtained according to the merge subtask set, the merge priority relationship set and the merge conflict relationship set.

[0035] Furthermore, the online task publishing algorithm includes:

[0036] Check the first release condition and the second release condition of each subtask to be released; wherein the first release condition is that all the predecessor tasks are being executed or completed; the second release condition is that the subtask to be released has no conflict with the subtask to be executed or being executed;

[0037] When both the first publishing condition and the second publishing condition are met, the to-be-published subtask is published, and the published to-be-published subtask is added to a to-be-executed list and deleted from the to-be-published list;

[0038] The current list to be published is checked in a loop.

[0039] Furthermore, the negotiation allocation algorithm includes:

[0040] When all robots receive one or more tasks, the robot selects the nearest task according to the distance and sets it as its own target to be executed;

[0041] If two robots select the same task at the same time, the robot at a farther distance reselects another task, and the process is repeated until there is no conflict;

[0042] The robot executes the selected task, updates its task status, and removes the task from task dependencies.

[0043] The technical solution provided by the embodiments of the present disclosure may have the following beneficial effects:

[0044] In the embodiment of the present disclosure, through the above-mentioned multi-robot collaborative distributed online task allocation algorithm, on the one hand, all subtasks and their task conditions are represented by linear temporal logic formulas to obtain the first sc-LTL formula that can represent the logical relationship of all subtasks; the first sc-LTL formula is processed by non-deterministic Butch automaton to obtain the shortest path, that is, the first feasible path; the priority relationship and conflict relationship of all subtasks in the first feasible path are analyzed by the task dependency generation algorithm to obtain the first task dependency; finally, the subtasks in the task dependency are published by the online task publishing algorithm, and the drone uses the negotiation allocation algorithm to allocate the published subtasks. On the other hand, when the tasks are continuously increasing, the task dependency merging algorithm is used to process the original subtasks and the newly added subtasks to handle the increasing task requirements, publish them online, and then hand them over to the robot for negotiation and allocation of tasks, so as to achieve the purpose of optimizing the dynamic task allocation process. BRIEF DESCRIPTION OF THE DRAWINGS

[0045] The accompanying drawings herein are incorporated into the specification and constitute a part of the specification, illustrate embodiments consistent with the present disclosure, and together with the specification are used to explain the principles of the present disclosure. Obviously, the accompanying drawings described below are only some embodiments of the present disclosure, and for ordinary technicians in this field, other accompanying drawings can be obtained based on these accompanying drawings without creative work.

[0046] Figure 1A step diagram showing a distributed online task allocation algorithm for multi-robot collaboration in an exemplary embodiment of the present disclosure;

[0047] Figure 2 In the exemplary embodiment of the present disclosure, Corresponding NBA;

[0048] Figure 3 A specific flow chart showing a distributed online task allocation algorithm for multi-robot collaboration in an exemplary embodiment of the present disclosure;

[0049] Figure 4 showing the path simulation results in the exemplary embodiment of the present disclosure;

[0050] Figure 5 The task release time in the exemplary embodiment of the present disclosure is shown. DETAILED DESCRIPTION

[0051] Example embodiments will now be described more fully with reference to the accompanying drawings. However, example embodiments can be implemented in a variety of forms and should not be construed as limited to the examples set forth herein; rather, these embodiments are provided so that the disclosure will be more comprehensive and complete and to fully convey the concepts of the example embodiments to those skilled in the art. The described features, structures, or characteristics may be combined in any suitable manner in one or more embodiments.

[0052] In addition, the accompanying drawings are only schematic illustrations of the embodiments of the present disclosure and are not necessarily drawn to scale. The same reference numerals in the figures represent the same or similar parts, and their repeated descriptions will be omitted. Some of the block diagrams shown in the accompanying drawings are functional entities and do not necessarily correspond to physically or logically independent entities.

[0053] This example implementation provides a distributed online task allocation algorithm for multi-robot collaboration. Figure 1 As shown in , the distributed online task allocation algorithm for multi-robot collaboration may include: steps S101 to S104.

[0054] Step S101: using a linear temporal logic formula to process a plurality of subtasks and their task conditions to obtain a first sc-LTL formula;

[0055] Step S102: using a non-deterministic Butch automaton to process the first sc-LTL formula to obtain a first feasible path;

[0056] Step S103: using a task dependency generation algorithm to process the first feasible path to obtain a corresponding first task dependency;

[0057] Step S104: the subtasks in the task dependency are published using an online task publishing algorithm, and the drones allocate the published subtasks using a negotiation allocation algorithm.

[0058] Through the above-mentioned multi-robot collaborative distributed online task allocation algorithm, on the one hand, linear temporal logic formulas are used to represent all subtasks and their task conditions to obtain the first sc-LTL formula that can represent the logical relationship of all subtasks; the first sc-LTL formula is processed using a non-deterministic Butch automaton to obtain the shortest path, namely the first feasible path; the priority relationship and conflict relationship of all subtasks in the first feasible path are analyzed using a task dependency generation algorithm to obtain the first task dependency; finally, the subtasks in the task dependency are published using an online task publishing algorithm, and the drones use a negotiation allocation algorithm to allocate the published subtasks. On the other hand, when there are increasing tasks, the task dependency merging algorithm is used to process the original subtasks and the newly added subtasks to handle the increasing task requirements, publish them online, and then hand them over to the robots for negotiation and allocation of tasks, so as to achieve the purpose of optimizing the dynamic task allocation process.

[0059] Next, we will refer to Figures 1 to 5 Each step of the above-mentioned distributed online task allocation algorithm for multi-robot collaboration in this example implementation is described in more detail.

[0060] In step S101, a plurality of subtasks and their task conditions are processed using a linear temporal logic formula to obtain a first sc-LTL formula.

[0061] Specifically, linear temporal logic (LTL) is the basis for the implementation of the method of this application. The linear temporal logic formula contains a set of atomic propositions AP (Atomic Propositions) and several Boolean and temporal operators. Atomic propositions are Boolean variables that can be true or false. In particular, its syntax is as follows: For simplicity, Always true; p∈AP; ∨(or), ∧(and), (not) is a logical operator; (final), ○(next), (until) is a tense operator; □ (always), (Implication) is the derivation operator.

[0062] In the alphabet 2 AP The infinite word ω on is defined as an infinite sequence ω=ω1ω2...ω i , where σ i ∈2AP . The language is defined as satisfying The set of words, that is in There is a special class of LTL formulas, called syntactically co-safe formulas (sc-LTL), which only contain tense operators. (final), ○(next), and (until), and The (not) operator only appears before atomic statements. For example means "Eventually ω1 is true, but before ω2 is true, ω ！ Not true. "

[0063] In step S102, the first sc-LTL formula is processed using a non-deterministic Butch automaton to obtain a first feasible path.

[0064] Specifically, for a given set of LTL formulas A nondeterministic Büchi automaton (NBA) equivalent to the task description can be constructed. The relevant NBA can be derived through the following structure. For example, given a Its corresponding NBA Figure 2 shown.

[0065] Definition 1 (NBA). NBA is a quintuple: Where Q is the state set, is the initial state set; Σ=AP is the allowed alphabet; δ:Q×δ→2 Q It is a state transfer relationship; is the set of accepting states.

[0066] Given an infinite word ω=ω1ω2..., we can get The result of the operation is an infinite sequence ρ = q0q1..., such that q0∈Q0, and for any q i ∈Q, i≥0, all have q i+1 ∈δ(q i ,σ i ) holds. The set of all words corresponding to accepting runs is called the language generated by NBA. The language can be represented by a prefix-suffix structure, where the prefix part can lead to a run from the initial state to the accepting state, and the suffix part can lead to a cyclic run containing the same accepting state. In addition, the satisfaction of sc-LTL formulas can be achieved in finite time, that is, if an LTL formula For any satisfaction For an infinite word ω=ω1ω2..., there exists a finite prefix that also satisfies Then this LTL is sc-LTL, which means syntactically safe.

[0067] For a given NBA, from Q0→Q F The path search is a shortest path problem, and the Dijkstra algorithm can be used to solve its shortest feasible path ω=ω1ω2.... and its corresponding ρ=q0q1....

[0068] In step S103, given a subtask set Ω, the following task dependency relationship is defined to describe the dependencies and conflicts between tasks.

[0069] Definition 2 (Task Dependency)

[0070] Task dependency is a triple in:

[0071] 1.Ω is a finite set of subtasks.

[0072] 2. is a set of priority relations, where Ω* represents the set of finite sequences on Ω. When (ω i ,ω j ...,ω k )∈≤, called (ω i ,ω j ...,ω k ) has a priority relationship, denoted by ω i ≤ω j ≤...≤ω k , then the predecessor task must be executed before the successor task, that is, task ω i Must be greater than j Start executing first.

[0073] 3. is a set of conflict relations, when (ω i ,ω j ...,ω k )∈≠, called (ω i ,ω j ...,ω k ) has a conflict relationship, denoted as ω i ≠ω j ≠...≠ω k , then ω i ,ω j ...,ω k They conflict with each other and cannot be executed at the same time.

[0074] The precedence relation has the following properties: (1) Anti-reflexivity: for all ω∈Ω, there does not exist {ω}∈≤; (2) Transitivity: if (ω1,ω2,…,ω n )∈≤and(ω n ,ω n+1 ,…,ω m )∈≤, then (ω1,ω2,…,ω m )∈≤;(3) Asymmetry: If (ω1,ω2,…,ω n )∈≤, then there does not exist (ω n ,ω n-1 ,…,ω1)∈≤.

[0075] The conflict relation has the following properties: (1) non-emptiness: every task conflicts with itself; (2) transitivity: if (ω1,ω2,…,ω n )∈≠and(ω n ,ω n+1 ,…,ω m )∈≠, then (ω1,ω2,…,ω m )∈≠; (3) Symmetry: If (ω1,ω2,…,ω n )∈≠, then for (ω1,ω2,…,ω n ) Any permutation of the elements above Both

[0076] For a given feasible path A corresponding task dependency relationship can be generated through Algorithm 1 (i.e., the task dependency generation algorithm):

[0077] Algorithm 1 Generate task dependencies

[0078]

[0079]

[0080] Among them, functiongenerate_less_equal checks whether there is a strict priority relationship between the two words by exchanging the two words in the path in sequence, and returns a certain priority relationship set. Functiongenerate_opposed checks whether there is a conflict relationship between the two words by setting the two words in the path to be executed simultaneously.

[0081] In step S104, Figure 3 As shown, whenever a new subtask is proposed, the merge task dependency algorithm converts it into a feasible task dependency, and then adds it to the existing task dependency in sequence.

[0082] The merging of task dependencies can be achieved through Algorithm 2 (i.e., the merging task dependencies algorithm):

[0083] Algorithm 2: Merging task dependencies

[0084]

[0085]

[0086] First, from the existing task dependencies (i.e. the first task dependencies) And the newly added task dependency (i.e. the second task dependency) Then, the task set Ω and Ω′ are merged to obtain a new task set Ω″. Next, the existing priority relationship ≤ and the newly added priority relationship ≤′ are merged to obtain a preliminary priority relationship set ≤″. In order to ensure that the priority relationship satisfies transitivity, the preliminary merged priority relationship set is expanded. If there is and In the precedence relation, add to the priority relation. Next, the existing conflict relation ≠ and the newly added conflict relation ≠′ are merged to obtain a preliminary conflict relation set ≠″. In order to ensure that the conflict relation satisfies symmetry and transitivity, the preliminary merged conflict relation set is expanded.

[0087] After a merged task dependency is given, the online allocation algorithm will cyclically check the conditions for each subtask release and release the subtasks that meet the conditions. The released subtasks will be assigned by robot negotiation. In this online allocation algorithm, a subtask contains the following states:

[0088] Definition 3 (Task Status)

[0089] For a subtask that cannot be decomposed any further, it contains the following states:

[0090] 1. To be released; 2. To be executed; 3. In execution; 4. Completed.

[0091] For a task to be released, there are two conditions for release, and it can only be released if both conditions are met:

[0092] Precedence relationship check: In the precedence relationship, all predecessor tasks of the current task are in progress or have been completed.

[0093] For a task ω∈Ω, its predecessor task is: [Pre(ω)=u∈Ω|(u,,ω)∈≤]; if and only if

[0094]

[0095] When satisfied, the priority relationship is established.

[0096] Conflict relationship check: If a task is in the conflict list, the conflicting task cannot be pending or being executed.

[0097] For a task ω∈Ω, its conflicting task is: [Conflict(ω)=∪S∈≠|w∈S]; if and only if

[0098]

[0099] When satisfied, a conflict relationship is established.

[0100] Therefore, the release of tasks will be determined by Algorithm 3 (i.e., online task release algorithm): Algorithm 3 Online Task Release Algorithm

[0101]

[0102]

[0103] After a subtask is released, all robots can learn the specific requirements of the task, and the task allocation is reached through mutual negotiation among all robots. The negotiation follows the following steps:

[0104] When all robots receive one (or more) tasks, they independently select the task closest to them and set it as their "target to be executed", that is,

[0105]

[0106] Where r∈{robots} is each robot, pos(r) and pos(ω) are the robot position and task position respectively, and Ω R For all published tasks.

[0107] For all robots r1,r2∈{robots} and tasks ω∈Ω R : If both r1 and r2 choose task ω, the robot that is farther away reselects the nearest non-conflicting task:

[0108]

[0109] Repeat this process until there are no conflicts.

[0110] A robot r∈{robots} performs a task of its choice ω∈Ω R , and update its task status to remove it from the task dependencies.

[0111] Therefore, Algorithm 4 (i.e., negotiation allocation algorithm) can be obtained as follows:

[0112] Algorithm 4 Robot Negotiation Allocation

[0113]

[0114]

[0115] In a specific embodiment, all subtasks and task conditions are represented by using atomic propositions and a number of Boolean and temporal operators in a linear temporal logic formula to obtain a first sc-LTL formula.

[0116] A non-deterministic Bouchet automaton is set; the non-deterministic Bouchet automaton is used to find the shortest path from the first sc-LTL formula to obtain a first feasible path.

[0117] The task dependency generation algorithm is used to analyze every two subtasks in the first feasible path to obtain a first priority relationship set and a first conflict relationship set between all subtasks; and the first task dependency of all subtasks is obtained according to the first priority relationship set and the first conflict relationship set. The task dependency generation algorithm includes:

[0118] The order of each two subtasks is determined in turn; among them, for the priority relationship, if the two subtasks can be executed after being exchanged, then there is no priority relationship between the two subtasks; if the two subtasks cannot be executed after being exchanged, then there is a priority relationship between the two subtasks; compare all subtasks and obtain a determined set of priority relationships; for the conflict relationship, if the two subtasks can be executed after being exchanged, then there is no conflict relationship between the two subtasks; if the two subtasks cannot be executed after being exchanged, then there is a conflict relationship between the two subtasks; compare all subtasks and obtain a determined set of conflict relationships.

[0119] When there is a new subtask, obtain the newly added subtask; use the linear temporal logic formula to process the newly added subtask and its task conditions to obtain the second sc-LTL formula; use the non-deterministic Butch automaton to process the second sc-LTL formula to obtain the second feasible path; use the task dependency generation algorithm to process the second feasible path to obtain the corresponding second task dependency; use the task dependency merging algorithm to merge the first task dependency with the second task dependency to obtain a merged task dependency; use the online task publishing algorithm to publish the subtasks in the merged task dependency, and the drone uses the negotiation allocation algorithm to allocate the published subtasks.

[0120] Obtain all subtasks and their first priority relationship set and first conflict relationship set from the first task dependency; obtain all newly added subtasks and their second priority relationship set and second conflict relationship set from the second task dependency; obtain a merged subtask set based on the subtasks and newly added subtasks; merge the first priority relationship set and the second priority relationship set to obtain an initial priority relationship set, and expand the initial priority relationship set to obtain a merged priority relationship set; merge the first conflict relationship set and the second conflict relationship set to obtain an initial conflict relationship set, and expand the initial conflict relationship set to obtain a merged conflict relationship set; obtain a merged task dependency based on the merged subtask set, the merged priority relationship set and the merged conflict relationship set.

[0121] Check the first release condition and the second release condition of each subtask to be released; wherein the first release condition is: all predecessor tasks are being executed or completed; the second release condition is: the subtask to be released has no conflict with the subtask to be executed or being executed; when the first release condition and the second release condition are met at the same time, release the subtask to be released, and add the released subtask to be released to the list to be executed and delete it from the list to be released; loop to check the current list to be released.

[0122] When all robots receive one or more tasks, they select the nearest task based on the distance and set it as their intended execution target; if two robots select the same task at the same time, the robot with a longer distance will reselect other tasks and repeat the process until there is no conflict; the robot executes the selected task, updates its task status, and removes the task from the task dependency.

[0123] In a specific embodiment, a simulation result is given below. The tasks are all fixed-point tasks, the number of robots is 5, and the initial given task conditions are: It means "start executing tasks A, E, and F, and then start executing task B, and then start executing task C (which cannot be performed at the same time as D), start executing task D (which cannot be performed at the same time as C), and finally all tasks are completed"; then add a new task at 5s of simulation time It means "start executing task G, start executing task I (which cannot be performed at the same time as H), and then start executing task H (which cannot be performed at the same time as I), and eventually all tasks are completed."

[0124] like Figure 4 As shown in the figure, the numerical simulation results are plotted, showing the location of the task and the trajectory of the robot.

[0125] like Figure 5 As shown, the release time of each task is given, demonstrating the effectiveness of the online task release mechanism.

[0126] Through the above-mentioned multi-robot collaborative distributed online task allocation algorithm, on the one hand, linear temporal logic formulas are used to represent all subtasks and their task conditions to obtain the first sc-LTL formula that can represent the logical relationship of all subtasks; the first sc-LTL formula is processed by non-deterministic Butch automaton to obtain the shortest path, that is, the first feasible path; the priority relationship and conflict relationship of all subtasks in the first feasible path are analyzed by the task dependency generation algorithm to obtain the first task dependency; finally, the subtasks in the task dependency are released by the online task release algorithm, and the drone uses the negotiation allocation algorithm to allocate the released subtasks. On the other hand, when there are increasing tasks, the task dependency merging algorithm is used to process the original subtasks and the newly added subtasks to handle the increasing task requirements, publish them online, and then hand them over to the robot for negotiation and allocation of tasks, so as to achieve the purpose of optimizing the dynamic task allocation process.

[0127] In addition, the terms "first" and "second" are used for descriptive purposes only and should not be understood as indicating or implying relative importance or implicitly indicating the number of technical features indicated. Thus, a feature defined as "first" or "second" may explicitly or implicitly include one or more of the features. In the description of the embodiments of the present disclosure, the meaning of "multiple" is two or more, unless otherwise clearly and specifically defined.

[0128] In the description of this specification, the description with reference to the terms "one embodiment", "some embodiments", "example", "specific example" or "some examples" etc. means that the specific features, structures, materials or characteristics described in conjunction with the embodiment or example are included in at least one embodiment or example of the present disclosure. In this specification, the schematic representations of the above terms do not necessarily refer to the same embodiment or example. Moreover, the specific features, structures, materials or characteristics described may be combined in any one or more embodiments or examples in a suitable manner. In addition, those skilled in the art may combine and combine the different embodiments or examples described in this specification.

[0129] Those skilled in the art will readily appreciate other embodiments of the present disclosure after considering the specification and practicing the invention disclosed herein. This application is intended to cover any modification, use or adaptation of the present disclosure, which follows the general principles of the present disclosure and includes common knowledge or customary techniques in the art that are not disclosed in the present disclosure. The specification and examples are intended to be exemplary only, and the true scope and spirit of the present disclosure are indicated by the appended claims.

Claims

1. A distributed online task allocation algorithm for multi-robot collaboration, characterized in that: The method includes: Processing a number of subtasks and their task conditions using a linear temporal logic formula to obtain a first sc-LTL formula; Processing the first sc-LTL formula using a non-deterministic Butch automaton to obtain a first feasible path; Processing the first feasible path using a task dependency generation algorithm to obtain a corresponding first task dependency; The subtasks in the first task dependency are published using an online task publishing algorithm, and the drones allocate the published subtasks using a negotiation allocation algorithm.

2. The distributed online task allocation algorithm for multi-robot collaboration according to claim 1 is characterized in that: The step of processing a plurality of subtasks and their task conditions by using a linear temporal logic formula to obtain a first sc-LTL formula includes: All the subtasks and the task conditions are represented by using the atomic propositions and a plurality of Boolean and temporal operators in the linear temporal logic formula to obtain the first sc-LTL formula.

3. The distributed online task allocation algorithm for multi-robot collaboration according to claim 2 is characterized in that: The step of processing the first sc-LTL formula by using a non-deterministic Butch automaton to obtain a first feasible path includes: Setting the non-deterministic Butch automaton; The non-deterministic Butch automaton is used to find the shortest path from the first sc-LTL formula to obtain the first feasible path.

4. The distributed online task allocation algorithm for multi-robot collaboration according to claim 3 is characterized in that: The task dependency generation algorithm includes: The order of each two subtasks is determined in turn; wherein, For the priority relationship, if the two subtasks can be executed after being exchanged, then there is no priority relationship between the two subtasks; if the two subtasks cannot be executed after being exchanged, then there is a priority relationship between the two subtasks; all the subtasks are compared, and a determined priority relationship set is obtained; Regarding the conflict relationship, if the two subtasks can be executed after being exchanged, then there is no conflict relationship between the two subtasks; if the two subtasks cannot be executed after being exchanged, then there is a conflict relationship between the two subtasks; all the subtasks are compared, and a determined conflict relationship set is obtained.

5. The distributed online task allocation algorithm for multi-robot collaboration according to claim 4 is characterized in that: The step of processing the first feasible path by using a task dependency generation algorithm to obtain a corresponding first task dependency includes: Analyzing every two of the subtasks in the first feasible path using the task dependency generation algorithm to obtain a first priority relationship set and a first conflict relationship set between all the subtasks; The first task dependency relationships of all the subtasks are obtained according to the first priority relationship set and the first conflict relationship set.

6. The distributed online task allocation algorithm for multi-robot collaboration according to claim 5 is characterized in that: The method further includes: Get the newly added subtask; Processing the newly added subtask and its task conditions using the linear temporal logic formula to obtain a second sc-LTL formula; Processing the second sc-LTL formula using the non-deterministic Butch automaton to obtain a second feasible path; Processing the second feasible path using the task dependency generation algorithm to obtain a corresponding second task dependency; Merging the first task dependency with the second task dependency using a task dependency merging algorithm to obtain a merged task dependency; The subtasks in the combined task dependency are published using the online task publishing algorithm, and the drone distributes the published subtasks using the negotiation distribution algorithm.

7. The distributed online task allocation algorithm for multi-robot collaboration according to claim 6 is characterized in that: The step of merging the first task dependency and the second task dependency using a task dependency merging algorithm to obtain a merged task dependency includes: Acquire all the subtasks and their first priority relationship set and the first conflict relationship set from the first task dependency relationship; Acquire all the newly added subtasks and their second priority relationship sets and second conflict relationship sets from the second task dependency relationship; Obtaining a merged subtask set according to the subtask and the newly added subtask; Merging the first priority relationship set and the second priority relationship set to obtain an initial priority relationship set, and expanding the initial priority relationship set to obtain a merged priority relationship set; Merging the first conflict relationship set and the second conflict relationship set to obtain an initial conflict relationship set, and expanding the initial conflict relationship set to obtain a merged conflict relationship set; A merge task dependency relationship is obtained according to the merge subtask set, the merge priority relationship set and the merge conflict relationship set.

8. The distributed online task allocation algorithm for multi-robot collaboration according to claim 7 is characterized in that: The online task publishing algorithm includes: Check the first release condition and the second release condition of each subtask to be released; wherein the first release condition is that all the predecessor tasks are being executed or completed; the second release condition is that the subtask to be released has no conflict with the subtask to be executed or being executed; When both the first publishing condition and the second publishing condition are met, the to-be-published subtask is published, and the published to-be-published subtask is added to a to-be-executed list and deleted from the to-be-published list; The current list to be published is checked in a loop.

9. The distributed online task allocation algorithm for multi-robot collaboration according to claim 8 is characterized in that: The negotiation allocation algorithm includes: When all robots receive one or more tasks, the robot selects the nearest task according to the distance and sets it as its own target to be executed; If two robots select the same task at the same time, the robot at a farther distance reselects another task, and the process is repeated until there is no conflict; The robot executes the selected task, updates its task status, and removes the task from task dependencies.

Images