The Design and Analysis of an Efficient Local Algorithm for

Coverage and Exploration Based on Sensor

Network DeploymentMaxim A. Batalin, Gaurav S. Sukhatme

Presented by: Shawn Kristek

A robot has networked sensor nodes that it can deploy. These static nodes then suggest the least recent direction taken when visited.

i.e. An intelligent breadcrumb trail for robots

The Basic Idea

Problem DefinitionAlgorithmAnalysisSimulationsImplementationConclusions

Outline

Problem DefinitionAlgorithmAnalysisSimulationsImplementationConclusions

Outline

Quick FactsGoals

Coverage Exploration

Based on the deployment of static, communication-enabled, sensor nodes

No localization or mapsUnlimited active nodes assumed

Problem Definition

The NodesHeart of this workSimple computation

Sensing Small Processor

Simple communication Limited range radio

Forms a sensor network / support infrastructure – the breadcrumb trail

Problem Definition

The robotUses the nodes to solve the coverage

problemOnly uses local data from closest nodeGoal is to visit least recently visited (LRV)

node

Problem Definition

Robot visiting/dropping node

Forward moving robot

Problem DefinitionAlgorithm

AnalysisSimulationsImplementationConclusions

Outline

R = receive NODE_INFO messages from nodes in vicinity

if out of SHORT communication range with n then (nclosest, dclosest ) = node and corresponding direction in R with largest signal strength

if n ≠ NULL then

Send(UPDATE_DIR, nclosest, dclosest )Send(UPDATE_DIR, nclosest, Opposite(dclosest ))

else

deploy sensor node n ' with suggested direction d '

(nclosest, dclosest ) = (n ‘, d ‘)

if no obstacles detected in direction dclosest (n ,d ) = (nclosest, dclosest )

else

Send(UPDATE_DIR, nclosest , dclosest )Wait for response, repeat the check

if moving and obstacle detected ≤

OBSTACLE_AVOIDANCE_RANGE then

if obstacle is large and no nodes in vicinity

deploy sensor node n‘ with suggested direction d ‘ (n ,d ) = (n ‘, d ‘)

if obstacles detected in direction d then Send(UPDATE_DIR, n, d ) Wait for response, repeat the check

else

avoid the obstacle

if d = NULL then

Move in direction d

Algorithm

n, d – current node and suggested direction

R – set containing data received from nodes in robot’s vicinity (node id, signal strength, suggested direction);

SHORT – communication range threshold used to determine when to deploy new nodes;

Opposite(d) – function returning direction opposite to d

Robot

Repeat:

if received UPDATE_DIR message from robot with direction dupdate then

W (dupdate ) = W (dupdate ) +1

Send(NODE_INFO, n, ANY_OF(arg min∀ d Є D( i ) W (d )) )

Algorithm

n, d – current node and suggested direction

D(i)– set of direction incident to node i, the possible directions

W(d) – number of times direction d traversed from this node

ANY_OF(G) – function returns member of set G according to arbitrary rule; ex. ordered, or random

Node

What it does:Waits for updates and sends directions, based on updates.

LRV in Action Initially no nodes

- Robot starts by deployinga node

Next nodes deployed arenetworked to at least one other node

This continues indefinitely or until no new nodes are required

The robot then continually covers the environment

Algorithm

Problem DefinitionAlgorithm

AnalysisSimulationsImplementationConclusions

Outline

Graphs

Trees

Lattice

Note: The algorithm uses none of these. This is for analysis only.

Analysis

On GraphsTreat nodes as the vertices of a graph even

though no explicit adjacency lists are maintained at each node

Analyze the steady state

Analysis

n – current node the robot is atn’ – next node; the node the robot transitions to

while Cover/Explored the graph = FALSE don’ = ANY_OF(argmin j∀ ϵE(n) W(n, j ))W(n, n’ ) := W(n, n’ ) +1n := n’

On TreesComplete

The least weight edge is selectedTrees - graphs without cycles

Exploration time Θ(2|E|) or Θ(n)

Analysis

On a LatticeSpecial case graphWhy is this applicable?

- Implementation utilizes compass with k bits and 2k directions

- Analyze case of several equal W(e)

Analysis

What they found for a Square LatticeLRV coverage O(V1+Є)

Analysis

More ComparisonLRV1-LRTA*DFS

Analysis

n – current node the robot is atn’ – next node; the node the robot transitions to

while Cover/Explored the graph = FALSE don’ = ANY_OF(argmin j∀ ϵE(n) W( j ))W(n) := W(n’) +1n := n’

Convergence SpeedRWLRV1-LRTA*

Analysis

Square Lattice Assumptions DFS

All resources available- Nodes- Map- Localization- Perfect navigation

Limited number of simple nodes 1-LRTA*

Graph exploration algorithm Not purely local

Analysis

On a Cube Lattice

Analysis

Cube/Square LatticeOrdered selection instead of randomTie breakers – optimal time more likely

Analysis

1

2

3

4

Circle

1

23

4

Line

1 2

3

4

Cross

Effects of Order Choices – Cover Time Maps

Analysis

Random Cross

Line

Circle Circle

Darker – more time

Problem DefinitionAlgorithmsAnalysis

SimulationsImplementationConclusions

Outline

Follows Problem DefinitionPlayer / StagePioneer 2DX robots

1.5m,180˚ fov planar laser range finder Wireless communication

Simulations

Differences: Cover time – laser Noise

Problem DefinitionAlgorithmsAnalysisSimulations

ImplementationConclusions

Outline

Nodes Recommend direction The four cardinal directions; i.e. 2 bit compass Each direction - OPEN or EXPLORED OPEN first

Implementation

T – binary state (OPENED, EXPLORED)C – counter for a directionE – possible additional information

RobotBehavior-based decisions

Obstacles Node locations Node recommendations

Implementation

Problem DefinitionAlgorithmAnalysisSimulationsImplementation

Conclusions

Outline

Feasible applications Network repair/maintenance

Questionable Comparisons Graph algorithms???

Overall good results/ideas Coverage times less than O(n ln n) Self healing – dead nodes replaced Simple

Conclusions