Table 4.1: Summary of notations used in our EVFA-B
Notation Description
m Length of the monitored field
n Width (breadth) of the monitored field
k Total number of sensor nodes (denoted as s1, s2, · · · , sk with radius r1, r2, · · · , rk)
(xi, yi) Coordinate (position) of sensor si
dijth Distance threshold for two arbitrary sensors si and sj (j 6= i) wa Tunable measure weight for the attractive force
wr(wb) Tunable measure weight for the repulsive force (boundary force)
−
→Fi Resultant force exerted on sensor si(attractive, repulsive, boundary forces considered)
M axloops Maximum number of virtual movements performed by each sensor cth Desired coverage ratio threshold
Algorithm 1 Enhanced Virtual Forces Algorithm with Boundary Forces (EVFA-B)
1: set loops = 0;
2: set cnow = cinit; // initial coverage ratio 3: while (loops < M axloops) && (cnow < cth) do 4: for each sensor si ∈ {s1, s2, ..., sk} do 5: compute −→
Fi=Pk
j6=i,j=1
−
→Fij+−→ Fib; 6: end for
7: perform virtual movements; // all sensors virtually move to their next positions 8: update coverage ratio cnow;
9: set loops = loops + 1;
10: end while
Table 4.1 summarizes the notations used in the EVFA-B mechanism, and Algorithm 1 provides the pseudocode for EVFA-B operations. Note that in the end of each loop, every sensor performs virtual movement without physically moving to the new position.
Physical movements are conducted once the EVFA-B process terminates (either cth or Maxloops has been reached), and this is when our collision-free path planning (CFPP) algorithm (detailed in Chapter 5) comes into play.
Chapter 5
Collision-Free Path Planning (CFPP)
In practical 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 for various collision cases need be systematically classified and handled/resolved in different ways. In this work, we assume the sensor volume is neglected and regarded as a moving point on a 2D plane, while every moving path (performed by a sensor) regarded as a line. Suppose no two moving paths share the same line (i.e., no path lies in the sub-path of another). 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 Q1(x1, y1) and Q2(x2, y2) fall in the same side if (ax1+ by1+ c)(ax2+ by2+ c) > 0, in different sides if (ax1 + by1 + c)(ax2+ by2 + c) < 0, while one or both reside(s) exactly on the line if (ax1+ by1+ c)(ax2+ by2+ c) = 0.
For an arbitrary sensor si departing from point pi (with coordinate (xi, yi)) to point p0 (with coordinate (x0, y0)), the moving path can be formulated as a line, denoted as
pij
Figure 5.1: Possible intersection (collision) cases generated by moving paths of any two sensors si and sj, where pi (pj) denotes the original position of si (sj) and p0i (p0j) indicates the physical movement destination for sensor si (sj).
Li. Similarly, the moving path of another sensor sj is given as Lj. Define pij as the intersection point of lines Li and Lj, 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 si and sj, as illustrated in Fig. 5.1, where d(pi, pij) and d(pj, pij) represent the Euclidean distances from pi to pij and from pj to pij. Case I shows the case in which points pi and p0i fall in different sides of line Lj, while points pj and p0j fall in different sides of line Li as well. In Case II, the departure point pj of sensor sj gets in the way of the moving path of si, while in Case IV, on the contrary, the departure point pi of sensor si blocks the moving path of sj. Case III draws the condition in which the destination point p0j of sensor sj lies on the moving path of si, while Case V, on the opposite side, displays the condition that destination point p0i of sensor si falls on the moving path of sj.
5.1 Path Planning Strategy
Given the five potential collision (intersection) cases caused by any two moving paths, we establish colliding set Ci, which includes all sensors whose moving paths intersect with that of si, for each sensor. 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 orderi as the cardinality of set Ci (orderi = |Ci|) for sensor si, indicating its moving order. We start from performing movements for sensors with the least order value. All sensors with the currently least (smallest) order value are contained in set Mmin order. Intuitively, sensors with order value of zero can move simultaneously since no other sensors pose potential colliding sources to them. For any sensor si with non-zero orderi value, potential colliding conditions (on per node-pair basis) caused by all members in its Ci set should be analyzed and handled case by case. Specifically, all sensors are divided into moving groups (batches) based on their order values and processed round by round (batch by batch). Sensors in set Mmin 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 Mmin order (or probably the whole Mmin order set) is determined and all sensors included in the subset are allowed to move simultaneously in the current round. For sensor si that has been evaluated and permitted to move, the tf lagi is set true, indicating its moving intention.
Once the physical movement has been successfully performed by sensor si, moving flag mf lagi is set true and si is removed from the consideration list. All order values for the remaining sensors (physical movements not performed yet) should be refreshed, and the batched scheduling procedure starts over accordingly.
Now we detail 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 order value as a potential moving batch and include them in set Mmin order. We then analyze all members in set Mmin order one by one to determine their moving possibilities. In our design, we start the evaluation from sensor with the smallest ID, say s1, and identify all possible collision cases caused by members in its colliding set C1. For any two sensors si and sj with moving orders orderi and orderj, the previously five collision cases can be further classified into ten cases according to the
relationship of orderi and orderj. Suppose si ∈ Mmin order, sj ∈ Ci, and orderi = orderj, 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 si and sj are potentially scheduled to move in the ”same” round due to equal order value. On the other hand, if orderi < orderj
(note that orderi > orderj is not possible since si ∈ Mmin 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 si and sj are potentially scheduled to move in ”different” rounds due to their unequal order values. In each potential collision case, on detecting a colliding possibility, si tries to resolve the collision by adjusting/prolonging the waiting time Tj or increasing the moving speed Vj of sensor sj. 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 si moves on to evaluate collision cases with other members in Ci. 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, si itself cannot be adjusted by other sensors in set Mmin order that are evaluated after it, if si is indeed scheduled to move in the current round. We keep track of the adjustment possibility for sensor si by the dirtyi bit, implying adjustable if set f alse and not adjustable if set true. When si intends to resolve a collision by adjusting another sensor with dirty bit set true, the adjustment is prohibited and si is not allowed to move in the current round (tf lagi set to f alse), since the collision remains. Only when all members in Ci with various colliding possibilities are all resolved can sensor si be included into the movable set and perform physical movement. Upon receiving the moving instruction from the clusterhead, si waits for Ti (possibly adjusted) and then moves with speed Vi (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 ad-justment, physical movement by sensor si 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 si and sj are scheduled 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, Chapter 5.2).
Action D-II In this case, since sj gets in the way of si’s moving path, the clusterhead instructs sj to slightly adjust its location along line −−→
pjp0j to avoid collision. Assume the location adjustment is small enough to have no effect on other moving paths.
Action D-V Sensor si is not allowed to move, for its destination point p0i will block the moving path of sj in a later round. In this case, the moving order of si should be set to be larger than that of sj (orderi = orderj+1) to postpone si’s physical movement after sj. In addition, a f ix orderi flag should be set true, indicating no updates on orderi will be performed in later rounds to ensure the delayed movement after sj, and then Action Deferred is invoked for si.
Action S-I Define the traveling time from pi to the intersection point pij as tpi→pij (obtained from available d(pi, pij) and Vi), the clusterhead evaluates if Ti + tpi→pij = Tj + tpj→pij, where Ti and Tj are the waiting times of si and sj as defined earlier. If equality holds, a collision at the intersection is expected, and the waiting time Tj of sj should be increased by a small amount of ∆t to avoid the collision. However, in case sj has already been processed with dirtyj set true, the adjustment is prohibited and si is not allowed to move in the current round. Consequently, moving order of si is increased
(orderi = orderi+ 1) and Action Deferred is invoked for si.
Action S-II If si reaches the intersection point pij no later than sj’s departure time, the clusterhead should instruct sj to slightly adjust its location along line −−→
pjp0j to avoid collision.
Action S-III If sj reaches the intersection point pij no later than si, the destination point p0j of sj will block the moving path of si. In this case, the clusterhead should instruct sj to increase its waiting time Tj by setting Tj = Ti + (tpi→pij − tpj→pij) + ∆t to ensure the delayed arrival of sj at pij (p0j). If the adjustment of Tj is not successful due to a true flag of dirtyj, then sj is not allowed to move in the current round. Consequently, moving order of sj is increased (orderj = orderj + 1) and Action Deferred is invoked for sj.
Action S-IV If sj reaches the intersection point pij no later than si’s departure time, the clusterhead should increase the waiting time of sj by setting Tj = Ti− tpj→pij+ ∆t. In case the adjustment is not allowed due to a true value of dirtyj, the clusterhead instructs si to slightly adjust its location along line −→
pip0i to avoid collision.
Action S-V If si reaches the intersection point pij no later than sj, the destination point p0i of si will block the moving path of sj. In this case, the clusterhead should instruct sj to increase its moving speed Vj by setting Vj = d(p Vi·d(pj,pij)
i,pij)+Vi(Ti−Tj) + ∆v, where
∆v is a small amount of speed increment to ensure sj’s earlier arrival at pij (p0i) than si. However, if the adjusted Vj is larger than the maximum possible moving speed Vmax or the adjustment of Vj is prohibited due to a true value of dirtyj, then si is not allowed to move in the current round. Moving order of si is increased (orderi = orderi+ 1) and Action Deferred is invoked for si.
Action Deferred Since si (sj) is not allowed to move in the current round, tf lagi (tf lagj) is set f alse. In addition, the clusterhead should confirm if this not-moving decision leads to moving path blocking of any sensor in Mmin order set that is already allowed to move in the current round (with tf lag set true), and do necessary slight
p1
fix order dirtyi tflagimflagi
0
dirtyi tflagi mflagi 1
Figure 5.2: Every sensor si in the potential moving set Mmin order should be analyzed by identifying its intersection (collision) relationship with each member in Ci, in which intersection cases D-II, D-IV, S-I, S-II, S-III, S-IV, and S-V require further considera-tion/processing, before including si into the moving set (allowed to move in the current round).
location adjustment to resolve the blocking.
Fig. 5.2 illustrates a snapshot of the CFPP operations. Note that s4 has more inter-sections with other sensors, which are not shown in the figure (omitted for brevity). In the current round, potential moving set Mmin order includes s1, s2, and s3, all having the currently smallest order value of 3. For s1, colliding conditions caused by all members in C1 are analyzed and handled case by case. In this example, since s1 and s2 are evaluated to reach intersection p12 simultaneously, the clusterhead adjusts the waiting time of s2 by setting T2 = T2+ ∆t to resolve the collision. Next, since s3 is found to reach intersection p13 earlier than s1, blocking s1’s moving path, the clusterhead instructs s3 to increase its waiting time by setting T3 = T1 + (tp1→p13− tp3→p13) + ∆t. As to s4 (scheduled to move in a later round), no action is required since no collision is likely to happen between s1 and s . Consequently, the clusterhead includes s into the moving set. Similar operations
apply to s2. In our example, s2 has no colliding possibilities with s1 and s3. However, since the departure location p4 of s4 blocks s2’s moving path, the clusterhead instructs s4 to slightly move from p4 (original) to p4 (adjusted), as shown in Fig. 5.2 (b). As a result, s2 is also included into the moving set. For s3, in our example, both s1 and s2 do not pose colliding sources to s3. Unfortunately, since the destination point p03 of s3 will block the moving path of s4 in a future round, s3 is not allowed to move before s4 (not included into the moving set), and order3 should be updated to 6 (order4+ 1) with f ix order3 set true. After the evaluations, sensors included in the moving set (i.e., s1 and s2) perform physical movements simultaneously, and order4 and set C4 are updated accordingly.
5.2 CFPP Algorithm Summary
Table 5.1: Summary of notations used in the CFPP algorithm
Notation Description
Ci Set of potential colliding sensors against si orderi Moving order of si, where orderi= |Ci|
f ix orderi Indicates the order value of si is henceforth fixed
dirtyi Indicates whether si has been processed in the current round tf lagi Indicates whether si is allowed to move in the current round mf lagi Indicates whether si has moved from pi to p0i
Mmin order Set of sensors with the minimum order value in the current round
Table 5.1 summarizes the notations used in CFPP, and Algorithm 2 provides the pseudocode for CFPP operations. In addition, a running example illustrating the CFPP route scheduling procedures is available in Fig. 5.3. Note that in Round 3 of this example, s9 is excluded from the moving set due to a unsuccessful adjustment of s11’s waiting time (since T11 has been adjusted by the clusterhead to resolve collision with s7 and can only be adjusted once according to the scheduling principles adopted by CFPP). After the clusterhead decides that s9 is not allowed to move in the current round, s9 no longer poses as a colliding source to s11. Consequently, s11 can be included into the moving set
si
dirtyi tflagimflagi
orderi fix order_ i
dirtyi tflagi mflagi
orderi fix order_ i
dirtyi tflagimflagi
orderi fix order_ i
dirtyi tflagimflagi orderi fix order_ i
dirtyi tflagimflagi
orderi fix order_ i
Figure 5.3: Example illustrating the operations of our proposed CFPP algorithm for sensor physical movements.
by the clusterhead.
In the CFPP strategy, we propose batched movements to successfully resolve moving collisions between sensors at the cost of global deployment latency. While most existing self-deployment works do not handle this collision problem, our proposed CFPP strategy is essential in practical deployment, and we believe the disadvantage of increased deployment time can be effectively reduced by the local recovery capability provided by our SSOA mechanism (detailed in Chapter 6), which leads to infrequent global redeployments.
Algorithm 2 Collision-free Path Planning (CFPP)
1: include all sensors in set S;
2: establish set Ci for ∀si ∈ S ; // i = 1, · · · , k
9: include all si with the minimum orderi value into the Mmin order set;
10: for (each si∈ Mmin order) do
11: set dirtyi= true; set tf lagi = true;
12: for (each sj ∈ Ci) do
13: classify the intersection (collision) case for si and sj; 14: switch (case)
15: Case D-II: do Action D-II;
16: Case D-V: do Action D-V;
17: Case S-I: do Action S-I;
18: Case S-II: do Action S-II;
19: Case S-III: do Action S-III;
20: Case S-IV: do Action S-IV;
21: Case S-V: do Action S-V;
22: end for 23: end for
24: perform simultaneous physical movements for ∀si with tf lagi== true;
25: set mf lagi = true for such sensor si; // indicating physical movement performed 26: remove all si with mf lagi== true from sensors set S;
27: end while
28: procedure Action D-II
29: slightly adjust location of sj from pj (original) to pj (adjusted);
30: procedure Action D-V
31: set orderi = orderj+ 1; set f ix orderi = true; invoke Action Deferred (si);
32: procedure Action S-I
33: if Ti+ tpi→pij = Tj+ tpj→pij then
34: if dirtyj == f alse then set Tj = Tj+ ∆t; dirtyj = true;
35: else set orderi = orderi+ 1; invoke Action Deferred (si);
36: procedure Action S-II
37: if Ti+tpi→pij ≤ Tj then slightly adjust location of sj from pj (original) to pj (adjusted);
38: procedure Action S-III
39: if Ti+ tpi→pij ≥ Tj+ tpj→pij then
40: if dirtyj == f alse then set Tj = Ti+ (tpi→pij− tpj→pij) + ∆t; set dirtyj = true;
41: else set orderj = orderj+ 1; invoke Action Deferred (sj);
42: procedure Action S-IV 43: if Ti≥ Tj + tpj→pij then
44: if dirtyj == f alse then set Tj = Ti− tpj→pij + ∆t; set dirtyj = true;
45: else slightly adjust location of si from pi (original) to pi (adjusted);
46: procedure Action S-V
47: if Ti+ tpi→pij ≤ Tj+ tpj→pij then
48: if dirtyj == f alse then set Vj = d(pi,pVijid(p)+Vj,pi(Tiji)−Tj)+ ∆v; set dirtyj = true;
49: if Vj > Vmax then set orderi= orderi+ 1; invoke Action Deferred (si);
50: else set orderi = orderi+ 1; invoke Action Deferred (si);
procedure Action Deferred (s)
28
Chapter 6
Sensor Self-Organizing Algorithm (SSOA)
Wireless sensors are inherently unreliable. Due to sensor power depletions or unex-pected failures over time, the decreased sensing coverage deteriorates the event detection capability of a WSN. To preserve the required sensing coverage, one alternative is to perform EVFA-B (presented in Chapter 4) periodically for global redeployments. How-ever, such constant global redeployment is costly in terms of communication overhead and consumed moving energy, and should be kept infrequent. Therefore, we propose the sensor self-organizing algorithm (SSOA) to firstly repair the sensing void (uncovered area caused by some broken sensor) by locally repositioning sensors around the sensing hole.
Two issues need be addressed to realize this local recovery: selection of repairing sensors (Chapter 6.1) and physical movements performed by the selected sensors (Chapter 6.2).
In case the local repairing is unable to recover the required sensing (detection) capability, SSOA then invokes EVFA-B to globally redeploy sensors.
6.1 Local Selection of Rescue Sensors
The first challenge of accomplishing partial repair is to locally select the rescue sensors around the sensing hole. Given a sensing hole caused by some broken sensor (sdead), all active sensors nearby (not necessarily the immediate neighbors of sdead) can be potential candidates to perform the local repair. Theoretically, every combination of rescue sensor candidates along with various moving strategies should be examined to obtain the most desirable coverage improvement. However, this approach is intractable, and not imple-mentable. Therefore, we limit the search of rescue sensors to the neighboring nodes of sdead, defined as set Ndead. Our objective is to select a subset Rdeadof local rescue sensors from Ndead (i.e., Rdead ⊆ Ndead) for repairing the sensing hole.
In order to evaluate the recovering capability of each sensor si ∈ Ndead, we try to quantify the overlapping degree possessed by each sensor, and associate an overlapping weight wi with sensor si. As shown in Fig. 6.1, for any two sensors si and sj with sensing radius ri and rj respectively, the overlapping degree wij is defined as the overlapped area between the two sensors, and can be easily obtained as wij = r2iθi + rj2θj − dijrisin θi. Then the overlapping degree wi can be approximated by summing up overlapping weights contributed from all neighbors of si, thus we have wi =P
sj∈Niwij (recall that Ni repre-sents the neighbor set of si). However, considering the existing sensing hole(s) around si,
sj∈Niwij (recall that Ni repre-sents the neighbor set of si). However, considering the existing sensing hole(s) around si,