A method for resolving path conflicts during multi-robot collaborative work

Abstract

The present invention discloses a method for resolving path conflicts during the collaborative work of multiple robots, including defining sets of path points for multiple robots, judging and generating a set of conflict points, defining multiple conflict scenarios based on whether the starting points and ending points of multiple robots are in the set of conflict points, calculating the in-place waiting time of the robots in the task according to the conflict scenarios, and transmitting the in-place waiting time back to the robots to resolve the path conflict problem. Compared with the traditional robot inspection mode, it not only improves the inspection efficiency of the robots, but also solves the problem that the paths in the multi-robot inspection cannot be dynamically adjusted and optimized.

Description

Technical Field

[0001] The present invention relates to the technical field of intelligent robot path planning, and particularly relates to a method for solving path conflicts during collaborative work of multiple robots. Background Art

[0002] In modern industrial applications, multi-robot systems have been widely used in fields such as warehousing, logistics, and manufacturing. In these application scenarios, collaborative work of multiple robots can effectively improve work efficiency. However, when multiple robots perform different tasks in a shared space, the path conflict problem becomes one of the key problems for the stable operation of the system. Path conflicts may not only cause delays in robot tasks, but may even lead to collisions and hardware damage. Therefore, how to quickly and efficiently solve the path conflict problem of multiple robots has become an urgent technical problem to be solved.

[0003] In a multi-robot system, traditional single-robot path planning algorithms face problems of path overlap and resource competition. To avoid path overlap and ensure that the paths of each robot do not conflict during operation, this patent proposes a method for solving path conflicts during collaborative work of multiple robots. Summary of the Invention

[0004] A method for solving path conflicts during collaborative work of multiple robots proposed by the present invention can solve the technical problems in the background art.

[0005] To achieve the above object, the present invention adopts the following technical solutions:

[0006] A method for solving path conflicts during collaborative work of multiple robots, comprising:

[0007] Using s to represent the coordinates of the actual scene and t to represent the time taken for the robot to reach the specified position; the robot generates list information and uploads it to the server. The server performs path planning according to the list information, and divides the robots into two states: idle and in-task. Conflict resolution is only applicable to robots in-task; the server arranges and combines the robots in-task. In each arrangement, the repeated path points in the list of multiple robots in-task are used as conflict points and put into the conflict point set. According to whether the starting and ending points of multiple robots are in the conflict point set, the conflict scenario is obtained. According to the conflict scenario, the in-task robot's in-place waiting time is calculated, and the in-place waiting time of the robot is sent back to the robot to solve the path conflict problem.

[0008] Furthermore, the method for performing path planning according to the list information in the present invention includes:

[0009] The way to measure the quality of the path is

[0010] In the formula, represents the movement cost of moving to the specified path, that is, the path distance between the current path point and the arrival path point is the heuristic function, representing the estimated cost. The heuristic function combines the spatial distance and the time dimension; The value represents the quality of the path,

[0011] = ;

[0012] , represents the distance value considering the Euclidean distance, turning angle, average curvature, and moving speed, , where is the estimated Euclidean distance from the current position to the end point, θ is the total estimated turning angle of the path, is the estimated average curvature of the path, represents the moving speed of the robot; represents considering the angular velocity of the robot , linear velocity , waiting time The time value of these factors, that is, = , is the angle of the change in the orientation of the robot before and after movement;

[0013] The robot starts from the starting point, first searches for adjacent points, and judges the optimal adjacent point by comparing the values. Based on the optimal adjacent point, it expands outward and approaches the end point through iteration, and finally obtains the optimal path to the end point.

[0014] Furthermore, in the present invention, the robot uploads its own list information to the server. The server senses whether there are conflict points through whether the path points are repeated. The algorithm of the server is independent of the map, abstracts the information of the map, and does not rely on the real map information.

[0015] Furthermore, the way for the server in the present invention to divide the robot into two states of being idle and being in a task is as follows:

[0016] A robot whose position is not in the walking route of other robots and stays still is an idle robot;

[0017] A robot whose position changes or does not change but is in the walking route of other robots is a robot in a task.

[0018] Further, the method for obtaining a conflict scenario in the present invention based on whether the starting points and ending points of multiple robots are in the conflict point set is as follows:

[0019] Select any two robots from n robots and set them as robot R1 and robot R2, narrow down the conflict scenario to between the two robots, and solve the conflict between robot R1 and robot R2 by traversal, so as to solve the path conflict between n robots.

[0020] Further, the calculation algorithm for the in-situ waiting time of the robot in the present invention is as follows:

[0021] Select any two robots from n robots and set them as robot R1 and robot R2. Take the intersection of the list information of robot R1 and robot R2 to obtain the set of path points where robot R1 and robot R2 conflict;

[0022] Compare the path points in the list information of robot R1 with the conflict point set respectively. If the conflict point set contains the path point, add the path point to the sequential list La of the conflict points passed by robot R1. According to the list information of robot R1, the time required to reach this path point is Tp, and the actual time Tr for robot R1 to reach this path point is Tr = Tw + Tp, where Tw is the waiting time;

