Routing on a Logical Grid

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
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
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
The Logical Grid

• The motes are named as if they form an MN
  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,1)
(0,1)
(1,1)
(2,1)
(2,1)
(1,1)
(2,0)
(0,0)
(1,0)
(2,0)
(0,0)
(1,0)
5
Neighbors

• Each mote (i, j) has
• two low-neighbors (i-H, j) and (i, j-H)
• two high-neighbors (iH, j) and (i, jH)
• 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, jH)
(i, j)
(iH, j)
(i-H, j)
(i, j-H)
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
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 (iH, j) or (i,
  jH) 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.

failed
failed
(H 2)
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
failed
(3,2), 1
(0,3), 0
failed
failed
(0,3), 0
(0,0), 0
failed
(0,0), 0
(H 2)
(0,1), 0
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
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 lt 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
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 lt cmax, c e
  1
• if (x, y) is high-neighbor and e cmax, then (i,
  j) loses its parent

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
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
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 713 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
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 (MN)/2H hops, which
  is relatively large
• For M7, N13, H2, the average message makes 5
  hops

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
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
Reducing Number of Hops

• A mote (i,j) accepts any received application
  data(x,y,txt) message iff
• xi and yj
• This applies only when i!0 or j!0
• Mote (0,0) accepts any received application
  data(x,y,txt) message

19
Concluding Remarks

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