Asynchronous Network Formation in Unknown Unbounded Environments

TL;DR

This paper introduces an online algorithm for multi-robot information dissemination in unknown, large environments, with proven competitive ratios and validation through simulations and real-world experiments.

Contribution

It presents a novel online network formation algorithm with competitive analysis for unknown environments, improving efficiency in random initial configurations.

Findings

Competitive ratio of $O(H imes ext{max}igrace M, ext{sqrt}(M H)igrace)$ for arbitrary deployments.

Improved ratio of $O(M)$ when initial positions are random.

Validation through simulations and a three-robot field experiment.

Abstract

In this paper, we study the Online Network Formation Problem (ONFP) for a mobile multi-robot system. Consider a group of robots with a bounded communication range operating in a large open area. One of the robots has a piece of information which has to be propagated to all other robots. What strategy should the robots pursue to disseminate the information to the rest of the robots as quickly as possible? The initial locations of the robots are unknown to each other, therefore the problem must be solved in an online fashion. For this problem, we present an algorithm whose competitive ratio is $O(H \cdot \max\{M,\sqrt{M H}\})$ for arbitrary robot deployments, where $M$ is the largest edge length in the Euclidean minimum spanning tree on the initial robot configuration and $H$ is the height of the tree. We also study the case when the robot initial positions are chosen uniformly at random and improve the ratio to $O(M)$. Finally, we present simulation results to validate the performance in larger scales and demonstrate our algorithm using three robots in a field experiment.

Equations