[0023] The arrival time Ta of robot R1 at the conflict point is the arrival time of the first path point in the sequential list La, and the departure time Tl from the conflict point is the arrival time of the last path point in the sequential list La; the calculation method for the arrival and departure times of robot R2 at the conflict point is the same as that of robot R1;

[0024] Judge the conflict scenario according to the positions of the starting points, ending points of robot R1 and robot R2 and the conflict point set;

[0025] According to the conflict scenario, it can be judged whether robot R1 and robot R2 can walk and the order of walking;

[0026] In a scenario where both robot R1 and robot R2 can move, according to the order list La of the two robots passing through the conflict point, it can be known whether the two robots are moving in the same direction; if robot R1 moves first, when moving in the same direction, the waiting time Tw of robot R2 = Ta1 - Ta2, where Ta1 is the arrival time of robot R1 and Ta2 is the arrival time of robot R2; when moving in different directions, the waiting time Tw of robot R2 = Tl1 - Ta2, where Tl1 is the departure time of robot R1 and Ta2 is the arrival time of robot R2; if robot R2 moves first, the calculation method of the waiting time Tw of robot R1 is the same as above;

[0027] When only one of robot R1 and robot R2 can move, or neither of them can move, the waiting time Tw of the non - moving robot is infinite.

[0028] Furthermore, the execution process of the calculation algorithm for the in - place waiting time of the robot in the present invention is as follows:

[0029] Starting from the first robot, execute the waiting time calculation algorithm with each subsequent robot. After the first one finishes, the second one executes the waiting time calculation algorithm with each subsequent robot, and so on, until the second - to - last robot and the last robot finish executing, which is considered the end of one round. A total of n - 1 rounds are executed;

[0030] The number of executions for n robots in one round is

[0031] = + + +…+1= The total number of executions is .

[0032] On the other hand, the present invention also discloses a computer - readable storage medium storing a computer program, which, when executed by a processor, causes the processor to execute the steps of the above - mentioned method.

[0033] On yet another aspect, the present invention also discloses a computer device including a memory and a processor, where the memory stores a computer program, and when the computer program is executed by the processor, it causes the processor to execute the steps of the above - mentioned method.

[0034] As can be seen from the above technical solutions, the present invention, through the coordinate system and the robot The list information divides multi-robots into idle robots and robots in tasks, sorts the robots in the task set, traverses the sorting situation to obtain conflict scenarios, obtains the in-situ waiting time of the robots based on the conflict scenarios, and transmits the in-situ waiting time back to the robots in tasks to avoid path conflict problems; compared with traditional single-robot inspection, the inspection efficiency is improved, and at the same time, the problems of path overlap and resource competition faced in multi-robot inspection are avoided. The present invention only needs to add a new interface at the robot end. The robot reorganizes the existing information and sends it to the dispatcher, and then controls the movement according to the waiting time replied by the dispatcher. The present invention does not require map reconstruction and reallocation of inspection points. By dynamically calculating conflict paths and adjusting the waiting time of the robots, the collaborative work between the robots is realized, the real-time response ability of the system is enhanced, and the interference, collision and other events caused by the robots not moving according to the expected situation due to unexpected situations are avoided. BRIEF DESCRIPTION OF THE DRAWINGS

[0035] Figure 1 It is a schematic flowchart of the method for solving path conflicts in the collaborative work of multi-robots of the present invention;

[0036] Figure 2 It is a schematic diagram of the sorting situation of the robots in tasks of the present invention;

[0037] Figure 3 It is a schematic diagram of conflict scenario 1 of the present invention;

[0038] Figure 4 It is a schematic diagram of conflict scenario 2 of the present invention;

[0039] Figure 5 It is a schematic diagram of conflict scenario 3 of the present invention;

[0040] Figure 6 It is a schematic diagram of conflict scenario 4 of the present invention;

[0041] Figure 7 It is a schematic diagram of conflict scenario 5 of the present invention;

[0042] Figure 8 It is a schematic diagram of conflict scenario 6 of the present invention;

[0043] Figure 9 It is a schematic diagram of conflict scenario 7 of the present invention;

[0044] Figure 10 It is a schematic diagram of conflict scenario 8 of the present invention;

[0045] Figure 11 It is a schematic diagram of conflict scenario 9 of the present invention;

[0046] Figure 12 It is a schematic diagram of conflict scenario 10 of the present invention;

[0047] Figure 13 Schematic diagram of conflict scenario 11 of the present invention;

[0048] Figure 14 Schematic diagram of conflict scenario 12 of the present invention;

[0049] Figure 15 Schematic diagram of conflict scenario 13 of the present invention;

[0050] Figure 16 Schematic diagram of conflict scenario 14 of the present invention;

[0051] Figure 17 Schematic diagram of conflict scenario 15 of the present invention;

[0052] Figure 18 Schematic diagram of conflict scenario 16 of the present invention;

[0053] Figure 19 Coordinate schematic diagram of the test scenario of the present invention. Detailed implementation manners

