Collision-Free Motion Algorithms for Sensors Automated Deployment to Enable a Smart Environmental Sensing-Net

As natural habitats protection has become a global priority, smart sensing-nets are ever-increasingly needed for effective environmental observation. In a practical monitoring network, it is critical to deploy sensors with sufficient automated intelligence and motion flexibility. Recent advances in robotics and sensors technology have enabled automated mobile sensors deployment in a smart sensing-net. Existing deployment algorithms can be employed to calculate adequate destinations (goals) for sensors to perform respective monitoring tasks. However, given the calculated goal positions, the problem of how to actually coordinate a fleet of robots and schedule moving paths from random initials to reach their goals safely, without collisions, remains largely unaddressed in the wireless sensor networking (WSN) literature. In this paper, we investigate this problem and propose polynomial-time collision-free motion algorithms based on batched movements to ensure all the mobile sensors reach their goals successfully without incurring collisions. We observe that the grouping (batching) strategy is similar to the coloring procedure in graph theory. By constructing a conflict graph, we model the collision-free path scheduling as the well-known k-coloring problem, from which we reduce to our k-batching problem (determining the minimum number of required batches for a successful deployment) and prove its NP completeness. Since the k-batching problem is intractable, we develop CFMA (collision-free motion algorithm), a simple yet effective batching (coloring) heuristic mechanism, to approximate the optimal solution. Performance results show that our motion algorithms outperform other existing path-scheduling mechanisms by producing 100% sensors reachability (success probability of goals reaching), time-bounded deployment latency with low computation complexity, and reduced energy consumption. Note to Practitioners— This research was originally motivated by an oceanography project, which studied marine microbes by sending a team of tiny robots (sensors) randomly scattered on the ocean floor. For hard-to-access habitats like deserts or oceans, where manual placement of sensors is costly or impossible, automatically scheduling robots movements to calculated positions from random initials is essential for an effective monitoring. Our contribution is unique in two ways. First, traditional path-planning research focuses more on independent robots navigating the environment, whereas we target on the network automation problem, coordinating a fleet of robots working together to perform an environmental sensing task. Second, we observe that existing movement methods are too complicated and energy-consuming due to the calculation on-the-go nature. To provide a practical solution, we suggest and design our motion algorithms from a new perspective: pre-scheduled batched movements. Our approach requires a central server for grouping (batching) calculations, but can effectively reduce computation complexity and save significant energy expenditure exerted on resource-limited sensors. The proposed collision-free motion algorithm (CFMA) is a suboptimal yet efficient batching solution, which can be easily applied in real-life open-space monitoring networks. Insights from this foundational research will facilitate future opportunities to implement and verify our method in operational monitoring testbeds.

matically scheduling robots movements to calculated positions from random initials is essential for an effective monitoring. Our contribution is unique in two ways. First, traditional pathplanning research focuses more on independent robots navigating the environment, whereas we target on the network automation problem, coordinating a fleet of robots working together to perform an environmental sensing task. Second, we observe that existing movement methods are too complicated and energyconsuming due to the calculation on-the-go nature. To provide a practical solution, we suggest and design our motion algorithms from a new perspective: pre-scheduled batched movements. Our approach requires a central server for grouping (batching) calculations, but can effectively reduce computation complexity and save significant energy expenditure exerted on resource-limited sensors. The proposed collision-free motion algorithm (CFMA) is a suboptimal yet efficient batching solution, which can be easily applied in real-life open-space monitoring networks. Insights from this foundational research will facilitate future opportunities to implement and verify our method in operational monitoring testbeds.
Index Terms-Environmental observation and monitoring, autonomous sensors deployment, smart sensing network automation, collision-free motion algorithm, graph theory, vertex coloring.

