We focus on the assignment of discrete points among K
robots and determining the order in which the points should be
processed by the robots, in the presence of geometric and kinematic
constraints between the robots. This is a path planning problem that arises
as a subproblem in the decoupled approach to solving the motion planning problem
of covering a point set by a multiple robot system in minimum time.
More concretely, our work is motivated by an industrial microelectronics
manufacturing system with two robots, with square footprints, that are
constrained to translate along a line while satisfying proximity and
collision avoidance constraints (see the figure on right). The N points lie on a planar base
plate that can translate along the plane normal to the direction of
motion of the robots. The geometric constraints on the motions of the
two robots lead to constraints on points that can be processed
simultaneously. We use a two step approach to solve the path planning problem: (1) Splitting Problem: Assign the points to the K robots subject to geometric constraints, such that the total processing time is minimized. (2) Ordering Problem: Find an order of processing the split points by formulating and solving a multi-dimensional Traveling Salesman Problem (TSP) in the K-tuple space with an appropriately defined metric to minimize the total travel cost. We show that for K = 2, the splitting problem can be converted to a maximum cardinality matching problem on a graph and solved optimally in polynomial time. The matching algorithm takes O(N^3) time in general and is too slow for large datasets. Therefore, we also provide a greedy algorithm for the splitting problem that takes O(N log(N)) time. We provide computational results comparing the two approaches and show that the greedy algorithm is very close to the optimal solution for typical industrial datasets. We also provide computational results for the ordering problem and propose local search based heuristics to improve the TSP tour. Further, we give computational results showing the overall performance gain obtained (over a single robot system) by using our algorithm. Finally, we extend our approach to a K-robot system and give computational results for K = 4.
In this paper, we present provably-good distributed task allocation (assignment) algorithms for a heterogeneous multi-robot system where the tasks form disjoint groups and there are constraints on the number of tasks a robot can do (both within the overall mission and within each task group). Our problem is motivated by applications where multiple robots with heterogeneous capabilities have to work together to accomplish tasks. Thus, for our purposes, a task group is a {\em compound task} composed of more than one atomic tasks where one robot is required for each atomic task. Since robots have limited battery life, we assume that the number of (atomic) tasks that a robot can do within a mission has an upper bound. Futhermore, each robot has a constraint on the number of tasks it can do from each group (this models the fact that multiple robots may be needed to simultaneously perform the atomic tasks that make up the compound task). Each robot obtains a payoff (or incurs a cost) for each task and the overall objective for task allocation is to maximize the total payoff (or minimize the total cost) of all the robots. In general, existing (centralized or distributed) algorithms for task allocation either assume that (atomic) tasks are independent, or do not provide performance guarantee for the situation where task constraints exist. We show that our problem can be solved in polynomial time by a centralized algorithm by reducing it to a minimum cost network flow problem. We then present a decentralized algorithm (that extends the auction algorithm of Bertsekas for linear assignment problems~\cite{Bertsekas88}) to provide an almost optimal solution. We prove that our solution is within a factor of $O(n_t\epsilon)$ of the optimal solution, where $n_t$ is the total number of tasks and $\epsilon$ is a parameter that we choose (the guarantees are the same as that of the original auction algorithm for unconstrained tasks). The decentralized algorithm assumes a shared memory model of computation that may be unrealistic for many multi-robot deployments. Therefore, we show that by using a maximum consensus algorithm along with our algorithm, we can design a totally distributed algorithm for task allocation with group constraints. The key aspect of our distributed algorithm is that the overall objective is (nearly) maximized by {\em each robot maximizing its own objective iteratively (using a modified payoff function based on an auxiliary variable, called price of a task)}. Our algorithm is polynomial in the number of tasks as well as the number of robots.