[0054] To make the objectives, technical solutions and advantages of the embodiments of the present invention clearer, the technical solutions in the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings in the embodiments of the present invention. Apparently, the described embodiments are some, but not all, of the embodiments of the present invention.

[0055] As Figure 1 shown, the method and device for resolving path conflicts during collaborative work of multiple robots described in this embodiment can solve the path conflict problem caused by the common patrol of within 10 patrol robots.

[0056] To achieve the above objective, each robot acts as a TCP client, and the path scheduling program acts as a TCP server. The steps of the method for resolving path conflicts during collaborative work of multiple robots are as follows:

[0057] S100. Establish a coordinate system according to the application scenario and plan the robot path;

[0058] S200. The robot uploads the list information to the scheduling program;

[0059] S300. The scheduling program divides the robots into an idle set and a task set according to the robot list information;

[0060] S400. The scheduling program sorts the robots in the task set, traverses the sorting situation of the robots to obtain the conflict scenario and calculates the in-place waiting time;

[0061] S500. The scheduling program selects the optimal arrangement method and determines the final in-place waiting time;

[0062] S600. The scheduler returns the conflict point set and the in-place waiting time to the corresponding robot according to the robot ID.

[0063] The following is a detailed description of each step:

[0064] S100. Establish a coordinate system according to the application scenario and perform robot path planning;

[0065] After establishing the coordinate system on the robot side according to the actual application scenario:

[0066] Each robot is based on the same coordinate system and the maps are exactly the same. The map has been marked with path points, and the numbers of each path point are unique. The path points are connected by routes. The distance between path points i and j .

[0067] The initial positions of each robot cannot be repeated. After receiving the target path point, the robot uses the heuristic search algorithm and adds the time dimension. The method for measuring the quality of the path is .

[0068] In the formula, represents the movement cost of moving to the specified path, that is, the path distance between the current path point and the arrival path point is the heuristic function, representing the estimated cost. The heuristic function combines the spatial distance and the time dimension The value represents the quality degree of the path, The smaller the value, the better the path;

[0069] = ;

[0070] , represents the distance value considering the Euclidean distance, turning angle, average curvature, and moving speed, , where is the estimated Euclidean distance from the current position to the end point, θ is the total estimated turning angle of the path, is the estimated average curvature of the path, represents the moving speed of the robot; represents considering the angular velocity of the robot , linear velocity , waiting time The time value of these factors, that is = , is the angle of the change in the orientation of the robot before and after moving;

[0071] The robot starts from the starting point and first searches for adjacent points. By comparing Based on the magnitude of the value, the optimal adjacent point is determined. Then, starting from this optimal adjacent point, it expands outward, approaching the end point step by step, reducing blind searches and improving the search efficiency.

[0072] After the server calculates the waiting time of the robot and returns it to the robot, the heuristic function changes in value, thereby affecting the magnitude, and the path planning of the robot will also change accordingly, thus achieving an effect of continuous optimization.

[0073] After path planning is completed, the robot obtains the ID for each target point to be visited and the time to reach that point.

[0074] S200. The robot uploads the list information to the scheduling program;

[0075] After the robot starts, it immediately sends an information message to the scheduling program. The content of the information message is the robot ID, real-time pose, current path point ID, and target point information list.

[0076] Among them, the robot ID is a unique identifier, and the scheduling program manages internal data and the corresponding relationship of the robot according to the robot ID as an index;

[0077] The real-time pose is the x and y coordinates and the orientation angle in the coordinate system. To use this information for display on the user interface, it is a field for system function expansion.

[0078] The target point information includes the target point ID and the time taken to reach that point. It is the core information relied on by the path conflict resolution algorithm. The scheduling program abstracts the information of the map and does not rely on real map information.

[0079] The structural data of the information message is as follows:

[0080] Robot ID: 1 (required)

[0081] Real-time pose x: 10.265 (optional)

[0082] Real-time pose y: 5.885 (optional)

[0083] Real-time pose orientation: 0 (0 - 360°, optional)

[0084] Current path point ID: 6 (required)

[0085] Target information list:

[0086] {

[0087] Target path point ID: 7 (required)

[0088] Time required to reach: 10 (required)

[0089] Destination waypoint ID: 8 (required)

[0090] Time required to arrive: 4 (required)

[0091] Destination waypoint ID: 9 (required)

[0092] Time required to arrive: 13 (required)

[0093] …

[0094] }

[0095] S300. The scheduler divides the robots into an idle set and a task set according to the list information;

[0096] The scheduler is deployed as a TCP server on the central server. The server and each robot are in the same local area network, and the network between each robot and the server is unobstructed.

[0097] After receiving the information message of the robot, the scheduler divides the robots into in-task robots and idle robots according to the list information and puts them into different sets respectively. In-task robots include two cases where the robot needs to move and stay still but is on the walking route of other robots, and path conflict resolution is required; idle robots include a case where the robot stays still and does not conflict with the paths of other robots, and no processing is required.