I. INTRODUCTION
F OR decades, researchers have been seeking ways to deploy useful networks for realizing the goal of smart living. Wireless sensor networks (WSNs) have been thriving and attracting significant attention thanks to the advancements of micro-electromechanical system (MEMS), sensing technology, and wireless communication. A WSN is widely used for habitat and environmental monitoring, surveillance (camera) networks, medical application, agricultural assistance, and as solutions to military problems [1]- [4]. For monitoring and surveillance applications, sufficient sensing coverage is essential for a WSN to operate successfully. Traditionally maintaining such a network is labor-intensive, often requiring additional staff charged with monitoring the sites daily and responding to inquiries. We consider a smart sensing network which has the ability to self-deploy mobile sensors and react with proper responses in an automated manner. With the growing prevalence of wireless mobile sensors, automated sensors deployment (in lieu of manual placement) has become practical and feasible [5]. In our prior research [6], [7], we developed coverage-aware deployment protocols that calculate best monitoring positions (goals) for all sensors. autonomous sensors and directing them from their random initials to goals without collisions has been left unsolved. In this follow-up research, we emphasize on resolving this problem by designing actual collision-free motion strategies for realizing a practical sensing environment. Fig. 1 (a) epitomizes an open-space sensing environment (such as an ocean floor), where each mobile sensor (tiny robot) has to move from its initial (departure) location to the goal (destination) position. Without careful path scheduling, those tiny robots are likely to run into each other, resulting in an unsuccessful deployment. As depicted in Fig. 1 (b), robots B and C collide at the intersection of their moving paths, further blocking the travel path of robot F to its goal position. Meanwhile, robots E and D are prevented from reaching their destinations because of the goal positions being occupied by robots F and E respectively. In fact, robots D, E, and F form a deadlock situation, which remains unsolved in some previous works [8]- [10]. Such collision and deadlock problems motivate us to design collision-and deadlock-free motion algorithms for ensuring sensors goal reachability.
We investigate the path scheduling problem and propose to apply batched movements by dividing robots into several moving groups. One possible grouping strategy, as illustrated in Fig. 1 (c), is to instruct robots A, D, E, F (group #1) move first, then robot C (group #2), followed by robots B and G (group #3). By assigning robots in proper moving groups (batches), Fig. 1 (d) displays a successful deployment with all robots now arriving at their correct goal positions.
Evidently, the grouping strategy (batching algorithm) plays a key role in helping robots reach their intended goals safely without collisions. Designing collision-free batching algorithms is non-trivial, which requires carefully analyzing all collision cases while considering computation and traveling latency (attempting to minimize the number of moving batches so as to accomplish the deployment task in a timely manner).
In this paper, we regard all sensors as dynamic objects (tiny robots) and develop our collision-free motion algorithms based on batched movements, to address the sensors deployment problem. Our proposed batching algorithms incur little computation latency, moderate energy consumption, and ensure 100% sensors goal reachability. The remainder of this paper is organized as follows. Section II prepares the readers with related work and summarizes our unique contributions. We present our CFPP, CFMA, and wCFMA protocol details in Section III, Section IV, and Section V respectively. Section VI provides performance comparisons in terms of goals reaching success probability, deployment latency, and energy consumption. Finally, we conclude the paper in Section VII. An illustrative video that shows the operations of our current prototype can be found at [11].

II. RELATED WORK
Traditional path-planning methods in the area of multirobot systems can be generally classified into three categories: roadmap-based, performing cell decomposition, and applying the concept of artificial potential field, according to the authors in [12] and [13]. The roadmap-based methods construct visibility graphs to assist in the path-planning process [14]- [16], in which the resultant moving paths may touch fixed obstacles at the vertices or even edges that are considered unsafe. To address this drawback, approaches based on cell decomposition by computing Voronoi diagrams have been introduced to perform path scheduling in a more precise way at the cost of increased computation latency [13]. The third category of path-planning approaches models the obstacles and targets as electrostatic charges interacting with each other, creating a potential field [17]- [19]. The obstacle exerts a repulsive force while the target location has an attractive effect on the robot position. This method enables path planning to be completed in real time. However, as only local properties are considered, the robots may get trapped at local minima or aimless oscillation without reaching their goals. The aforementioned approaches assume one or more fixed obstacles in a multi-robot system, which differs from our mobile sensors networking scene. In this paper, we investigate a sensing system where all sensors are mobile and considered as dynamic objects (rather than fixed obstacles). 1 Another approach in finding shortest moving paths is based on A* search [20]. A* works by expanding the vertices inside the map and searching for the nodes with lower estimated distance to the goal. The ability of this A* search algorithm to be manipulated in many ways leads to the development of many path planning techniques [9], [10], [21]. Approaches based on adapted GA (genetic algorithm) have also been proposed to address the problem [22], [23]. A comprehensive study of path-planning algorithms comparison can be found in [24]. In recent years, special-purpose research also puts interest in using autonomous underwater vehicles (AUVs) for marine geoscience studies in dangerous environments [25], [26]. In these settings, robots are deployed in an obstacle-free space moving/flying from initial to goal positions to perform certain tasks. However, those approaches require high computation complexity and deal with independent robots navigating an environment rather than coordinating a fleet of robots distributed to perform the monitoring task. In this paper, we consider a smart sensing environment 2 with environmental monitoring application to automatically coordinate a fleet of autonomous sensors (tiny robots) to move toward their designated goals (destinations). To enable a smart environment with sufficient sensing coverage, the success rate of goals reachability is crucial in our target application.
Three more closely related path-planning methods to our envisioned scenario that also deal with dynamic objects include ADO [8], Super A* [9], and M* [10]. In ADO, all robots are prioritized and equipped with omnidirectional cameras (visual sensors) to perform real-time path-planning computations. ADO suffers from the deadlock problem in which some robots are unable to reach their destinations (goal positions). In addition, extra (non-negligible) energy consumption is required due to the constant usage of visual sensors for path calculations in ADO. On the other hand, both M* and Super A* modify the classical A* search algorithm [20] by taking environmental changes into account while robots move. M* additionally introduces subdimensional expansion, a framework to compute individual policy for each robot first (neglecting the presence of other robots) and then joint policy path is employed using an underlying planner (based on A* search) to find optimal paths in the search space. Another concept of backpropagation is introduced such that the search space is only expanded where necessary (when the planner encounters robot-robot collision). Super A* and M* successfully resolve some deadlock cases that ADO fails to handle. However, the triangular deadlock problem in ADO remains unsolved in Super A* and M*. Moreover, extensive computation latency is required in Super A* and M* due to the high time-complexity nature of the A* search algorithm. In our proposed motion mechanisms, computation latency, execution (moving) time, and energy consumption are also evaluated so that the deployment task can be accomplished in a timely manner while conserving energy resources on sensors.

A. Our Contributions
In this research, we provide an in-depth analysis on the sensors moving path scheduling problem and propose corresponding motion algorithms. Below we summarize our unique contributions.
First, we carefully classify all possible collision cases and devise a collision-free path planning (CFPP) algorithm (Section III) based on batched movements to guarantee all the mobile sensors reach their goals (destinations) with 100% success rate. The CFPP performance demonstrates the feasibility of resolving collisions and deadlocks by moving in batches. 3 Second, to accelerate the deployment process (by possibly reducing the number of required moving groups), we observe the grouping (batching) strategy is similar to the coloring procedure in graph theory. By constructing a conflict graph, we model the collision-free path scheduling as the well-known k-coloring problem, from which we reduce to our k-batching problem (determining the minimum number of required batches for a successful deployment) and prove its NP completeness. Since the k-batching problem is intractable, we develop CFMA (collision-free motion algorithm), a simple yet effective batching (coloring) heuristic mechanism, to approximate the optimal solution (refer to Section IV for proof and algorithm details). Third, to further enhance CFMA 3 The preliminary results of CFPP have been reported and published in a previous conference paper [27]. However, the prior work did not study the aspects of minimizing the number of moving groups (batches) or shortening the total deployment time, and lacks detailed results on sensors goal reachability with effectively reduced computation and execution (travel) latency. Also, the aspects of moving energy consumption and different initial/final sensors configurations were not extensively evaluated in the prior work. In this journal paper, we identify several inefficiencies of CFPP and propose two enhanced collision-free motion algorithms, namely CFMA and wCFMA, for accelerating the deployment process by possibly reducing the number of required moving groups (batches) and shortening the total travel (moving) time spent by all sensors. Though inspired from CFPP and also based on batched movements, CFMA and wCFMA are two new path scheduling approaches that operate quite differently from CFPP. performance, we propose wCFMA (weighted collision-free motion algorithm), which reduces sensors execution (moving) time by imposing smaller variance (difference) among travel distances within the same batch (moving group). We regard this as the weighted-batching problem and successfully prove its NP-hardness by reducing from the weighted-coloring problem. Consequently, we design wCFMA, a weight-ordered batching (coloring) heuristic mechanism, to approximate the min-weighted solution (refer to Section V for proof and algorithm details). Our wCFMA intends to generate batches with shortened total execution (moving) time in the example cases, thus accomplishing the sensors deployment task earlier (compared to CFPP and CFMA). The proposed CFMA and wCFMA grouping strategies can also be nicely applied to other similar research problems modeled in the form of graph coloring (using minimum number of colors) or weighted coloring (minimizing sum of total group weights). Furthermore, we have also implemented a proof-of-concept prototype based on moving robots (LEGO MINDSTORMS NXT 9797 [28]), network camera M30 [29], and Tibbo embedded systems [30] to demonstrate the operations of our proposed motion algorithm in a real system [11].
Specifically, in this work, we propose a new perspective of pre-scheduled batched movements to bring down the sensors deployment cost. There has been a growing recognition of the need to keep spending (cost spent on hardware and software) under control, even as environmental monitoring projects become increasingly complex. That is where our work comes in by introducing a practical solution. Existing path-planning methods for multi-robot systems are computation-intensive and/or energy-consuming. Another major concern is those previous approaches do not ensure all robots reach their goal points (as demonstrated in Section VI-A, Fig. 10 and Fig. 11). Sensors goal reachability is critical in realizing an effective environmental monitoring application.
Our theoretical contributions include interpretation of multirobot path planning as the coloring problem on a conflict graph, proving NP-completeness of the k-batching problem (Theorem 2), and verifying NP-hardness of the weightedbatching problem (Theorem 3). Please note that we do not directly use graph theory to solve our problem. By proving NP-completeness/hardness, we show that there do not exist efficient (polynomial-time) algorithms to determine optimal moving sets. Therefore, we develop CFMA and wCFMA, suboptimal yet efficient batching solutions, to address the problems under study. Existing coloring algorithms only take care of adjacent-coloring rule, ensuring adjacent nodes colored differently, without considering coloring sequence (robots movement order). However, in our target application, movement order is important in resolving robot-robot collisions or deadlocks. To address these new challenges, in CFMA and wCFMA, we define collision Cases II and III (Fig. 5) to impose extra restrictions in addition to the valid adjacent-coloring rule. Adjusting colors for special conflict Cases II and III can be found in the last segment of our CFMA Algorithm. Unlike previous path-planning approaches, our motion algorithms advance related research by proposing computation-efficient and robust path-scheduling methods that ensure all sensors reach their goals successfully.

III. PATH PLANNING STRATEGY
To enable actual sensors deployment, a collision-free moving path scheduling is essential, so that mobile sensors can reach their destinations without colliding with each other. However, the scheduling strategy is non-trivial since various collision cases need be systematically classified and handled/resolved in different ways.

A. Preliminaries
Assume that the sensor volume is neglected 4 and each sensor (tiny robot) can be regarded as a moving point on a 2D plane, while every moving path (traveled by a sensor) formulated as a line. Suppose no two moving paths share the same line (i.e., no path lies in the sub-path of another). 5 We identify the collision cases based on the following geometric theorem.
Theorem 1: With respect to the line ax + by + c = 0 on a 2D plane, points Q 1 (x 1 , y 1 ) and Q 2 (x 2 , y 2 ) fall on the same side if (ax 1 + by 1 + c)(ax 2 + by 2 + c) > 0, on different sides if (ax 1 +by 1 +c)(ax 2 +by 2 +c) < 0, while one or both reside(s) exactly on the line if (ax 1 For an arbitrary sensor s i departing from point p i with coordinate (x i , y i ) to point p i with coordinate (x i , y i ), the moving path can be formulated as a line, denoted as L i . Similarly, the moving path of another sensor s j is given as L j . Define p i j as the intersection point of lines L i and L j , which can be easily obtained by solving the two line equations. According to Theorem 1, we can now classify five possible intersection (collision) cases for any two sensors s i and s j , as illustrated in Fig. 2, where d( p i , p i j ) and d( p j , p i j ) represent the Euclidean distances from p i to p i j and from p j to p i j . Case I shows the case in which points p i and p i fall on different sides of line L j , whereas points p j and p j fall on different sides of line L i as well. In Case II, the departure point p j of sensor s j gets in the way of the moving path of s i , while in Case IV, on the contrary, the departure point p i of sensor s i blocks the moving path of s j . Case III draws the condition in which the destination point p j of sensor s j lies on the moving path of s i , whereas Case V, in contrast, displays the condition that destination point p i of sensor s i falls on the moving path of s j .

B. Collision-Free Path Planning (CFPP)
Given the five potential collision (intersection) cases caused by any two moving paths, we establish a colliding set C i for each sensor, which includes all sensors whose moving paths intersect with that of s i . Instead of performing one-time physical movements, we propose to use batched movements  such that the scheduling complexity can be reduced at the expenses of increased moving latency. Define or der i as the cardinality of set C i (or der i = |C i |) for sensor s i , indicating its moving order. We start from performing movements for sensors with the smallest or der value. All sensors with the currently minimum (smallest) or der value are contained in set M min_order . Intuitively, sensors with or der value of zero can move simultaneously since no other sensors pose potential colliding sources to them. For any sensor s i with non-zero or der i value, potential colliding conditions (on per node-pair basis) caused by all members in its C i set should be analyzed and handled case by case. Specifically, all sensors are divided into moving groups (batches) based on their or der values and processed round by round (batch by batch). Sensors in set M min_order are evaluated in the same round. The evaluation and processing details will be provided later in this section. After the evaluations, a subset of M min_order (or probably the whole M min_order set) is determined and all sensors included in the subset are allowed to move simultaneously in the current round. For sensor s i that has been evaluated and permitted to move, the t f lag i is set true, indicating its moving intention. Once the physical movement has been successfully performed by sensor s i , moving flag m f lag i is set true and s i is removed from the consideration list. All or der values for the remaining sensors (physical movements not performed yet) should be refreshed, and the batched scheduling procedure starts over accordingly. Now, we elaborate on the evaluation procedures for determining a set of movable sensors in a single round (batch). Based on the idea of batched movements, we regard all sensors with the currently minimum or der value as a potential moving batch and include them in set M min_order . We then analyze all members in set M min_order one by one to determine their moving possibilities. In our design, we start the evaluation from sensor with the smallest ID, say s 1 , and identify all possible collision cases caused by members in its colliding set C 1 . For any two sensors s i and s j with moving orders Algorithm 1 Collision-free Path Planning (CFPP) include all sensors in set S; establish set C i for ∀s i ∈ S; // i = 1, · · · , n evaluate or der i for ∀s i ∈ S; include all s i with the minimum order i value into the M min_order set; procedure Action D-II slightly adjust location of s j from p j (original) to p j (adjusted); procedure Action D-V set or der i = or der j + 1; set f i x_or der i = true; invoke Action Deferred (s i ); do necessary slight adjustment of s i 's departure location to resolve moving path blocking possibly caused by this not-moving decision; (end of Algorithm 1) or der i and or der j , the previously five collision cases can be further classified into ten cases according to the relationship Every sensor s i in the potential moving set M min_order should be analyzed by identifying its intersection (collision) relationship with each member in C i , in which intersection cases D-II, D-V, S-I, S-II, S-III, S-IV, and S-V require further consideration/processing, before including s i into the moving set (allowed to move in the current round).
of or der i and or der j . Suppose s i ∈ M min_order , s j ∈ C i , and or der i = or der j , we term the five collision cases as Case S-I, Case S-II, Case S-III, Case S-IV, and Case S-V, where 'S' indicates that sensors s i and s j are potentially scheduled to move in the "same" round due to equal or der value. On the other hand, if or der i < or der j (note that or der i > or der j is not possible since s i ∈ M min_order ), we define another five collision cases as Case D-I, Case D-II, Case D-III, Case D-IV, and Case D-V, where 'D' means s i and s j are potentially scheduled to move in "different" rounds due to their unequal or der values. In each potential collision case, on detecting a colliding possibility, s i tries to resolve the collision by adjusting/prolonging the waiting time T j or increasing the moving speed V j of sensor s j . Originally all waiting times are set to zero, and moving speeds all set at a constant velocity V . If the adjustment (on either waiting time or moving speed) is successful, the colliding possibility is eliminated and s i moves on to evaluate collision cases with other members in C i . To avoid repeated adjustments on a single sensor, in our design, each sensor is allowed to be adjusted (either on waiting time or moving velocity) once. In addition, s i itself cannot be adjusted by other sensors in set M min_order that are evaluated after it, if s i is indeed scheduled to move in the current round. We keep track of the adjustment possibility for sensor s i by the dirt y i bit, implying adjustable if set f alse and not adjustable if set true. When s i intends to resolve a collision by adjusting another sensor with dirt y bit set true, the adjustment is prohibited and s i is not allowed to move in the current round (t f lag i set to f alse), since the collision remains. Only when all members in C i with various colliding possibilities are all resolved can sensor s i be included into the movable set and perform physical movement. Upon receiving the moving instruction from the clusterhead, s i waits for T i (possibly adjusted) and then moves with speed V i (possibly adjusted). In our route scheduling strategy, we try to include as many sensors as possible to move simultaneously in the same round (batch).
For each of the ten collision cases identified, we define corresponding actions (Action D-I, Action D-II, · · · , Action S-I, Action S-II, · · · ) to evaluate respective case and perform necessary adjustments. If colliding possibility remains due to unsuccessful adjustment, physical movement by sensor s i is not allowed and should be deferred. Thus we additionally define Action Deferred to perform corresponding operations. Note that in Case D-I, Case D-III, and Case D-IV, no action is needed since s i is scheduled to move before s j in different rounds (no collision is likely to happen in the three cases despite intersection exists between the two moving paths). For the rest of seven cases, we describe the evaluation principles exercised by respective action as follows (detailed operations are available in Algorithm 2, Section III-C).
Action D-II In this case, since s j gets in the way of s i 's moving path, the clusterhead instructs s j to slightly adjust its location along line −−→ p j p j to avoid collision. Assume the location adjustment is small enough to have no effect on other moving paths.
Action D-V Sensor s i is not allowed to move, for its destination point p i will block the moving path of s j in a later round. In this case, the moving order of s i should be set larger than that of s j (or der i = or der j + 1) to postpone s i 's physical movement after s j . In addition, a f i x_or der i flag should be set true, indicating no updates on or der i will be performed in later rounds to ensure the delayed movement after s j , and then Action Deferred is invoked for s i . Action S-I Define the traveling time from p i to the inter- where T i and T j are the waiting times of s i and s j as defined earlier. If equality holds, a collision at the intersection is expected, and the waiting time T j of s j should be increased by a small amount of t to avoid the collision. However, in case s j has already been processed with dirt y j set true, the adjustment is prohibited and s i is not allowed to move in the current round. Consequently, moving order of s i is increased (or der i = or der i + 1) and Action Deferred is invoked for s i . Action S-II If s i reaches the intersection point p i j no later than s j 's departure time, the clusterhead should instruct s j to slightly adjust its location along line −−→ p j p j to avoid collision. Action S-III If s j reaches the intersection point p i j no later than s i , the destination point p j of s j will block the moving path of s i . In this case, the clusterhead should instruct s j to increase its waiting time T j by setting . If the adjustment of T j is not successful due to a true flag of dirt y j , then s j is not allowed to move in the current round. Consequently, moving order of s j is increased (or der j = or der j + 1) and Action Deferred is invoked for s j .
Action S-IV If s j reaches the intersection point p i j no later than s i 's departure time, the clusterhead should increase the waiting time of s j by setting T j = T i − t p j → p i j + t. In case the adjustment is not allowed due to a true value of dirt y j , the clusterhead instructs s i to slightly adjust its location along line − − → p i p i to avoid collision. Action S-V If s i reaches the intersection point p i j no later than s j , the destination point p i of s i will block the moving path of s j . In this case, the clusterhead should instruct s j to increase its moving speed V j by setting V j = where v is a small amount of speed increment to ensure s j 's earlier arrival at p i j ( p i ) than s i . However, if the adjusted V j is larger than the maximum possible moving speed V max or the adjustment of V j is prohibited due to a true value of dirt y j , then s i is not allowed to move in the current round. Moving order of s i is increased (or der i = or der i + 1) and Action Deferred is invoked for s i .
Action Deferred Since s i (s j ) is not allowed to move in the current round, t f lag i (t f lag j ) is set f alse. In addition, the clusterhead should confirm if this not-moving decision leads to moving path blocking of any sensor in M min_order set that is already allowed to move in the current round (with t f lag set true), and do necessary slight location adjustment to resolve the blocking. Fig. 3 illustrates a snapshot of the CFPP operations. Note that s 4 has more intersections with other sensors, which are not shown in the figure (omitted for brevity). In the current round, potential moving set M min_order includes s 1 , s 2 , and s 3 , all having the currently smallest or der value of 3. For s 1 , colliding conditions caused by all members in C 1 are analyzed and handled case by case. In this example, since s 1 and s 2 are evaluated to reach intersection p 12 simultaneously, the clusterhead adjusts the waiting time of s 2 by setting T 2 = T 2 + t to resolve the collision. Next, since s 3 is found to reach intersection p 13 earlier than s 1 , blocking s 1 's moving path, the clusterhead instructs s 3 to increase its waiting time by setting As to s 4 (scheduled to move in a later round), no action is required since no collision is likely to happen between s 1 and s 4 . Consequently, the clusterhead includes s 1 into the moving set. Similar operations apply to s 2 . In our example, s 2 has no colliding possibilities with s 1 and s 3 . However, since the departure location p 4 of s 4 blocks s 2 's moving path, the clusterhead instructs s 4 to slightly move from p 4 (original) to p 4 (adjusted), as shown in Fig. 3 (b). As a result, s 2 is also included into the moving set. For s 3 , in our example, both s 1 and s 2 do not pose colliding sources to s 3 . Unfortunately, since the destination point p 3 of s 3 will block the moving path of s 4 in a future round, s 3 is not allowed to move before s 4 (not included into the moving set), and or der 3 should be updated to 6 (or der 4 +1) with f i x_or der 3 set true. After the evaluations, sensors included in the moving set (i.e., s 1 and s 2 ) perform physical movements simultaneously, and or der 4 and set C 4 are updated accordingly. Table I summarizes the notations used in CFPP, and Algorithm 2 provides the pseudocode for CFPP operations.

C. CFPP Summary
A running example illustrating the route scheduling procedures is available in Fig. 4. Note that in Round 3 of this example, s 9 is excluded from the moving set due to an unsuccessful adjustment of s 11 's waiting time (since T 11 has been adjusted by the clusterhead to resolve collision with s 7 and can only be adjusted once according to the scheduling principles adopted by CFPP). After the clusterhead decides that s 9 is not allowed to move in the current round, s 9 no longer poses as a colliding source to s 11 . Consequently, s 11 can be included into the current moving set (Round 3).

IV. ENHANCED PATH SCHEDULING
While CFPP operates correctly, yet the collision cases classification and corresponding actions pose as a tedious work. Nonetheless, we gain useful insights from the design process, which prompts us to wonder whether or not CFPP produces the minimum number of moving sets (batches). In other words, does there exist an efficient path scheduling algorithm that guarantees the fewest number of moving batches to minimize the overall deployment time? We attempt to answer this intriguing question and possibly enhance our path scheduling (grouping) strategy as follows.

A. Problem Formulation
Observing the example in Fig. 4, we identify two main problems in CFPP operations. First, scheduling mi n_or der sensors to move early may not be a good idea as those sensors actually bear lesser colliding conflict to others and could be handled later. Second, sensors with same or der value are not necessarily able to move in the same round. For instance, s 4 and s 5 are on the collision course with each other and should not be scheduled in same moving set despite having the same or der value (or der 4 = or der 5 = 2). On the other hand, sensors with different or der values are possible to move in the same round without collisions. For instance, s 2 , s 6 and s 9 are able to deploy simultaneously despite having different or der values (or der 2 = 2, or der 6 = 1, and or der 9 = 3). However, CFPP conservatively schedules s 2 (Round 2) and s 6 (Round 5) to move alone respectively, as shown in Fig. 4. For a better scheduling, whether or not two sensors can be assigned in the same moving set should depend on their mutual conflict relationship, rather than inspecting their or der values alone and separately.
Inspired from this observation, we aim to resolve the CFPP inefficiency by first constructing a conflict graph to specifically identify the conflict relationship between each pair of sensors in their moving paths.

1) Construction of a Conflict Graph:
We re-organize the collision cases in CFPP into three possible intersection categories (collision types), as shown in Fig. 5. Case I plots the moving paths of s i and s j collide at the path intersection. 6 Case II illustrates the departure (initial) location of s j gets in the way of s i 's moving path whereas Case III draws the condition in which the destination (goal) position of s j lies on the moving path of s i . The intersection cases sufficiently reveal three collision types, allowing us to explicitly define conflict links between sensors.
For a given set of n sensors and moving paths, we construct an undirected conflict graph G = (S, L) where S = {s 1 , s 2 , . . . , s n } includes all sensor nodes and edge set L contains all conflict links between any two sensors. That is, (s i , s j ) ∈ L iff moving paths of s i and s j encounter one of the three collision types (Case I, Case II, or Case III).
Furthermore, back to Fig. 5, since Case I indicates the two sensors will reach the intersection at the same time, this sensor pair should move in different rounds. We denote this conflict type by a solid link in our conflict graph. For Case II, denoted by a dotted link, s j should move no later than s i , meaning that s j must move earlier than s i or be scheduled in the same round as s i to resolve the conflict. By setting up same_ f lag[i ][ j ] we are able to identify this special case and possibly schedule s i and s j in the same group to reduce the number of moving sets (batches). In Case III, we should instruct s i to move earlier than s j , as such early_ f lag[i ][ j ] must be set, drawn as a dashed link to imply this conflict type in our conflict graph. Algorithm 5 (the last segment) provides a detailed description on how to handle special Cases II and III. At this moment, we consider a conflict graph containing conflict links with no distinction between different collision types.
A constructed conflict graph concisely defines the collision relationship between each pair of sensors' moving paths, which helps in both theoretically analyzing the path scheduling problem and our algorithm design in Section IV-B.
2) NP Completeness Proof: Now, we return to the interesting question of how many moving sets (batches) are just sufficient for a successful collision-free sensors deployment with minimum execution time. For a given constructed conflict graph, our path scheduling (grouping) strategy intends to divide the sensors into different groups (batches) such that all sensors scheduled in the same group (moving round) do not collide with each other. Specifically, our grouping strategy attempts to make sure adjacent nodes (connected with one of the three conflict types defined in Section IV-A1) in the conflict graph do not move simultaneously, so collisions can be effectively eliminated. This design rationale reminds us of the well-known vertex-coloring problem in graph theory, which deals with coloring adjacent vertices using different colors. A valid coloring of an undirected graph G = (V, E) is an assignment of colors to the vertices such that each vertex is assigned one color and no two adjacent vertices share the same color. The k-coloring problem has developed from the 3-coloring decision (yes/no) problem to one that determines the minimum number of colors needed to color a graph [33], [34], as formally defined below.