$$R_i=\{\begin{array}{ll}{R}_{i-1}+1,& \text{k=0 or k=1}\\ R_{i-1}+k,& k\ge 2\end{array}$$

$$\begin{array}{rl}SOL& \le 4\pi M^2+\sum _{t=1}^{2H}2\pi \frac{(R_t^2-R_{t-1}^2)}{k_t}\\ & <4\pi M^2+\sum _{t=1}^{2H}2\pi \frac{8M^{2}t}{t}=M^2(32\pi H+4\pi ),\end{array}$$

$$\begin{array}{rl}\mathbb{E}[SOL]& \le \sum _{i=1}^{2L/M}\frac{2\pi M^2(2i-1)}{n\frac{i^2{M}^2}{4L^2}}\le \sum _{i=1}^{2L/M}16\pi \frac{L^2}{ni}\\ & \approx 16\pi L^2\frac{\log (2L/M)}{n}\le 16\pi L^2\frac{\log n}{n},\end{array}$$

Full text

For this problem, we present an algorithm whose competitive ratio is $O(H\cdot\max\{M,\sqrt{MH}\})$ for arbitrary robot deployments, where $M$ is the largest edge length in the Euclidean minimum spanning tree on the initial robot configuration and $H$ is the height of the tree. We also study the case when the robot initial positions are chosen uniformly at random and improve the ratio to $O(M)$. Finally, we present simulation results to validate the performance in larger scales and demonstrate our algorithm using three robots in a field experiment.

I Introduction

Consider a group of robots with unknown locations scattered over a large area. The robots can not communicate with each other unless they are within a given communication range. Such scenarios may occur, for example, after aerial deployments in disaster response situations. It might also be the case that many robots operate independently in a search task without coordination and disperse across the environment.

Now imagine that one of the robots wants to convey a piece of information to all other robots. This information can be used for network formation, rendezvous or any other task. For this purpose, the robot starts searching for other robots. Once a robot is found, it can be recruited to propagate the information. What strategy should the robot team follow to convey this information as soon as possible? In this paper, we study this online network formation in unbounded environments.

Our problem is closely related to the Freeze-Tag Problem (FTP), in which there is initially a single active (leader) robot and the rest of the robots are frozen/asleep, staying put [2]. The goal is to wake up all the asleep robots in the shortest time. An asleep robot awakens when an active robot is in its close proximity. After a robot awakens, it becomes activated and participates in the process of rousing the robots.

The network formation problem can be regarded as the online version of the original FTP, where the robot positions are unknown to each other. Without the knowledge of the locations of their peers, the active robots need to perform a search strategy to discover them as illustrated in Figure 1. Since the robots do not necessarily start executing the algorithm at the same time, our problem is asynchronous. This property of the problem is beneficial especially in real-world systems where exact synchrony is hard to achieve.

Algorithm design for mobile network formation has received significant attention over the past years. These approaches can be categorized as centralized and decentralized solutions [19]. In a centralized approach, a base station or a leader robot has access to positions of all the robots and can directly command them [20, 18, 6]. On the other hand, with decentralized algorithms the robots can perform tasks using local information, without explicit instructions from an external source [4, 9].

While centralized approaches are usually efficient and easy to implement, adopting these solutions may not be possible in settings where the communication range of the robots is short. Consequently, there is an increasing interest in distributed communication protocols. Gossip protocols, for instance, are designed to disseminate information in a connected network of nodes [3]. In the single-piece dissemination scenario of a gossip protocol, an arbitrarily chosen node has a piece of information and the objective is to spread this information to all other nodes in the shortest time [17]. In this one-to-all broadcast setting, the network is stationary and a node propagates the information to its neighbors with an associated probability. Contrary to this formulation, in the FTP the nodes are able to move and transfer the piece of information to a neighbor as soon as they are within each other’s connectivity range.

In the rendezvous problem, a group of robots need to meet at a point as quickly as possible. The two-player case with initial positions unknown to each other was studied in [1]. Roy and Dudek proposed strategies to achieve rendezvous together with the exploration of an unknown environment [16]. Ozsoyeller et al. studied the rendezvous search problem on the line [13] and in planar environments [14]. Robots in this formulation do not know the positions of each other and they have to execute the same algorithm. Due to this constraint, the strategy is inherently stochastic since otherwise the robots cannot meet by following the same motion. An asymmetric version of this problem where a robot needs to rendezvous with non-adversarial targets is analyzed in [10].

Poduri and Sukhatme studied the problem of establishing a connected network in a bounded toroidal domain using a decentralized approach [15]. In their model the robots perform random walk, and stop moving when they are near the base station or a robot who is already connected.

The FTP was originally posed in the graph settings where the robots are placed on the vertices of a graph [2]. The robots can move only along the edges and an asleep robot awakens when its vertex is visited by an active robot. In this formulation, each robot knows the positions of all other robots. The online version of the problem was studied by [8] who proposed a lower bound on the competitive ratio for graph settings.

The online FTP in the Euclidean domain was further explored in [11]. The authors considered the case where the robots are distributed uniformly at random over a rectangular shaped bounded area. In this case, the robots cannot go outside the closed area. For this problem the authors proposed a logarithmic factor approximation algorithm which depends on the area, therefore is not directly applicable.

The results in [11] rely on a bounded environment assumption. Considering the typical operation environments of field robots, including open seas and skies, this constraint may need to be relaxed. In this paper, we generalize the environment by removing the closed boundary assumption. In summary, our contributions can be stated as follows.

Our contribution: We study a scenario where the robots are deployed in an unbounded environment and the robot positions are unknown to each other. We analyze two cases of the problem: the initial robot positions are chosen arbitrarily and uniformly at random. For arbitrary deployments we present a strategy which is $O(H{}\cdot\max\{M,\sqrt{MH{}}\})$-competitive. This result improves the competitive ratio of a naive algorithm by a factor of $H{}$ or $\sqrt{MH{}}$. The algorithm performs better in random deployments and the ratio becomes $O(M)$. In addition to providing performance guarantees, we demonstrate our algorithm in field experiments as a proof-of-concept implementation.

The remainder of the paper is organized as follows. We formulate our problem and introduce the models used throughout the paper in Section II. In Section III we present our algorithm and analyze its performance in Section IV. Section V contains simulations we conducted. We describe the outdoor experiments demonstrating the algorithm in Section VI. Finally, we conclude with a summary and future research directions in Section VII.

II Problem Formulation and Models

In the Online Network Formation Problem (ONFP), at the beginning there is a single active robot and the goal is to find a strategy to explore all inactive robots such that the time it takes to tag the last robot is minimized.

In this problem, the robot initial positions are unknown to each other, thus the robots use an online strategy. The performance of online algorithms are usually evaluated in comparison to the optimal offline solution [12]. The optimal offline strategy has access to the initial positions of all robots beforehand, so the leader robot does not need to perform a search but instead can directly move towards the inactive robots. For an instance $\sigma$ of the problem, suppose $A(\sigma)$ is the solution produced by our online algorithm, and $OPT(\sigma)$ is the optimal offline solution. The algorithm $A$ is said to be $c$-competitive if for all instances of the problem the ratio $A(\sigma)/OPT(\sigma)\leq c$ holds.

II-A Environment and Robot Models

In the ONFP, we have $n$ robots scattered over an unbounded area. Initially, one active robot carries a piece of information to propagate to all other robots. An asleep robot receives this information (or awakens), once an active robot is within its close proximity. The robots are assumed to be point robots that always move at constant speed.

The initial positions of the robots are $\mathcal{X}=\{x_{1},\dots,x_{n}\}$, where each $x_{i}\in\mathbb{R}^{2}$. Without loss of generality we assume $x_{1}$ is the leader’s initial position and $x_{2}$ to $x_{n}$ are labeled in non-decreasing order with respect to their distances to $x_{1}$. The Euclidean distance between two robots $x_{i}$ and $x_{j}$ is denoted by $d(x_{i},x_{j})$. In our analysis, we use the Minimum Spanning Tree (MST) on the initial robot positions and denote it by $\mathcal{T}$. We denote the longest edge length in $\mathcal{T}$ as $M$, and its height as 0pt.

Finally, the communication range is denoted by $r{}$. We measure the distances in units of $r{}$, and a robot displaces by $r{}$ per time step. In the performance analysis of our algorithm, we consider two cases: sparse and dense configurations. A configuration is called sparse if $n\cdot r{}\leq M$, and dense otherwise. In the rest of the paper we will ignore the unit distance in the expressions and regard as $r{}=1$.

III The Proposed Algorithm

In this section, we describe Circle-Tag, our strategy for the ONFP. In essence, the algorithm partitions the unexplored environment into blocks of equal size and assigns an active robot to each of them as shown in Figure 2. The blocks are shaped as cut circle sectors and each active robot performs an arc-shaped back-and-forth motion to cover the block. This motion guarantees that an asleep robot is going to be explored when it is inside a block.

The algorithm includes a set of behaviors which we introduce next. The execution of our algorithm consists of a sequence of rounds. A round starts when the leader begins traveling on its circle and ends when the last active robot finishes covering its assigned block for that round.

The motion of the leader robot is called Concentric-Circles-Search (CCS), and CCS($i$) refers to the path of the leader in round $i$. The CCS is composed of concentric circles whose radii increase at each round. These circles are always centered at the initial position of the leader robot. Suppose the leader travels on a circle of radius $R_{i}$ during a round $i$. If the number of activated robots is $k$, then $R_{i}$ is given by:

[TABLE]

where the starting radius $R_{0}$ is zero. Initially, there is only the leader and no other robot is active, so $k=0$. Until finding a robot, at each round the leader updates the radius $R_{i}$ by 1. This motion pattern ensures a full coverage of the leader’s surrounding.

At the end of each round, the leader moves in the East direction until it reaches the circle for the next round. Therefore, CCS($i$) in a round $i$ consists of traveling on a circle of radius $R_{i}$ and moving by $R_{i+1}-R_{i}$ towards East to get to the next circle. An example of this motion is illustrated in Figure 3(a). Here, the leader robot is shown in blue. The yellow area is the already covered part and gray area is the region explored in the current circle. The white outer part of the environment is unknown to the robot.

When the leader hits its nearest frozen robot, the activated robot does not immediately participate in the search, but merely follows the leader robot instead. After the second nearest robot is found, the algorithm proceeds by partitioning the area into two blocks and assigns an active robot for each. In each round, the active robots other than the leader cover their blocks in multiple back-and-forth sweeps. This motion pattern is called Block-Cover and an instance of it is shown in Figure 3(b). The actives are reassigned to their new blocks in the beginning of the next round.

Suppose that there are $k_{i}\geq 2$ active robots, excluding the leader, in the beginning of round $i$. Then, the number of blocks for that round is also $k_{i}$. Let $b_{i,k}{}$ denote a block in round $i$. In each block $b_{i,k}{}$ the active robot travels along $k_{i}$ concentric arcs and brings all the robots it encounters together, until the round finishes. The task of the leader robot is to circle around the covered area and reassign the active robots to their blocks, taking the newly found robots into account.

In round $i+1$, the leader robot starts by collecting the robots discovered in round $i$, as it passes from the active robot locations. An active robot starts sweeping the arcs as soon as it receives the block assignment. The leader robot keeps the collected robots until the end of the round and assigns blocks for them in the next round. Therefore, a robot explored in round $i$ joins the search starting from round $i+2$. The algorithm proceeds in this manner by expanding the coverage area, and terminates when all robots are discovered.

IV Performance of Circle-Tag

We proceed with analyzing the performance of Circle-Tag. We start with the case where the initial positions of the robots are chosen arbitrarily, then continue with the case when they are distributed uniformly at random.

IV-A Sweeping a Block

The algorithm Circle-Tag begins the process of exploring the frozen robots starting from the leader’s initial position. After the leader awakens two robots, each activated robot works on a dedicated zone assigned by the leader.

Suppose there are already explored $k_{i}$ robots in round $i$. Thus, the number of blocks is also $k_{i}$. An active robot sweeps its block $b_{i,k}{}$ in $k_{i}$ arcs in increasing radius whose apex angle is $2\pi/k_{i}$ (see Figure 3(b)). The asleep robots encountered during the coverage follow the active robot until the end of the round and become activated in the next round.

Proposition 1

Consider a round $i$ with $k_{i}$ active robots, and let $C(b_{i,k}{})$ denote the coverage time of a block $b_{i,k}{}$ using Block-Cover. The time it takes to complete the round is no more than $2C(b_{i,k}{})$.

The proof is presented in an accompanying technical report [5]. Proposition 1 tells us that the execution time of a round is bounded by twice the size of a block in that round.

IV-B Exploration with Circle-Tag

We continue by analyzing the performance of Circle-Tag in unbounded environments. Our analysis consists of two cases for the initial configuration of the robots. We say a configuration is sparse if $n\leq M$, and dense if $n>M$. We start with the sparse case.

IV-B1 Sparse configurations

In the beginning of the execution, the leader robot starts by performing the CCS centered at its initial position as shown in Figure 3(a). Consider the MST $\mathcal{T}$ on the initial configuration of the robots, and let $M$ denote the longest edge length in $\mathcal{T}$. Suppose $x_{1}$ is the leader robot, and $x_{2}$ and $x_{3}$ are the first and second activated robots, respectively. Since $\mathcal{T}$ spans all the robots, we know that the nearest neighbor distance of a robot cannot be more than $M$. Therefore, $d(x_{1},x_{2})\leq M$, and from the triangle inequality $d(x_{1},x_{3})\leq 2M$. Then, the time it takes to explore the first two robots is at most $4\pi M^{2}$.

To upper bound the solution of our algorithm, that is the time it takes to explore all robots using Circle-Tag, we consider the worst case. The worst case configuration for the ONFP is when the robots are initially in a path configuration with an equal spacing of $M$, and the leader robot is the leftmost or rightmost robot. This means that the tree $\mathcal{T}$ is a path with all edges of length $M$. This configuration is the worst case scenario because it has the maximum furthest pairwise distance among all possible configurations.

The analysis of our algorithm comprises multiple phases. Each phase is a collection of rounds, and the $t$-th phase finishes at the end of a round where the leader robot reaches a distance $t\cdot M$ away from its initial location. This ensures that there is a newly activated robot at the end of each phase. Note that the phases are only used in the analysis and they are not explicitly available to the robots.

For any two consecutive phases $t-1$ and $t$, consider the circles they started and let their radii be $R_{t-1}$ and $R_{t}$, respectively (see Figure 4). We define the radius difference as $\Delta^{-}:=R_{t}-R_{t-1}$, and sum as $\Delta^{+}:=R_{t}+R_{t-1}$.

Let $k_{t}$ be the number of active robots except the leader in phase $t$. The radius difference $\Delta^{-}$ cannot be more than $2M$. This is because the distance between a robot found in phase $t$ to an already explored robot in earlier phases is at most $M$, and since there are at most $k_{t}$ extra sweeps in a phase after finding a robot, the radii difference $\Delta^{-}$ is no more than $M+k_{t}<M+n\leq 2M$. The last inequality holds because $n\leq M$ in sparse configurations.

The radius sum $\Delta^{+}$ can be bounded by $2M(t-1)+2Mt<4Mt$, since the radius of the starting circle of a phase increases by at most $\Delta^{-}<2M$.

In each round of phase $t$, the blocks have height $k_{t}$ since the number of activated robots remains same within a phase and using Block-Cover the active robots sweep $k_{t}$ arcs. Therefore, until the next robot is explored, in phase $t$ there will be at most $\Delta^{-}/k_{t}<2M/k_{t}$ rounds in the worst case.

Suppose $D{}$ is the diameter of the tree $\mathcal{T}$. The distance between the initial position of the leader robot and its furthest neighbor is no more than $MD{}$. Then, there are at most $2H{}$ phases in the worst case, since $MD{}/M=D{}\leq 2H{}$.

We can then bound the solution of Circle-Tag as:

[TABLE]

where the radius $R_{0}$ is zero, and $k_{t}\geq t$ since in each phase there is at least one explored robot. For sparse configurations, we then arrive at the following result.

Lemma 1

Suppose the MST on the initial configuration has height 0pt and its maximum edge length is $M$. Then, the time to explore all robots using Circle-Tag in sparse configurations is $O(M^{2}H{})$.

IV-B2 Dense configurations

In dense configurations, $n$ is larger than $M$ so we cannot bound the completion time of a phase as before. However, since the robots use the same strategy in both cases, for the part when the number of activated robots $k_{t}$ in phase $t$ is smaller than $M$, the performance analysis will be the same.

Lemma 2

The time it takes to explore all robots in dense configurations is $O(\max\{M^{2}H{},(MH{})^{1.5}\})$, if the initial configuration MST has height 0pt and maximum length $M$.

Sketch of Proof: After bounding the value of $R_{t}$, we upper bound the number of rounds for the part where $k_{t}\geq M$. The full proof is presented in [5].

We proceed with lower bounding the optimal offline strategy. Consider $\mathcal{T}$, the MST on the initial configuration of the robots. The longest edge length $M$ in $\mathcal{T}$ is a lower bound for the optimal solution, because no strategy with execution time less than $M$ can tag all the robots. The following is the main result of our paper for arbitrary deployments.

Theorem 1

There exists an $O(H{}\cdot\max\{M,\sqrt{MH{}}\})$-competitive algorithm to the Online Network Formation Problem for arbitrary deployments in unbounded environments, where 0pt is the height of the MST on the initial configuration and $M$ is the maximum edge length in the tree.

Proof:

In Lemmas 1 and 2 we have shown that the time it takes to explore all the robots with Circle-Tag is $O(\max\{M^{2}H{},(MH{})^{1.5}\})$. Lower bounding the optimal solution by $M$ concludes the proof. ∎

IV-C Circle-Tag* in Random Deployments*

In this section, we present the performance of Circle-Tag for the case when the initial robot positions are chosen uniformly at random. Suppose that the robots are distributed uniformly at random over an open circular area of radius $L$, which is unknown to the robots.

Because the environment radius is $L$, the furthest pairwise distance between the robots is no more than $2L$. We have a loose upper bound by noting that all robots can be tagged by the first robot in time $4\pi L^{2}$. Using Circle-Tag, however, we show that we can significantly improve the performance to $O(M^{2})$. We analyze the execution time of the algorithm in phases as in the case of arbitrary deployments.

Proposition 2

Consider a partition of the environment surrounding the leader’s initial position $x_{1}$ with $N$ circular rings of increasing radius $iM$, for $i=1,\ldots,N$, until all robots are included. Then, each ring has at least one robot in it and the number of rings is bounded as $N\leq 2L/M$.

In our analysis we use the expected number of robots in the rings. Let $S_{i}$ denote the number of robots in ring $i$, and $S_{1:i}$ be the number of robots up to and including the ring $i$. To compute the expected values of $S_{i}$ and $S_{1:i}$, we first assume that the leader position is at the center of the area.

Proposition 3

Suppose the $i$-th innermost ring has radius $iM$ and there are $S_{i}$ robots inside. Then, the expected value of $S_{i}$ is lower bounded as $\mathbb{E}[S_{i}]\geq n(2i-1)M^{2}/4L^{2}$.

Proposition 4

The expected number of robots in up to and including the $i$-th innermost ring is lower bounded as $\mathbb{E}[S_{1:i}]\geq n(iM)^{2}/4L^{2}$.

The proofs of Propositions 2, 3 and 4 are given in [5].

Lemma 3

Suppose $n$ robots are distributed uniformly at random over a circular area of radius $L$. The expected time to explore all robots is $O(L^{2}\log n/n)$ using Circle-Tag.

Proof:

From Proposition 1, we know that the completion time of a round is no more than twice the size of a block in that round. Since the $i$-th innermost ring has area $\pi M^{2}(2i-1)$, we bound the expected execution time of Circle-Tag as follows.

[TABLE]

where the expectation is taken over all instances of the problem that are equally likely. The last inequality holds since $2L$ is the maximum possible pairwise distance and $Mn\geq 2L$. We can see that the exploration time is in $O(L^{2}\log n/n)$. Note that this bound does not change even when the leader is not at the center because the expected value of $S_{1:i}$ would be at least one fourth of the result in Proposition 4. ∎

The longest edge length $M$ of the MST $\mathcal{T}$ determines an important property in initial configurations. Suppose $G(n,r)$ denotes a Random Geometric Graph (RGG) of $n$ nodes each with communication radius $r$. A two dimensional RGG is constructed by uniformly distributing $n$ points over a unit ball, and placing an edge between two nodes if they are within $r$ of each other.

An MST on a set of points is the spanning tree with the smallest maximum edge length. Then, we can observe that $M$ is the critical distance to make $G(n,M)$ connected, because otherwise the MST would have a smaller longest edge. The following result establishes a bound for the connectivity of an RGG.

Lemma 4

([3, 7]) A two dimensional geometric random graph $G(n,r)$ is connected with probability at least $1-1/n^{2}$, if $r\geq\sqrt{2\log n/n}$.

Lemma 4 is remarkable since it tells us that the critical distance to make an RGG connected is $M=O(L\sqrt{\log n/n})$, when the points are distributed over a circle of radius $L$.

Theorem 2

There exists an $O(M)$-competitive algorithm to the ONFP in unbounded environments for the case when robot initial positions are chosen uniformly at random.

Proof:

In Lemma 3, we showed that the expected solution of Circle-Tag is $O(L^{2}\log n/n)$. The proof follows by lower bounding the optimal solution as $M=O(L\sqrt{\log n/n})$. ∎

Theorem 2 is our main result for the case of random deployments. In the next section, we present simulation results to validate the performance analysis.

V Simulations

We conducted simulations in MATLAB to confirm our analytical analyses presented in the previous section. The robots are deployed uniformly at random over a circular area of radius $L$ which is not accessible by the robots. In the simulations we used varying number of robots from 20 to 1000.

A snapshot from the execution of the algorithm is shown in Figure 5. Here, the leader robot is shown in blue, the active robots are colored red, and the rest of the robots are gray. The robots are distributed uniformly at random over a circular region of radius $L=20$ indicated by the dashed black circle. The solid circles depict the blocks to be covered.

In Figure 6 we present the simulation results of our algorithm. In this simulation, the robots are distributed uniformly at random over an area of radius $L=10$ and varying number of robots from $50$ up to $1000$ is used. For each number of robots we take the average of the algorithm’s performance over 1000 trials. We see that the $M^{2}H{}$ bound on arbitrary deployments fits nicely on random deployments as well. We note that the arbitrary deployments bound holds even without its coefficient derived in the analysis. The expected bound for random deployments also fits the result especially after the number of robots is significantly large. For fewer number of robots the bound is loose, which suggests that there is a room for improvement in the analysis.

VI Field Experiments

In this section, we describe our multi-robot system and the field experiments where we demonstrated Circle-Tag.

VI-A System Description

The experiment requires a system of multiple robots, each able to navigate autonomously, communicate and make decisions on the fly. Our system consists of three Uninhabited Aerial Vehicles (UAVs) and a ground station which is used to start and abort the mission. In our experiments, we used the quadrotor DJI Matrice 100 equipped with a GPS and compass modules. As an on-board computation unit, each UAV uses the NVIDIA Jetson TX1 running Linux Ubuntu 16.04 operating system. The robots communication network is based on the XBee modules. Each robot and the base station has a XBee module so that the robot states can be monitored from the ground. This also allows the base station to interrupt the mission in case of emergency situations such as low battery voltage.

VI-B State Machines for the Mission

As part of the implementation of Circle-Tag, we designed finite state machines for the active and frozen robots.

Initially, the leader robot runs the state machine shown in Figure 7(a) and all other robots run the one in 7(b). In the beginning of the execution, all robots are in the state IDLE waiting for the ground station to start the mission. The inactive robots remain in this state until they are found and became activated. Once the leader hears from the station, it goes into the TAKE-OFF state. After the take-off, the leader is in the GENERATE-WAYPOINTS state where it computes a path generated by Circle-Tag. While traveling on this path, the robot is in the NAVIGATE state. In this state, the active robot checks its vicinity using the XBee module and tags a frozen robot if it is nearby. If there is a tagged robot by the end of a round, the newly activated robot starts executing the active finite state machine. The robot then takes-off and all active robots generate a new path. This process is repeated until all robots are found and the round is finished. After this point, the robots return to the home locations (a gathering point), and go into the LAND state to finalize the mission.

VI-C Algorithm Demonstration

We implemented the state machines in Figure 7 as Robot Operating System (ROS) based modules compatible with our hardware. The experiments are conducted in Cedar Creek Ecosystem Science Reserve over a $100m\times 150m$ area.

Figure 8 shows the starting locations and trajectories of the robots used in the experiment. Each solid line with a separate color indicates the trajectory of a robot, and the triangles are the starting positions of the robots. An instance of the experiment is illustrated in Figure 1.

Although our algorithm is designed for planar environments, we generalize it to the UAV setting as follows. The highest UAV altitude is set to $h=40m$ and the robots increase the radius of their concentric-circles path by $2s=60m$ at each circle. The communication range of the robots is $r=50m$. Then, any staying put robot is guaranteed to be explored by the search since if it has a distance $d$ to a hovering active robot, this distance will be at most $d\leq r=\sqrt{h^{2}+s^{2}}$.

VII Conclusion

In this paper, we studied the network formation problem for a multi-robot system operating in an unbounded area. Each robot has a limited sensing range, therefore only the robots in the vicinity are communicable. For this problem, we introduced an algorithm whose competitive ratio is $O(H{}\cdot\max\{M,\sqrt{MH{}}\})$ for the case where the initial robot positions are chosen arbitrarily. On the other hand, when the robots are distributed uniformly at random we improve the ratio to $O(M)$. Future work includes removing the $O(\sqrt{MH{}})$ term in the competitive ratio for the case of arbitrary deployments. Another research direction is to consider the problem for a heterogeneous robots setting. In this case the task assignments of the robots can differ: for example, faster aerial robots can be used for exploring far away regions while the slower ground robots may be more efficient to search the nearby areas.