[0098] S400. The scheduler sorts the robots in the task set, traverses the sorting situation of the robots to obtain the conflict scenarios and calculates the in-place waiting time;

[0099] Sort the robots in the task set. Assuming the number of robots in the task set is n, then n! different permutation orders can be obtained, and each permutation order is traversed.

[0100] As Figure 2 shown, in each permutation order, starting from the first robot, calculate the waiting time with each subsequent robot. After the first one finishes, the second one calculates the waiting time with each subsequent robot. And so on, until the second-to-last robot and the last robot finish, which is considered the end of one round, and a total of n - 1 rounds are executed.

[0101] The number of executions in one round for n robots is

[0102] = + + +…+1 = , and the total number of executions is 。

[0103] After the calculation of the waiting time is completed, calculate the longest time taken for all robots in this permutation to reach the destination as the time taken for this permutation, and select the permutation method with the shortest time among all permutations as the best scheduling method.

[0104] Among them, the algorithm for calculating the waiting time of the robot is as follows:

[0105] Let the first robot be R1 and the second robot be R2. Initialize the arrival time Ta and departure time Tl of robots R2 and R2 at the conflict point to 0.

[0106] Take the intersection of the path point sets of robots R1 and R2 to obtain the set of conflicting path points of R1 and R2, and put the set of conflicting path points into their respective conflict point sets.

[0107] Compare the path points in the path information list of robot R1 with the conflict point set respectively. If the conflict point set contains this path point, add this path point to the list La of the order of passing through the conflict point of robot R1. According to the path information list of robot R1, the time required to reach this path point is Tp, and the actual time Tr for robot R1 to reach this conflict point is Tr = Tw + Tp, where Tw is the waiting time.

[0108] If Ta is 0, then Ta = Tr; if Tr is less than Ta, then Ta = Tr; if Tr is greater than Tl, then Tl = Tr. Thus, the actual time for robot R1 to reach and leave the conflict point can be obtained. The calculation method of the actual time for robot R2 to reach and leave the conflict point is the same as that of robot R1.

[0109] The positional relationship between the starting point, ending point of each robot and the conflict set can be divided into 4 cases, including:

[0110] 1. Neither the starting point nor the ending point is in the conflict set;

[0111] 2. The starting point is not in the conflict set and the ending point is;

[0112] 3. The starting point is in the conflict set and the ending point is not;

[0113] 4. Both the starting point and the ending point are in the conflict set.

[0114] The conflict situation of n robots is 4 to the power of n. Arbitrarily select two of the robots as robots R1 and R2, and there are 16 conflict scenarios for R1 and R2.

[0115] According to whether their starting points and ending points of robots R1 and R2 are in the conflict point set, 16 scenarios are divided, and the specific scenarios are:

[0116] As Figure 3 shown, Scenario 1: The starting and ending points of robots R1 and R2 are not in the conflict point set

[0117] In this case, robot R1 goes first, and the variable tempTw for calculating the waiting time is initialized to 0. By comparing the order list La of robots R1 and R2 passing through the conflict points, it can be obtained whether the two robots are moving in the same direction. If the two robots are moving in the same direction and the number of conflict points is greater than 1, tempTw = the arrival conflict point time Ta of robot R1 - the arrival conflict point time Ta of robot R2; otherwise, tempTw = the leaving conflict point time Tl of robot R1 - the arrival conflict point time Ta of robot R2. If tempTw is greater than 0, then the in-place waiting time Tw of robot R2 plus the value of tempTw is the new in-place waiting time.

[0118] As Figure 4 shown, Scenario 2: The starting and ending points of robot R1 are not in the conflict set, and the starting point of robot R2 is not in the ending point

[0119] In this case, robot R1 goes first, and the variable tempTw for calculating the waiting time is initialized to 0. By comparing the order list La of robots R1 and R2 passing through the conflict points, it can be obtained whether the two robots are moving in the same direction. If the two robots are moving in the same direction and the number of conflict points is greater than 1, tempTw = the arrival conflict point time Ta of robot R1 - the arrival conflict point time Ta of robot R2; otherwise, tempTw = the leaving conflict point time Tl of robot R1 - the arrival conflict point time Ta of robot R2. If tempTw is greater than 0, then the in-place waiting time Tw of robot R2 plus the value of tempTw is the new in-place waiting time.

[0120] As Figure 5 shown, Scenario 3: The starting and ending points of robot R1 are not in the conflict set, and the starting point of robot R2 is in the ending point not

[0121] In this case, robot R2 goes first, and the variable tempTw for calculating the waiting time is initialized to 0. By comparing the order list La of robots R1 and R2 passing through the conflict points, it can be obtained whether the two robots are moving in the same direction. If the two robots are moving in the same direction and the number of conflict points is greater than 1, tempTw = the arrival conflict point time Ta of robot R2 - the arrival conflict point time Ta of robot R1; otherwise, tempTw = the leaving conflict point time Tl of robot R2 - the arrival conflict point time Ta of robot R1. If tempTw is greater than 0, then the in-place waiting time Tw of robot R1 plus the value of tempTw is the new in-place waiting time.