. , v n } and edge set E ⊆ V × V . A kcoloring of G is a mapping (valid coloring) function f : V → {1, . . . , k} where k is a positive integer, with each vertex v i corresponding to an integer color value c i (1 ≤ c i ≤ k) such that c i = c j for every edge
In other words, the numbers 1, 2, · · · , k represent the k colors, and adjacent vertices must have different colors. The k-coloring problem is to determine the minimum k.
The k-coloring problem has proven to be NP-complete (NPC), from which we prove our path scheduling (k-batching) problem is also NPC. Given a conflict graph, the k-batching problem is to determine the minimum number of batches (moving groups) required to accomplish a collision-free sensors deployment, formally defined as follows.
Definition 2: Given a conflict graph G = (S, L) with sensor set S = {s 1 , s 2 , . . . , s n } and conflict link set L ⊆ S × S. A k-batching of G is a mapping (valid grouping) function f : S → {1, . . . , k} where k is a positive integer, with each sensor node s i corresponding to an integer group number g i (1 ≤ g i ≤ k) such that g i = g j for every conflict link (s i , s j ) ∈ L. In other words, the numbers 1, 2, · · · , k denote the k groups (batches), and adjacent sensor nodes must be assigned in different moving groups (batches). The k-batching problem is to determine the minimum k.
Theorem 2: Our k-batching problem is NP-complete. Proof: The k-batching problem belongs to NP since we can verify a solution easily in polynomial time. To prove kbatching is NP-complete, we reduce k-coloring to k-batching by showing k-coloring ≤ p k-batching. In other words, any instance of k-coloring can be reduced in polynomial time to an instance of k-batching. Let G = (V, E) represent an arbitrary instance of k-coloring. We can transform G with coloring function f to an instance of the k-batching G = (S, L) with grouping function f by taking S = V , L = E and group number g i corresponding to the color value c i in polynomial time. We claim that we can find a valid k-coloring of G if and only if we can discover a collision-free k-batching of G . For the if part, suppose that G can be validly colored using a minimum number of k colors. By taking G = G and f = f , we can find a solution in G with each sensor node s i being assigned group number g i = c i resulting in a minimum of k batches (moving groups). Conversely, we prove the only if part. Suppose that we can obtain a minimum k batches for grouping all sensors without collisions in G . By taking G = G and f = f , there must exist a valid coloring of G with each vertex v i being colored c i = g i using a minimum number of k colors, which completes the proof.

