1. 1 Routing on a Logical Grid Mohamed Gouda, Anish Arora, Young-ri Choi, Vinayak Naik The University of Texas at Austin The Ohio-State University January 2004

2. 2 New Routing Protocol We present a new routing protocol that is suitable for the Echelon demo This protocol is simple: it requires each mote to send only one three-byte msg every 3 seconds This protocol is reliable: it can overcome random msg loss and mote failure

3. 3 Motes A mote is a small computer that has a sensor board (sensing magnetism, sound, movement, etc.) A mote can communicate with adjacent motes by broadcasting messages over radio channels (i.e. wireless comm.). The motes in a network need to periodically send their sensing data to a particular mote called the network root.

4. 4 The Logical Grid The motes are named as if they form an M*N logical grid Each mote is named by a pair (i, j) where i = 0.. M-1 and j = 0.. N-1 The network root is mote (0,0) Physical connectivity between motes is a superset of their connectivity in the logical grid: (0,0) (0,1) (1,1) (1,0) (2,1) (2,0) (0,0) (0,1) (1,0) (1,1) (2,0) (2,1)

5. 5 Neighbors Each mote (i, j) has two low-neighbors (i-H, j) and (i, j-H) two high-neighbors (i+H, j) and (i, j+H) H is a positive integer called the tree hop If a mote (i, j) receives a msg from any mote other than its low- and high-neighbors, (i, j) discards the msg (i, j+H) (i+H, j) (i, j-H) (i-H, j) (i, j)

6. 6 Communication Pattern Each mote (i, j) can send msgs whose ultimate destination is mote (0, 0) The motes need to maintain an incoming spanning tree whose root is (0, 0): each mote maintains a pointer to its parent When a mote (i, j) has a msg, it forwards the msg to its parent. This continues until the msg reaches mote (0, 0). (H = 2)

7. 7 Choosing the Parent Usually, each mote (i, j) chooses one of its low-neighbors (i-H, j) or (i, j-H) to be its parent If both its low-neighbors fail, then (i, j) chooses one of its high- neighbors (i+H, j) or (i, j+H) to be its parent. This is called inversion Example: there is one inversion at mote (2, 2) because the two low-neighbors of (2, 2) have failed. (H = 2) failed

8. 8 Inversion Count Each mote (i, j) maintains  the id (x, y) of its parent, and  the value c of its inversion count: the number of inversions that occur along the tree from (i, j) to (0, 0) Inversion count c has an upper value cmax Example: failed (H = 2) (3,2), 1(0,3), 0 (0,1), 0 (0,0), 0

9. 9 Protocol Message If a mote (i, j) has a parent, then every 3 seconds it sends a msg with three fields: connected(i, j, c) where c is the inversion count of mote (i,j) Otherwise, mote (i, j) does nothing. Every 3 seconds, mote (0, 0) sends a msg with three fields: connected(0, 0, 0)

10. 10 Acquiring a Parent Initially, every mote (i, j) has no parent. When mote (i, j) has no parent and receives connected(x, y, e), (i, j) chooses (x, y) as its parent if (x, y) is its low-neighbor, or if (x, y) is its high-neighbor and e < cmax When mote (i, j) receives a connected(x, y, e) and chooses (x, y) to be its parent, (i, j) computes its inversion count c as: if (x, y) is low-neighbor, c := e if (x, y) is high-neighbor, c := e + 1

11. 11 Keeping the Parent If mote (i, j) has a parent (x, y) and receives any connected(x, y, e) then (i, j) updates its inversion count c as: if (x, y) is low-neighbor, c := e if (x, y) is high-neighbor and e < cmax, c := e + 1 if (x, y) is high-neighbor and e = cmax, then (i, j) loses its parent

12. 12 Losing the Parent There are two scenarios that cause mote (i, j) to lose its parent (x, y) (i, j) receives a connected(x, y, cmax) msg and (x, y) happens to be a high-neighbor of (i, j) (i, j) does not receive any connected(x, y, e) msg for 30 seconds

13. 13 Replacing the Parent If mote (i, j) has a parent (x, y), and receives a connected(u, v, f) msg where (u, v) is a neighbor of (i, j), and (i,j) detects that by adopting (u, v) as a parent and using f to compute its inversion count c, the value of c is reduced then (i, j) adopts (u, v) as its parent and recomputes its inversion count

14. 14 For Line-in-the-Sand Demo We made the following decisions: Adjacent motes are placed 5 feet apart (to ensure accurate sensing). The motes are arranged in 7*13 grid (to cover the designated area for the demo). H = 2 (since reliable communication is ensured between two motes that are 15 feet apart). cmax = 3

15. 15 Two Problems of this Protocol The protocol does not take advantage of any long links between motes that are not neighbors in the logical grid In an MxN grid, the protocol causes an average application message to make (M+N)/2H hops, which is relatively large For M=7, N=13, H=2, the average message makes 5 hops

16. 16 Problems can be solved By allowing long links in the routing tree reducing the number of hops traveled by the application data messages

17. 17 Allowing Long Links Add the following rule to the previous rules for acquiring and replacing a parent: If any mote (i,j) ever receives a message connected(0,0,0), then mote (i,j) makes mote (0,0) its parent

18. 18 Reducing Number of Hops A mote (i,j) accepts any received application data(x,y,txt) message iff x=i and y=j This applies only when i!=0 or j!=0 Mote (0,0) accepts any received application data(x,y,txt) message

19. 19 Concluding Remarks Currently Choi is working on simulating the grid routing protocol, after adding these two modifications, on a 5x5 grid Stay tuned!