[0122] As Figure 6 shown, Scenario 4: The starting and ending points of robot R1 are not in the conflict set, and both the starting and ending points of robot R2 are

[0123] In this case, robot R1 cannot move, and the waiting time Tw of robot R1 is directly set to the maximum value.

[0124] As Figure 7 shown, Scenario 5: The starting point of robot R1 is not in the conflict set, and the ending point is, and neither the starting nor the ending point of robot R2 is

[0125] In this case, robot R2 moves first, and the variable tempTw for calculating the waiting time is initialized to 0. By comparing the order list La of the conflict points passed by robots R1 and R2, it can be obtained whether the two robots move in the same direction. If the two robots move in the same direction and the number of conflict points is greater than 1, tempTw = the arrival conflict point time Ta of robot R2 - the arrival conflict point time Ta of robot R1; otherwise, tempTw = the leaving conflict point time Tl of robot R2 - the arrival conflict point time Ta of robot R1. If tempTw is greater than 0, then the value of tempTw is added to the in-place waiting time Tw of robot R1 to obtain the new in-place waiting time.

[0126] As Figure 8 shown, Scenario 6: The starting point of robot R1 is not in the conflict set, and the ending point is, and the starting point of robot R2 is not and the ending point is

[0127] In this case, neither robot R1 nor robot R2 can move, and the waiting times Tw of robot R1 and robot R2 are set to the maximum value.

[0128] As Figure 9 shown, Scenario 7: The starting point of robot R1 is not in the conflict set, and the ending point is, and the starting point of robot R2 is and the ending point is not

[0129] In this case, robot R2 moves first, and the variable tempTw for calculating the waiting time is initialized to 0. By comparing the order list La of the conflict points passed by robots R1 and R2, it can be obtained whether the two robots move in the same direction. If the two robots move in the same direction and the number of conflict points is greater than 1, tempTw = the arrival conflict point time Ta of robot R2 - the arrival conflict point time Ta of robot R1; otherwise, tempTw = the leaving conflict point time Tl of robot R2 - the arrival conflict point time Ta of robot R1. If tempTw is greater than 0, then the value of tempTw is added to the in-place waiting time Tw of robot R1 to obtain the new in-place waiting time.

[0130] As Figure 10As shown in the figure, scenario 8: The starting point of robot R1 is not in the conflict set, and the end point is. The starting and end points of robot R2 are both in the conflict set.

[0131] In this case, robot R1 cannot move, and the waiting time Tw of robot R1 is directly set to the maximum value.

[0132] As Figure 11 shown in the figure, scenario 9: The starting point of robot R1 is in the conflict set, and the end point is not. The starting and end points of robot R2 are both not in the conflict set.

[0133] In this case, robot R1 moves first, and the variable tempTw for calculating the waiting time is initialized to 0. By comparing the order list La of robot R1 and R2 passing through the conflict point, it can be obtained whether the two robots move in the same direction. If the two robots move in the same direction and the number of conflict points is greater than 1, tempTw = the arrival time Ta of robot R1 at the conflict point - the arrival time Ta of robot R2 at the conflict point; otherwise, tempTw = the leaving time Tl of robot R1 at the conflict point - the arrival time Ta of robot R2 at the conflict point. If tempTw is greater than 0, then the original waiting time Tw of robot R2 plus the value of tempTw is the new original waiting time.

[0134] As Figure 12 shown in the figure, scenario 10: The starting point of robot R1 is in the conflict set, and the end point is not. The starting point of robot R2 is not in the conflict set, and the end point is in the conflict set.

[0135] In this case, robot R1 moves first, and the variable tempTw for calculating the waiting time is initialized to 0. By comparing the order list La of robot R1 and R2 passing through the conflict point, it can be obtained whether the two robots move in the same direction. If the two robots move in the same direction and the number of conflict points is greater than 1, tempTw = the arrival time Ta of robot R1 at the conflict point - the arrival time Ta of robot R2 at the conflict point; otherwise, tempTw = the leaving time Tl of robot R1 at the conflict point - the arrival time Ta of robot R2 at the conflict point. If tempTw is greater than 0, then the original waiting time Tw of robot R2 plus the value of tempTw is the new original waiting time.

[0136] As Figure 13 shown in the figure, scenario 11: The starting point of robot R1 is in the conflict set, and the end point is not. The starting point of robot R2 is in the conflict set, and the end point is not.

[0137] In this case, neither robot R1 nor robot R2 can move, and the waiting time Tw of robot R1 and robot R2 is set to the maximum value.

[0138] As Figure 14 shown in the figure, scenario 12: The starting point of robot R1 is in the conflict set, and the end point is not. The starting and end points of robot R2 are both in the conflict set.

[0139] In this case, neither robot R1 nor robot R2 can move, and the waiting time Tw of robots R1 and R2 is set to the maximum value.

[0140] As Figure 15 shown, scenario 13: The starting and ending points of robot R1 are in the conflict set, and the starting and ending points of robot R2 are not