B. Collision-Free Motion Algorithm (CFMA)
Since our k-batching problem is intractable, the answer to determining the minimum required number of moving sets (batches) cannot be easily obtained. Specifically, there does not exist an efficient (polynomial-time) path scheduling algorithm that guarantees the fewest number of moving batches to minimize the overall deployment execution time. Therefore, we devise CFMA (collision-free motion algorithm), a simple yet effective batching (coloring) strategy, to approximate the optimal solution. 1) Algorithm Description: In this proposed heuristic algorithm, we attempt to address the two main drawbacks in CFPP (identified in Section IV-A) by first constructing a conflict graph to reflect mutual conflict (collision) relationship between sensors and then assigning batches (colors) from highest-to lowest-degree nodes in a greedy manner. Here we define the node degree as the number of conflict links a sensor is connected with in a conflict graph. The strategy of considering sensors with high conflict degrees before sensors with low conflict degrees intends to take care of sensors with the largest number of conflicts as early as possible. 7 CFMA starts out with an established conflict graph. For each pair of sensors (s i , s j ) connected with a conflict link, a specific con f li ct_type[i ][ j ] is set values 1, 2, or 3 to respectively indicate the three collision cases Case I, Case II, and Case III described in Section IV-A1 (illustrated in Fig. 5). Before performing the coloring (grouping) process, we need to identify potential circular deadlocks. First, CFMA examines all sensor pairs and constructs chains, set of ordered sensors based on the early_ f lag [i ][ j ] defined in Section IV-A1. Specifically, chai n x = {s i , s j } indicates that s i should move Second, all chains are examined to produce merged chains by repeatedly connecting any two chains chai n x and chai n y if tail sensor in chai n x equals head sensor in chai n y . In Fig. 6, the four chains are merged into one large chai n = {1, 4, 3, 2, 1}. Finally, our algorithm checks the head and tail sensors in every merged chain. A circular deadlock (loop) is detected if head sensor equals tail sensor within the chain. In our example, the merged chai n = {1, 4, 3, 2, 1} happens to be a loop (circular deadlock) with the same head and tail sensor s 1 . Once a circular deadlock is detected, CFMA will apply the same color to all involved sensors in the loop. In other words, those sensors involved in the circular deadlock will be scheduled in the same moving batch and act together (colored as a group) thereafter. Consequently, in this example, all four sensors s 1 , s 2 , s 3 , and s 4 will move simultaneously, hence resolving the circular deadlock problem.
Our goal is to assign as few collision-free moving groups as possible to all sensors (associated with valid coloring for the conflict graph using as few colors as possible). The coloring (grouping) process is applied in the order of decreasing node degrees, meaning that s i with max_degree will be colored first. In case of sensors with the same degree, s i will be considered before s j if i < j . A used color set U i keeps track of colors not allowed for s i because these colors have already been allocated to neighboring nodes. Once producing a successfully colored conflict graph, 8 CFMA returns to handle special collision cases Case II and Case III where some colors adjustment may be necessary. Finally, sensors perform physical movements accordingly in the order of their assigned colors (moving groups). Table II summarizes the notations used in CFMA, and Algorithm 5 provides the CFMA pseudocode, presented in three segments. The first Algorithm 5 segment describes the procedure of classifying conflict types for every sensor pair (s i , s j ) and constructing corresponding conflict graph. The second segment details on how to detect and resolve potential deadlocks, followed by a complete coloring process. Finally, the last segment illustrates the process of handling special (to be continued in next Algorithm segment) conflict Cases II and III. Now, the number of required moving sets is indicated by the value of color_count.
2) An Example: Using the same configuration with our CFPP example, Fig. 7 displays the constructed conflict graph and corresponding coloring process inside the dashed box. Starting from the max_degree = 2 with smallest sensor ID, CFMA colors s 1 red (c 1 ), followed by s 2 colored green (c 2 ). Next, sensors s 7 , s 9 , s 11 are colored red (c 1 ), green (c 2 ), and blue (c 3 ) respectively according to the coloring rules. Then CFMA proceeds to color remaining sensors with lower degrees until all sensors have been validly colored. Finally, CFMA inspects the special collision cases (Cases II and III) and discovers s 10 should move simultaneously with s 2 (same_ f lag [10][2] = 1), thus changing color from c 1 to c 2 for s 10 . So far a total of three colors have been applied, which happens to be the minimum required number of colors because there is a triangle in the graph (formed by sensors s 7 , s 9 , s 11 ). In any undirected graph containing a triangle, at least three colors are needed for a valid coloring. Consequently, CFMA effectively improves the total execution time by reducing from 5 rounds in CFPP to 3 rounds, which // for s i , s j with same degree, s i will be considered before s j if i < j initiate used color set U i = ∅ for ∀s i ∈ S order ; clear color i = 0, color _count = 0; if color i = 0 then continue; // skip coloring if U i == ∅ then color i = 1; else choose a color c / ∈ U i ; set color i = c; for each s j ∈ conflict set C i do add color i into used color set U j ; end for for each s j with loop j = loop i && loop i = 0 do set color j = color i ; // all sensors involved in same loop (circular deadlock) applied same color for each s k ∈ conflict set C j do add color j into used color set U k ; end for end for if color i > color _count then color _count = color i ; end for // coloring completed turns out to be the optimal (smallest) number of required moving sets (batches) for a collision-free deployment in this configuration. 9 Suppose w(B r ) denotes the longest travel time among all sensors in moving batch B r , here r = 1, 2, 3, then the corresponding total execution time T can be obtained by summing up w(B r ). That is, T = 3 r=1 w(B r ) in this CFMA example.

V. WEIGHTED PATH SCHEDULING
Now that CFMA successfully reduces moving sets (batches) from 5 rounds in CFPP to 3 rounds (as shown in Fig. 7), the total execution time has been effectively decreased. If all robots require the same or similar travel times, then minimizing the number of moving batches naturally translates to minimized overall execution time. However, in a real deployment, robots (mobile sensors) typically take different travel times to their respective destinations (goal positions). For a moving set (group) containing robots with mixed long and short travel times, the execution time to complete physical movements within this group is determined by the longest travel time. From this perspective, a solution using fewer batches does not always perform better than another solution requiring more batches in terms of total execution time. Specifically, minimizing the number of moving sets does not necessarily translate to minimized total execution time, due to the fact that the number of batches cannot solely determine the aggregate required deployment time.
In light of this, we associate each sensor s i with a weight defined by its travel time (moving from initial to goal positions) and investigate the weighted path scheduling problem. One can easily obtain the required travel time w(s i ) for sensor s i by computing w(s i ) = distance(s i ) velocit y(s i ) . For each batch (moving set) B r , the weight of B r is defined as w(B r ) = max{w(s i )|s i ∈ B r } since the elapsed time to complete physical movements depends on the longest travel time among all sensors within this batch. Our idea is to design an enhanced grouping strategy that aptly arranges sensors with similar travel times in one group, combining with the goal of employing as few moving sets as possible, to further improve (accelerate) the total deployment time.
Example showing the benefit of considering weight (traveling distance) in our grouping strategy (assuming the same moving speed); total deployment cost is reduced from 240 units (40 sec) to 160 units (26 sec).
To further enhance the performance with reduced moving cost, we consider weight (traveling distance) in the grouping strategy by starting group arrangement from sensors associated with the highest weight. Thus s 1 , s 6 are assigned to the first moving set B 1 producing weight w(B 1 ) = max{w(s 1 ), w(s 6 )} = max{100, 100} = 100, whereas the second and third moving sets imposing weights w(B 2 ) = max{w(s 2 ), w(s 3 ), w(s 5 )} = max{40, 40, 40} = 40 and w(B 3 ) = max{w(s 4 )} = max{20} = 20, as illustrated in Fig. 8 (b). Consequently, this new arrangement results in a total moving (travel) cost of 160 units, which shows a noticeable improvement in cost reduction by 33%. The enhancement brought by incorporating weights (time costs) into the grouping strategy motivates us to study the problem complexity of weighted path scheduling.