[0141] In this case, robot R2 cannot move, and the waiting time Tw of robot R2 is directly set to the maximum value.

[0142] As Figure 16 shown, scenario 14: The starting and ending points of robot R1 are in the conflict set, the starting point of robot R2 is not, and the ending point is in

[0143] In this case, robot R2 cannot move, and the waiting time Tw of robot R2 is directly set to the maximum value.

[0144] As Figure 17 shown, scenario 15: The starting and ending points of robot R1 are in the conflict set, the starting point of robot R2 is in, and the ending point is not

[0145] In this case, neither robot R1 nor robot R2 can move, and the waiting time Tw of robots R1 and R2 is set to the maximum value.

[0146] As Figure 18 shown, scenario 16: The starting and ending points of both robots R1 and R2 are in the conflict set

[0147] In this case, neither robot R1 nor robot R2 can move, and the waiting time Tw of robots R1 and B is set to the maximum value.

[0148] So far, the time waiting calculation algorithm has been executed.

[0149] S500. The scheduler selects the optimal arrangement method and determines the final in-place waiting time;

[0150] The method for calculating the longest time for all robots in this arrangement to reach the destination is that the waiting time of the robot plus the arrival time of the last path point in the path list of this robot is used as the longest time Tf for the arrangement. Starting from the first robot in the queue, traverse each robot in the queue to obtain the longest time tempTf and compare it with Tf, and take the larger value as the new Tf.

[0151] Traverse and compare the Tf values in each arrangement method, select the arrangement method corresponding to the minimum Tf value as the optimal arrangement method, and use the in-place waiting time of the robots in this arrangement method as the final in-place waiting time for each robot.

[0152] The S600 scheduler returns the conflict point set and the in-place waiting time to the corresponding robot according to the robot ID;

[0153] Return the conflict point set and the in-place waiting time to the corresponding robot according to the robot ID.

[0154] After receiving the waiting time, the robot executes the waiting command and starts moving after the waiting ends. If a new waiting time is received within the waiting time, the waiting time is reset.

[0155] As Figure 19 shown, it is a coordinate map for testing. The coordinates and route lengths of each path point are marked, and the walking speed of the robot is 0.5 m / s. The following details the path conflict resolution method during multi-robot collaborative work through embodiments:

[0156] Embodiment 1

[0157] Robot 1 travels from path point 1 to path point 15

[0158] Robot 2 travels from path point 2 to path point 11

[0159] Robot 3 travels from path point 3 to path point 12

[0160] Before the scheduler receives the robot information and executes the algorithm, the robot information statistics are as follows in the table:

[0161]

[0162] After arrangement 1 executes the time waiting calculation algorithm, it takes 24 seconds for all robots to arrive. The robot information statistics are as follows in the table:

[0163]

[0164] After arrangement 2 executes the time waiting calculation algorithm, it takes 34 seconds for all robots to arrive. The robot information statistics are as follows in the table:

[0165]

[0166] After arrangement 3 executes the time waiting calculation algorithm, it takes 28 seconds for all robots to arrive. The robot information statistics are as follows in the table:

[0167]

[0168] After arrangement 4 executes the time waiting calculation algorithm, it takes 28 seconds for all robots to arrive. The robot information statistics are as follows in the table:

[0169]

[0170] After the permutation 5 finishes executing the time waiting calculation algorithm, it takes 26 seconds for all the robots to reach their positions. The robot information is summarized in the following table:

[0171]

[0172] After the permutation 6 finishes executing the time waiting calculation algorithm, it takes 34 seconds for all the robots to reach their positions. The robot information is summarized in the following table:

[0173]

[0174] Permutation 1 takes the shortest time. Therefore, permutation 1 is adopted. The waiting time for robot 1 is 0, the waiting time for robot 2 is 4, and the waiting time for robot 3 is 10.

[0175] Example 2

[0176] Robot 1 travels from path point 1 to path point 8

[0177] Robot 2 travels from path point 2 to path point 14

[0178] Robot 3 travels from path point 3 to path point 9

[0179] Before the scheduling program receives the robot information and executes the algorithm, the robot information is summarized in the following table:

[0180]

[0181] After the permutation 1 finishes executing the time waiting calculation algorithm, it takes 24 seconds for all the robots to reach their positions. The robot information is summarized in the following table:

[0182]

[0183] After the permutation 2 finishes executing the time waiting calculation algorithm, it takes 18 seconds for all the robots to reach their positions. The robot information is summarized in the following table:

[0184]

[0185] After the permutation 3 finishes executing the time waiting calculation algorithm, it takes 24 seconds for all the robots to reach their positions. The robot information is summarized in the following table:

[0186]

[0187] After the permutation 4 finishes executing the time waiting calculation algorithm, it takes 24 seconds for all the robots to reach their positions. The robot information is summarized in the following table:

[0188]

[0189] After the permutation 5 finishes executing the time waiting calculation algorithm, it takes 18 seconds for all the robots to reach their positions. The robot information is summarized in the following table:

[0190]

[0191] After permutation 6 finishes executing the time waiting calculation algorithm, it takes 18 seconds for all the robots to be in place. The robot information is statistically shown in the following table:

[0192]

[0193] Permutations 2, 5, and 6 take the shortest time. The permutation 2 with the earliest order is adopted. The waiting time for robot 1 to reply is 10, the waiting time for robot 2 to reply is 6, and the waiting time for robot 3 to reply is 0.

[0194] Furthermore, the present invention can also be applied to the problem of path conflicts when several robots perform inspection tasks.

[0195] In summary, the present invention divides multiple robots into idle robots and robots in tasks through a coordinate system and the working states of the robots, sorts the robots in the task set, traverses the sorting situations to obtain conflict scenarios, obtains the in-situ waiting time of the robots based on the conflict scenarios, and transmits the in-situ waiting time back to the robots in tasks to avoid path conflict problems; compared with traditional single-robot inspection, it improves the inspection efficiency and simultaneously avoids the problems of path overlap and resource competition in multi-robot inspection. The present invention only needs to add a new interface at the robot end. The robot reorganizes the existing information and sends it to the scheduling program, and then controls the movement according to the waiting time replied by the scheduling program. The present invention does not require map reconstruction and reallocation of inspection points. By dynamically calculating conflict paths and adjusting the waiting time of the robots, it realizes the collaborative work among the robots, enhances the real-time response ability of the system, and avoids events such as interference and collision caused by the robots not moving as expected due to unexpected situations.

[0196] On the other hand, the present invention also discloses a computer-readable storage medium storing a computer program, which when executed by a processor causes the processor to execute the steps of the above method.

[0197] On yet another aspect, the present invention also discloses a computer device including a memory and a processor, where the memory stores a computer program, and when the computer program is executed by the processor, it causes the processor to execute the steps of the above method.

[0198] In yet another embodiment provided by the present application, there is also provided a computer program product containing instructions, which when running on a computer causes the computer to execute the method for solving path conflicts in any of the above embodiments when multiple robots collaborate.

[0199] It is understandable that the systems, devices, and storage media provided in the embodiments of the present invention correspond to the methods provided in the embodiments of the present invention. For the explanations, examples, and beneficial effects of the relevant content, reference may be made to the corresponding parts in the above methods.

[0200] In the above embodiments, it can be implemented in whole or in part by software, hardware, firmware, or any combination thereof. When implemented using software, it can be implemented in whole or in part in the form of a computer program product. The computer program product includes one or more computer instructions. When the computer program instructions are loaded and executed on a computer, the processes or functions described in the embodiments of the present application are generated in whole or in part. The computer can be a general-purpose computer, a special-purpose computer, a computer network, or other programmable devices. The computer instructions can be stored in a computer-readable storage medium or transmitted from one computer-readable storage medium to another. For example, the computer instructions can be transmitted from one website, computer, server, or data center to another website, computer, server, or data center by wire (such as coaxial cable, optical fiber, digital subscriber line (DSL)) or wireless (such as infrared, wireless, microwave, etc.). The computer-readable storage medium can be any available medium that can be accessed by a computer or a data storage device such as a server or data center that includes one or more integrated available media. The available medium can be a magnetic medium (such as a floppy disk, hard disk, magnetic tape), an optical medium (such as a DVD), or a semiconductor medium (such as a solid-state disk (SSD)).

[0201] It should be noted that in this document, relational terms such as "first" and "second" are only used to distinguish one entity or operation from another entity or operation, and do not necessarily require or imply any actual relationship or order between these entities or operations. Moreover, the term "comprising", "including", or any other variant thereof is intended to cover non-exclusive inclusion, such that a process, method, article, or device that includes a series of elements includes not only those elements but also other elements that are not explicitly listed, or also includes elements that are inherent to such process, method, article, or device. Without further limitation, an element defined by the statement "including one..." does not exclude the existence of additional identical elements in the process, method, article, or device that includes the element.

[0202] Each embodiment in this specification is described in a related manner. For the same or similar parts among the embodiments, reference can be made to each other. Each embodiment focuses on the differences from other embodiments. In particular, for the system embodiment, since it is basically similar to the method embodiment, the description is relatively simple. For the related parts, reference can be made to the partial description of the method embodiment.

[0203] The above embodiments are only used to illustrate the technical solutions of the present invention, not to limit them. Although the present invention has been described in detail with reference to the foregoing embodiments, those of ordinary skill in the art should understand that they can still modify the technical solutions recorded in the foregoing embodiments, or perform equivalent replacements on some of the technical features; and these modifications or replacements do not make the essence of the corresponding technical solutions deviate from the spirit and scope of the technical solutions of the embodiments of the present invention.

Claims