B. Problem Formulation
In Section IV-A2 we regard our path scheduling to minimize moving sets as a reduced case from the k-coloring problem in graph theory. As investigating the problem further, we discover, as mentioned in the beginning of Section V, minimizing the number of moving batches does not always yield minimized total travel cost. When we consider weights (time costs) in the grouping strategy, the overall execution time can be effectively reduced, as demonstrated in Fig. 8(b). For the goal of speeding up deployment time, weights should be taken into consideration when we perform the batching (coloring) process, referred to as the weighted-batching problem. This reminds us of another coloring problem, known as weighted-coloring in graph theory. The weighted-coloring is a weighted version of the coloring problem which consists in finding a color partition P = (P 1 , · · · , P k ) (k is the number of used colors) in the vertex set V of an undirected graph G into stable sets and minimizing k r=1 w(P r ) where the partition weight w(P r ) is defined as max{w(v i )|v i ∈ P r }. Note that the weighted-coloring problem attempts to minimize the sum of total weights imposed by all partitions, rather than optimize (minimize) the number of partitions k. Similarly, our weighted-batching problem intends to find a batch arrangement producing a minimum sum of weights (time costs), instead of minimizing the number of batches.
1) NP Hardness Proof: We formally define the weightedcoloring problem as follows.
Definition 3: Given an undirected graph G = (V, E, w) with vertex set V = {v 1 , v 2 , . . . , v n } and edge set E ⊆ V × V , the vertex-weighted function w assigns a positive real number w(v i ) ≥ 0 for any vertex v i ∈ V . The weightedcoloring problem is to find a valid coloring that contains a color partition P = (P 1 , · · · , P k ) of the vertex set V minimizing k r=1 w(P r ) where the color partition weight w(P r ) = max{w(v i )|v i ∈ P r }.
The weighted-coloring problem was originally proposed in [35] and proven to be NP-hard [36], from which we prove our weighted path scheduling (weighted-batching) problem is also NP-hard. Given a conflict graph, the weighted-batching problem is to determine a batch arrangement with a minimized sum of total weights (travel time costs) to optimize the collision-free deployment time, formally defined below.
Theorem 3: Our weighted-batching problem is NP-hard. Proof: To prove weighted-batching is NP-hard, we reduce weighted-coloring to weighted-batching by showing weightedcoloring ≤ p weighted-batching. In other words, any instance of weighted-coloring can be reduced in polynomial time to an instance of weighted-batching. Let G = (V, E, w) with coloring function f and color partition P represent an arbitrary instance of weighted-coloring. We can transform G with coloring function f and color partition P to an instance of the weighted-batching G = (S, L, w ) with grouping function f and batch partition B by taking S = V , L = E, w = w, group number g i corresponding to the color value c i and batch partition B r corresponding to the color partition P r in polynomial time. We claim that we can find a valid weightedcoloring of G if and only if we can discover a collisionfree weighted-batching of G . For the if part, suppose that G can be validly colored with minimized k r=1 w(P r ) where w(P r ) = max{w(v i )|v i ∈ P r }. By taking G = G , f = f and P r = B r , we can find a solution in G with each sensor node s i being assigned group number g i = c i resulting in a minimized k r=1 w (B r ) (sum of batch partition weights) where w (B r ) = max{w (s i )|s i ∈ B r }. Conversely, we prove the only if part. Suppose that we can obtain a collision-free (valid) sensors grouping arrangement with minimized total travel time in G . By taking G = G, f = f and B r = P r , there must exist a valid coloring of G with each vertex v i being colored c i = g i producing a minimized k r=1 w(P r ) (sum of color partition weights), which completes the proof.

C. Weighted CFMA (wCFMA)
Since the weighted-batching problem belongs to NP-hard, we propose wCFMA, a weight-ordered heuristic algorithm, to approximate the min-weighted solution. Our idea is to impose smaller variance (difference) among travel time costs // for s i , s j with same weight, s i will be considered before s j if i < j initiate used color set U i = ∅ for ∀s i ∈ S order ; clear color i = 0, color _count = 0; perform coloring process (same as CFMA) adjust colors for special conflict Cases II and III perform physical movements (same as CFMA) within the same moving batch. In contrast to CFMA intending to reduce the number of batches, wCFMA attempts to reduce the sum of batch weights, where weight of a moving batch is the maximum (longest) travel time among sensors in the same batch.
1) Algorithm Description: wCFMA mostly follows the previously outlined CFMA method. The key difference lies in the coloring process, in which wCFMA colors sensors in the order of decreasing weights. Table III summarizes the notations used in wCFMA, and Algorithm 6 provides the wCFMA pseudocode.
2) An Example: Our wCFMA intends to generate batches with shortened total execution (moving) time, thus accomplishing the sensors deployment task earlier (compared to CFPP and CFMA). Fig. 9 illustrates the wCFMA coloring process which results in 3 rounds (same as CFMA) with total moving cost of 190 units. Compared to 290 units in CFPP and 205 units in CFMA, the overall execution cost in wCFMA improves (reduces) by 35% (improved from CFPP) and 7.3% (further improved from CFMA) respectively. In our prototype, one grid unit equals 1 cm, and the average moving speed of our robots is measured at 0.06 m/sec. Hence the total execution time can be obtained at 48 sec (CFPP), 34 sec (CFMA), and 31 sec (wCFMA), respectively.

VI. PERFORMANCE EVALUATION
In this section, we validate our motion algorithms by comparing the performance with three other path-planning approaches: ADO (introduced in [8]), Super A* (introduced in [9]) and M* algorithm (introduced in [10]). Fig. 10 depicts a configuration consisting of 20 random moving paths with three deadlock situations. Potential deadlocks #1 and #2 simulate the situation when a goal position blocks another sensor's moving path, whereas potential deadlock #3 demonstrates a triangular deadlock situation, in which all involved sensors are prevented from moving. This configuration is arranged in order to observe the capability of path-planning algorithms on resolving deadlocks, as mentioned in [37]. 10 Fig . 11 shows the sensors goal reachability accomplished by CFPP, CFMA, wCFMA, ADO, Super A*, and M* as time advances. Samples are taken every 20 seconds to record the reachability rate within a set time. We observe that ADO suffers from deadlocks #1 and #3 at time 20, which stop sensors s 11 , s 16 , s 17 , s 18 from moving to their destinations (goals). At time 40, ADO encounters deadlock #2, which prevents sensor s 14 from reaching its goal position. After time 40, ADO is unable to make any further progress with eventually 75% final goal reachability. Super A* is capable of resolving deadlocks #1 and #2, but unable to handle the triangular deadlock #3, which occurs at time 20 and traps sensors s 16 , s 17 , s 18 from departing toward their destinations. Super A* stops making progress after time 40, leading to 85% 10 Here we define that deadlocks among two or more robots (mobile sensors) occur if these robots block each other in a way such that any or all of them is/are unable to continue along its/their trajectory (traveling path) without causing a collision. final goal reachability. Similar to Super A*, M* also suffers from deadlock #3, leading to 85% final goal reachability.