1. A method for solving path conflicts when multiple robots work together, characterized in that: include: The actual scene coordinates are represented by s, and the time taken by the robot to reach the specified position is represented by t; the robot combines space and time information to generate List information and upload it to the server, the server will The server arranges and combines the robots in the task, and in each arrangement, multiple robots in the task are arranged in the same way. The repeated path points in the list are taken as conflict points and put into the conflict point set. The conflict scenario is obtained based on whether the starting points and end points of multiple robots are in the conflict point set. Then, the robot's waiting time in the task is calculated based on the conflict scenario. The robot's waiting time in the task plus the time to reach the last target path point is the robot's arrival time. Finally, the arrival time of all robots is traversed, and the longest time is selected as the solution time. Traverse all the arrangements and select the one with the shortest solution time as the optimal solution to the path conflict; The set of robot conflict points in the optimal solution and the waiting time in place are sent back to the robot to solve the path conflict problem.

2. The method for solving path conflicts when multiple robots work together according to claim 1, characterized in that: according to The path planning method based on list information includes: The path quality measurement method is In the formula, Indicates the cost of moving to the specified path, that is, the path distance between the current path point and the destination path point is the heuristic function, which represents the estimated cost. The heuristic function combines the spatial distance and time dimensions; The value indicates the quality of the path. The smaller the value, the better the path; The specific expression of the heuristic function H is: = ； , represents the distance value taking into account the Euclidean distance, turning angle, average curvature, and moving speed. ,in is the estimated Euclidean distance from the current position to the end point, θ is the total estimated turning angle of the path, is the estimated mean curvature of the path, Indicates the robot's moving speed; Indicates that the angular velocity of the robot is taken into account , Line speed , waiting time The time values ​​of these factors, namely = , is the angle of change of the robot's orientation before and after movement; The robot starts from the starting point and first looks for adjacent points. The optimal adjacent point is determined based on the value; based on the optimal adjacent point, it expands outward and approaches the end point through a loop, and finally obtains the optimal path to the end point.

3. The method for solving path conflicts when multiple robots work together according to claim 1, characterized in that: The robot will The list information is uploaded to the server, and the server detects whether there are conflicting points by checking whether the path points are repeated.

4. The method for solving path conflicts when multiple robots work together according to claim 1, characterized in that: The server divides the robot into two states: idle and tasked. The robot that is not in the walking route of other robots and stays in place is an idle robot; The robot whose position changes or does not change but is within the walking route of other robots is an on-task robot.

5. The method for solving path conflicts when multiple robots work together according to claim 1, characterized in that: The method for obtaining the conflict scene according to whether the starting points and end points of multiple robots are in the conflict point set is: Select two robots from the n robots and set them as robot R1 and robot R2, narrow the conflict scene to the two robots, and solve the conflict between robot R1 and robot R2 by traversal, so as to solve the path conflict between the n robots.

6. The method for solving path conflicts when multiple robots work together according to claim 1, characterized in that: The calculation algorithm of the robot's waiting time in place is: Select two robots from n robots and set them as robot R1 and robot R2. The list information is intersected to obtain the set of conflicting path points of robot R1 and robot R2; Put the robot R1 The path points in the list information are compared with the conflict point set. If the path point is included in the conflict point set, the path point is added to the sequential list La of the robot R1 passing through the conflict points. From the list information, we know that the time required to reach the path point is Tp, and the actual time Tr=Tw+Tp of robot R1 to reach the path point, where Tw is the waiting time; The time Ta when robot R1 arrives at the conflict point is the arrival time of the first path point in the sequence list La, and the time Tl when robot R1 leaves the conflict point is the arrival time of the last path point in the sequence list La; the calculation method of the time when robot R2 arrives at the conflict point and leaves the conflict point is the same as that of robot R1; Determine the conflict scenario based on the positions of the starting point, end point and conflict point set of the robot R1 and the robot R2; According to the conflict scenario, it can be determined whether robots R1 and R2 can walk and the order in which they can walk; In the scenario where both robots R1 and R2 can walk, according to the order list La of robot R1 and robot R2 passing through the conflict points, it can be known whether the two robots are walking in the same direction; if robot R1 goes first, the waiting time of robot R2 when walking in the same direction is Tw=Ta1-Ta2, Ta1 is the arrival time of robot R1, and Ta2 is the arrival time of robot R2; when walking in different directions, the waiting time of robot R2 is Tw=Tl1-Ta2, Tl1 is the departure time of robot R1, and Ta2 is the arrival time of robot R2; if robot R2 goes first, the calculation method of robot R1's waiting time Tw is the same as above; When only one of the robot R1 and the robot R2 can walk, or both of them cannot walk, the waiting time Tw of the robot that cannot walk is infinite.

7. The method for solving path conflicts when multiple robots work together according to claim 6, characterized in that: The execution process of the robot's in-situ waiting time calculation algorithm is as follows: Starting from the first robot, it executes the waiting time calculation algorithm with each subsequent robot. After the first robot finishes executing, the second robot and each subsequent robot execute the waiting time calculation algorithm, and so on, until the second to last robot and the last robot finish executing, and a round is considered complete, and a total of n-1 rounds are executed; The number of executions per round by n robots is = + + +…+1= The total number of executions is .

Images