A. Sensors Goal Reachability
In contrast, our CFPP is capable of resolving all deadlock situations. For deadlocks #1 and #2 (classified as Case D-V in our CFPP algorithm), sensors s 4 and s 10 execute Case D-V by deferring their movements (scheduled in a later batch after s 11 and s 14 reach their goal positions). For deadlock #3 (a triangular deadlock), since sensors s 16 , s 17 , s 18 will be scheduled in the same moving order, CFPP naturally resolves this deadlock situation by allowing three sensors to move simultaneously without blocking each other. Interestingly, CFPP reachability grows slowly (due to the batched movements applied by CFPP) and outperforms the other three approaches after time passes 80, eventually leading to 100% goal reachability.
CFMA also defers the movement of sensors s 4 and s 10 after s 11 and s 14 reach their goals, resolving deadlocks #1 and #2, whereas the triangular deadlock #3 is handled by allowing three sensors to move in the same round (batch). CFMA achieves 100% goal reachability at time 60 (earlier than CFPP) due to the reduced number of moving batches employed. wCFMA further improves the overall deployment time by grouping sensors with longer travel distances (s 1 , s 11 , s 12 , s 14 ) in the same batch, while CFMA arranges s 1 and s 14 (two sensors with longer paths) to move in different batches. As a result, wCFMA achieves 100% goal reachability before time 40 (fastest among all approaches).
We conduct extensive experiments against various sensor populations (creating various sensor densities) to observe how each mechanism performs in different sensor configurations.   Sensors goal reachability accomplished by our CFPP, CFMA, wCFMA, also Super A*, M*, and ADO path-planning strategies with the existence of potential deadlocks #1, #2, and #3 in a monitored 200×200 area. their destinations (goal positions) with reachability weakening into 80% as the population of sensors grows. Super A* is capable of approaching 100% reachability under a balanced configuration, yet with crowded initials and crowded goals, the reachability of Super A* drops, indicating this mechanism is vulnerable to uneven distribution of sensors. Although M* performs relatively well with small numbers of sensors, its performance weakens significantly as the population grows because the algorithm fails to generate safe moving paths for most sensors. In fact, M* reachability drops drastically to almost 0% in the second configuration (crowded initials). When the initial points of sensors are very crowded (very close to each others), the tree expansion in M* encounters failures very early, and the mechanism eventually fails to generate moving paths for most/all of the sensors as the population grows. In contrast, our CFPP, CFMA, and wCFMA can safely generate collision-free paths and deliver all sensors to their destinations with 100% goal reachability for various sensor populations under all three configurations. Fig. 12 (d)(e)(f) also display the sensors deployment time incurred by all six approaches. The total deployment time consists of computation latency (shaded parts) and execution (moving) time (unshaded/light parts). We define the moving time as the time required for all robots to travel to their goals (from robots start moving until no robot moves anymore, even though in some cases, not all robots can successfully reach their goals). CFPP, CFMA, wCFMA and ADO manifest little computation latency (so that it might be difficult to observe in the figure, as the value is very small, close to zero second), while M* and Super A* require significantly longer time to compute path-planning solutions (can be observed in the figure clearly). Apparently, computation latency with M* increases drastically as the number of mobile sensors (moving paths) grows, due to extensive computation required by the tree expansion method in M* algorithm. In the second (crowded initials) and third configurations (crowded goals), the generated paths encounter failures (collisions) and M* needs to retrace backward (initiating backpropagation sets), leading to growing dimensions of the search space/tree, consuming even more computational time. For execution (moving) time, we can observe that CFPP spends the most time for travel due to its batched movements in a conservative way, whereas CFMA and wCFMA improve (decrease) the travel time noticeably because of minimized number of batches and minimized sum of total time costs. The travel (execution) time for M* drops as the population grows, because most robots are unable to reach their intended destinations (algorithm fails to generate paths for those robots). Despite that CFPP consumes more execution time, the total deployment time required by M* is longer than CFPP when sensor population increases (over 30 sensors in the figure); in fact, M* fails to deliver most sensors whereas CFPP still achieves a 100% reachability. Overall, this set of experiments demonstrates our CFMA and wCFMA outperform other approaches in terms of sensors deployment latency while maintaining 100% goal reachability.

C. Energy Consumption
To model the moving energy, we estimate the energy consumed by the motion device moving for one grid unit by performing real measurements on the sensor robot used in our implementation testbed [7], based on moving robots (LEGO MINDSTORMS NXT 9797 [28]), with grid size equal to 1 cm. The robot assembles six 1.2 V 2000 mAh rechargeable NiMH batteries with measured 200 ∼ 290 mA moving current and average moving speed at 0.06 m/sec. Consequently, the average moving energy consumption per grid (unit distance) can be obtained by 0.29 × 7.2 × ( 0.01 0.06 ) = 0.348 Joule. We then compute the total moving energy consumption based on the traveling distance accordingly. To model the energy consumed by visual sensors (cameras) in ADO (recall that ADO algorithm depends on the presence of omnidirectional cameras for calculating moving paths, as described in Section II), we perform measurements on a commercial video camera M30 Series [29]. An estimated 3.4 Watt on average (ranging from 2.2 to 4.6 Watt) facilitates our calculation of the total camera energy required by an individual sensor in ADO, which can be obtained by 3.4 × moving time (sec) Joule. Fig. 13 displays the aggregate energy consumed by six approaches under a balanced sensors configuration. Our proposed mechanisms (CFPP, CFMA and wCFMA) consume the least aggregate energy while achieving 100% goal reachability, whereas ADO produces the most power cost due to extra energy consumed by visual sensors (omnidirectional cameras). Meanwhile, since the generated Super A* paths are not always in straight lines (shortest paths), Super A* consumes relatively more moving energy as compared to our approaches. Note that, as sensor population grows, M* deployment consumes less energy, not because of improved efficiency, but due to its inability to deliver most of the robots to their intended destinations (most robots fail to move with only 58% goal reachability). Consequently, this set of experiments further demonstrates our proposed motion algorithms are practical in terms of energy efficiency.

VII. CONCLUSION AND FUTURE APPLICATIONS
In this paper, we devised three collision-free motion algorithms (CFPP, CFMA, wCFMA) to schedule moving paths for the mobile sensors deployment problem. When sensors move around to self-deploy, the motion algorithm comes into play by systematically classifying colliding cases and employing batched movements. Our proposed mechanisms guarantee 100% sensors goal reachability due to the capability of judiciously grouping all sensors and guiding them to their goals without causing collisions nor deadlocks. With the assistance of an IoT application development tool [38], we have implemented a proof-of-concept prototype 11 based on moving robots (LEGO MINDSTORMS NXT 9797 [28]), network camera M30 [29], and Tibbo embedded systems [30] to further corroborate our CFMA protocol feasibility in a real-life environment. A brief demonstration video on our experiments is available at [11]. Among a great number of practical IoT testbeds that have been set up during recent years, potential application targets include roof/bridge monitoring networks, agricultural plant watering schedules to enable smart farming, underwater sensor systems [25], [39], etc. We observe 11 In our system, robots are equipped with collision-detection sensors to prevent occasional bumps in case of path prediction inaccuracy. When that happens, involved robots will stop and wait for central server's instructions before proceeding further. that IoT testbeds operated in open space are in need of effective, intelligent yet not too complicated, collision-free motion scheduling algorithms. We expect the concept and deployment of our proposed approaches can facilitate the realization of various meaningful IoT applications in the near future.