Sie sind auf Seite 1von 26

Abstract

Energy harvesting devices are in rise now. These are devices that comes with low power
batteries that can be easily charged with small solar cells. Typically the specification of such
batteries are 50mWatt to 150mWatt. They are increasingly being used in sensor network as
sensor nodes need to remain active for longer period of time. However charring of the sensor
nodes is typically slower than the power usage due to excessive participation of the nodes in
routing and sensing. Henc esuitable techniques should be adopted for both routing as well as
data scheduling at the sensor nodes such that , nodes do not loose enough energy before they
are charged. In this work we propose a comprehensive routing and scheduling scheme for
energy harvesting sensor network that can optimize the power loss and increase the lifetime
of the network. We adopt: 1. Minimum spanning tree based routing 2) Shortest path based
routing and 3) Direct diffusion to obtain routes from different selected sensors to the sink
node. Sensor nodes do not send the data immidiately when they sense. Rather they wait for
specific period of time and then suitably schedule the data. We adopt a) Centralized
scheduling using Linear Programming b) Decentralized scheduling using flow graph ratio
over spanning tree. We compare all the techniques for energy loss and packet generated and
prove that decentralized and distributed scheduling yeilds better result.






Chapter 1
Preamble
1.1 Objective
Energy harvesting devices are typically low power. The intention behind using such devices
is that the devices would not need to replace batteries frequently. However due to excessive
operations by transmitter, receiver, sensor and processing circuits nodes loose more energy at
a unit time than they acquire. Further acquisition of energy differs in different times of the
day. Considering solar nodes, nodes charges faster at the day time than in nights. Therefore
nodes must adopt suitable techniques that enables them to restore their energy even when
they are not charging by suitably reducing the packet transmission and routing participation.
Therefore in this work our objective is to develop an efficient solution for energy harvesting
sensor network over different topologies that can easily sustain the gained energy throughput
the day. The object is also to analyze the concept for different routing techniques and for
diferent scheduling methods.
1.2 Statement of the Problem

Conventional sensor network works proposes lifetime maximization through different
approaches like clustering and wise routing. However energy harvesting nodes beg to differ
from the conventional sensor nodes in a way that they are low powered. Thus convention
techniques do not offer ample solution for the same. Therefore in this work we develop
centralized and distributed scheduling techniques for sensor network and test them for most
adopted routing techniques for sensor nodes. We prove that using decentralized technique
improves the network performance in terms of low energy dissipation and thus improve
lifetime.

1.3 Scope of the Work
More and more devices are now powered with alternative energy sources like wind power,
solar energy and so on. Charging of the cells takes longer time when power rating is higher.
Therefore such devices are lower power. Current work solves the puzzle of retaining
maximum energy of the nodes over a longer period of time and eliminate the need of battery
replacement in the nodes. Also using proper scheduling techniques can avoid network
congestion which results in lower number of retransmission. Therefore nodes do not loose
energy for overhearing or packet congestion. The work is also suitable to define routing
structure in the network. It can also be used for data aggregation in sensor network and
design a suitable scheduling for data aggregation.

1.4 Limitation
Scheduling techniques generally introduces delay in transmission. hence latency gets
increased. Some of the sensor networks are deployed for mission critical applications like
flood alarm. Current protocol can not be used for such networks.




Chapter 2
General Introduction
2.1 Basics of Sensor Network
2.2 Routing in Sensor Network
Directed Diffusion
Directed diffusion works by disseminating sensor tasks throughout the sensor network as an
interest for named data. The dissemination of the interest sets up time stamped gradients in the
network designed to draw data about events back to the originating node (the sink). When sensors
detect events matching the request the event is sent towards the originator along multiple paths.
The stored gradients give a direction and data rate and are used to determine the paths to be taken.
Initially the sink requests a low data rate from the network. Once the sink begins to receive data
back from the network it reinforces one or more paths with a higher data rate. The interest is
periodically refreshed with a new time stamp by the sink to keep the interest up to date.

Minimum Spanning Tree
Every computer program is based upon some kind of algorithms. Efficient algorithms will produce
efficient programs. Let us consider the minimal spanning tree problem. We believe that the reader
will quickly understand why it is so important to study algorithm design.
There are two versions of spanning tree problem. We will introduce one version of them first.
Consider Figure 2.1.

Figure 2.1: A Set of Planar Points

A tree is a graph without cycles and a spanning tree of a set of points is a tree consisting all of the
points. In Figure 2.2, we show three spanning trees of the set of points in Figure 2.1.

Figure 2.2: Three Spanning Trees of the Set of Points in Figure 2.1

Among the three spanning trees, the tree in Figure 2.2(a) is the shortestand this is what we are
interested. Thus the minimal spanning tree problem is defined as follows: We are given a set of
points and we are asked to find a spanning tree with the shortest total length.
How can we find a minimal spanning tree? A very straightforward algorithm is to enumerate all
possible spanning trees and one of them must be what we are looking for. Figure 2.3 shows all of the
possible spanning trees for three points. As can be seen, there are only three of them.

Figure 2.3: All Possible Spanning Trees for Three Points

For four points, as shown in Figure 2.4, there are sixteen 16 possible spanning trees. In general, it
can be shown that given n points, there are
2 n
n possible spanning trees for them. Thus if we have
5 points, there are already
3
5 = 125 possible spanning trees. If n = 100, there will be
98
100
possible spanning trees. Even if we have an algorithm to generate all spanning trees, time will not
allow us to do so. No computer can finish this enumeration within any reasonable time.

Figure 2.4: All Possible Spanning Tree for Four Points

Yet, there is an efficient algorithm to solve this minimal spanning tree problem. Let us first
introduce the Prim's Algorithm.

Prim's Algorithm

Consider the points in Figure 2.1 again. Suppose we start with any point, say point b. he nearest
neighbor of point b is point a. We now connect point a with point b , as shown in Figure 2.5(a). Let
us denote the set { } b a, as X and the set of the rest of points as Y. We now find the shortest
distance between points in X and Y which is that between between b and e, We add e to the minimal
spanning tree by connecting b with e, as shown in Figure 2.5(b). Now X = { } e b a , , and Y =
{ } f d c , , . During the whole process, we continuously create two sets, namely X and Y. X consists of
all of the points in the partially created minimal spanning tree and Y consists of all of the remaining
points. In each step of Prim's algorithm, we find a shortest distance between X and Y and add a new
point to the tree until Y is empty. For the points in Figure 2.1, the process of constructing a minimal
spanning tree through this method is shown in Figure 2.5.

Figure 2.5: The Process of Constructing a Minimal Spanning Thee Based upon Prims Algorithm

In the above, we assumed that the input is a set of planar points. We can generalize it so that the
input is a connected graph where each edge is associated with a positive weight. It can be easily
seen that a set of planar points corresponds to a graph where there is an edge between every two
vertices and the weight associated with each edge is simply the Euclidean distance between the two
pints. If there is an edge between every pair of vertices, we shall call this kind of graph a complete
graph. Thus a set of planar points correspond to a complete graph. Note that in a general graph, it is
possible that there is no edge between two vertices. A typical graph is now shown in Figure 2.6.
Throughout the entire book, we shall always denote a graph by G = (V,E) where V is the set of
vertices in G and E is the set of edges in G.

Figure 2.6: A General Graph

We now present Prim's algorithm as follows:

Algorithm 2.1 Prim's Algorithm to Construct a Minimal Spanning Tree
Input: A weighted, connected and undirected graph G = (V,E).
Output: A minimal spanning tree of G.
Step 1: Let x be any vertex in V. Let X = { } x and Y = V \ { } x
Step 2: Select an edge (u,v) from E such that X ue , Y ve and (u,v)has the smallest weight among
edges between X and Y.
Step 3: Connect u to v. Let { } v X X = and { } v Y Y \ = .
Step 4: If Y is empty, terminate and the resulting tree is a minimal spanning tree. Otherwise, go to
Step 2.

Let us consider the graph in Figure 2.7. he process of applying Prim's algorithm to this graph is now
illustrated in Figure 2.8.

Figure 2.7: A General Graph


Figure 2.8: The Process of Applying Prims Algorithm to the Graph in Figure 2.7

We will not formally prove the correctness of Prim's algorithm. The reader can find the proof in
almost every textbook on algorithms. Yet, now we can easily see the importance of algorithms. If
one does not know the existence of such an efficient algorithm to construct minimal spanning trees,
one can never construct minimal spanning trees if the input size is large. It would be disastrous for
any one to use an exhaustive search method in this case.
In the following, we will introduce another algorithm to construct a minimal spanning tree. This
algorithm is called Kruskal's algorithm.

Kruskal's Algorithm

Kruskal's algorithm to construct a minimal spanning tree is quite similar to Prim's algorithm. It would
first sort all of the edges in the graph into an ascending sequence. Then edges are added into a
partially constructed minimal spanning tree one by one. Each time an edge is added, we check
whether a cycle is formed. If a cycle is formed, we discard this edge. The algorithm is terminated if
the tree contains n-1 edges.

Algorithm 2.2 Kruskal's Algorithm to Construct a Minimal Spanning Tree
Input: A weighted, connected and undirected graph G = (V,E).
Output: A minimal spanning tree of G.
Step 1: | = T .
Step 2: while T contains less than n-1edges do
Choose an edge (v,w) from E of the smallest weight.
Delete (v,w) from E.
If the adding of (v,w)does not create cycle in T then
Add (v,w) to T.
Else Discard (v,w).
end while

Let us consider the graph in Figure 2.7. The process of applying Kruskal's algorithm to this graph is
illustrated in Figure 2.9.
Both algorithms presented above are efficient.


Figure 2.9: The Process of Applying Kruskals Algorithm to the Graph in Figure 2.7

Flooding
In the flooding protocol each node receiving a data or management packet repeats the
packet by broadcasting it. Only packets which are destined for the node itself or packets whose hop
count has exceeded a preset limit are not forwarded.

The main benefit of flooding is that it requires no costly topology maintenance or
route discovery. Once sent a packet will follow all possible routes to its destination. If the network
topology changes sent packets will simply follow the new routes added. Flooding does however have
several problems. One such problem is implosion. Implosion is where a sensor node receives
duplicate packets from its neighbors. Figure 2.3a illustrates the implosion problem. Node A
broadcasts a data packet ([A]) which is received by all nodes in range (nodes B and C in this case).
These nodes then forward the packet by broadcasting it to all nodes within range (nodes A and D).
This results in node D receiving two copies of the packet originally sent by node A. This can result in
problems determining if a packet is new or old due to the large volume of duplicate packets
generated when flooding. Overlap is another problem which occurs when using flooding. If two
nodes share the same observation region both nodes will witness an event at the same time and
transmit details of this event. This results in nodes receiving several messages containing the same
data from different nodes. Figure 2.3b illustrates the overlap problem. Nodes A and B both monitor
geographic region Y.
When nodes A and B flood the network with their sensor data node C receives two copies of
the data for geographic region Y as it is included in both packets. Another problem with flooding is
that the protocol is blind to available resources. Messages are sent and received by a node
regardless of how much power it has available. In addition to this the number of packets generated
by the flooding protocol causes a lot of network traffic and causes a large network wide energy drain
across the network. This can shorten the life of the network.

Figure 2.3a: The Implosion problem Figure 2.3b: The Overlap problem




Dijkstra's Algorithm

This algorithm finds the shortest path from a source vertex to all other vertices in a weighted
directed graph without negative edge weights.

Here is the algorithm for a graph G with vertices V = {v
1
, ... v
n
} and edge weights w
ij
for an
edge connecting vertex v
i
with vertex v
j
. Let the source be v
1
.

Initialize a set S = C. This set will keep track of all vertices that we have already computed
the shortest distance to from the source.

Initialize an array D of estimates of shortest distances. D[1] = 0, while D[i] = , for all other
i. (This says that our estimate from v
1
to v
1
is 0, and all of our other estimates from v
1
are
infinity.)

While S != V do the following:
1) Find the vertex (not is S) that corresponds to the
minimal estimate of shortest distances in array D.
2) Add this vertex, v
i
into S.
3) Recompute all estimates based on edges emanating
from v. In particular, for each edge from v, compute
D[i]+w
ij
. If this quantity is less than D[j], then set
D[j] = D[i]+w
ij
.







Essentially, what the algorithm is doing is this:

Imagine that you want to figure out the shortest route from the source to all other vertices.
Since there are no negative edge weights, we know that the shortest edge from the source to
another vertex must be a shortest path. (Any other path to the same vertex must go through
another, but that edge would be more costly than the original edge based on how it was
chosen.)

Now, for each iteration, we try to see if going through that new vertex can improve our
distance estimates. We know that all shortest paths contain subpaths that are also shortest
paths. (Try to convince yourself of this.) Thus, if a path is to be a shortest path, it must build
off another shortest path. That's essentially what we are doing through each iteration, is
building another shortest path. When we add in a vertex, we know the cost of the path from
the source to that vertex. Adding that to an edge from that vertex to another, we get a new
estimate for the weight of a path from the source to the new vertex.

This algorithm is greedy because we assume we have a shortest distance to a vertex before
we ever examine all the edges that even lead into that vertex. In general, this works because
we assume no negative edge weights. The formal proof is a bit drawn out, but the intuition
behind it is as follows: If the shortest edge from the source to any vertex is weight w, then any
other path to that vertex must go somewhere else, incurring a cost greater than w. But, from
that point, there's no way to get a path from that point with a smaller cost, because any edges
added to the path must be non-negative.

By the end, we will have determined all the shortest paths, since we have added a new vertex
into our set for each iteration.
This algorithm is easiest to follow in a tabular format.

The adjacency matrix of an example graph is included below. Let a be the source vertex.

a b c d e
a 0 10 inf inf 3
b inf 0 8 2 inf
c 2 3 0 4 inf
d 5 inf 4 0 inf
e inf 12 16 13 0

Here is the algorithm:

Estimates b c d e
Add to Set
a 10 inf inf 3
e 10 19 16 3
b 10 18 12 3
d 10 16 12 3

We changed the estimates to c and d to 19 and 16 respectively since these were
improvements on prior estimates, using the edges from e to c and e to d. But, we did NOT
change the 10 because 3+12, (the edge length from e to b) gives us a path length of 15, which
is more than the current estimate of 10. Using edges bc and bd, we improve the estimates to
both c and d again. Finally using edge dc we improve the estimate to c.







Now, we will prove why the algorithm works. We will use proof by contradiction. After each
iteration of the algorithm, we "declare" that we have found one more shortest path. We will
assume that one of these that we have found is NOT a shortest path.

Let t be the first vertex that gets incorrectly placed in the set S. This means that there is a
shorter path to t than the estimate produced when t is added into S. Since we have considered
all edges from the set S into vertex t, it follows that if a shorter path exists, its last edge must
emanate from a vertex outside of S to t. But, all the estimates to the edges outside of S are
greater than the estimate to t. None of these will be improved by any edge emanating from a
vertex in S (except t), since these have already been tried. Thus, it's impossible for ANY of
these estimates to ever become better than the estimate to t, since there are no negative edge
weights. With that in mind, since each edge leading to t is non-negative, going through any
vertex not in S to t would not decrease the estimate of its distance. Thus, we have
contradicted the fact that a shorter path to t could be found. Thus, when the algorithm
terminates with all vertices in the set S, all estimates are correct.

Try an example your self on the graph with the following adjacency matrix using a as the
source.


a b c d e
a 0 3 4 inf inf
b inf 0 inf 6 8
c inf 2 0 1 5
d inf inf inf 0 2
e inf inf inf inf 0
Path Reconstruction in Dijkstra's Algorithm

Given the history of the values in the distance estimate array, we can trace the shortest path.
In the example below, consider determining the shortest distance from a to c:

Estimates b c d e
Add to Set
a 10 inf inf 3
e 10 19 16 3
b 10 18 12 3
d 10 16 12 3

When we updated the estimate to c to be 16, we added vertex d. This means that the last edge
of the path was d -> c. Now, go to the column for d. We see that d's distance was updated
when we added b to the set S. Thus, the last edge of the shortest path from a to d is the edge
d->b. Finally, we go to the column for b and find that the shortest distance to b is obtained by
the edge a->b. Thus, putting everything together, we have the path a->b->d->c.

Consider if we had filled out the chart as follows:

Estimates b c d e
Add to Set
a 10/a inf inf 3/a
e 10/a 19/e 16/e 3/a
b 10/a 18/b 12/b 3/a
d 10/a 16/d 12/b 3/a

When we update a estimate, we ALSO update which vertex got us there. When we finish, we
just need the information on the last row to reconstruct any shortest path from a.
2.3 Energy Harvesting sensor network
Wireless distributed microsensor systems will enable fault tolerant monitoring and
control of a variety of appli-cations. Due to the large number of microsensor nodes that
may be deployed and the long required system lifetimes, replacing the battery is not an
option. Sensor systems must utilize the minimal possible energy while operating over a
wide range of operating scenarios. This paper presents an overview of the key technolo-
gies required for low-energy distributed microsensors.These include power aware
computation communication component technology, low-energy signaling and
networking, system parti-tioning considering computation and communication trade-offs,
and a power aware software infrastructure.
The design of micropower wireless sensor systems has gained increasing
importance for a variety of civil and military applications. With recent advances in
MEMS technology and its associated interfaces, signal processing, and RF circuitry, the
focus has shifted away from limited macrosensors communicating with base stations to
creating wireless networks of communicating microsensors that aggregate complex data
to provide rich, multi-dimensional pictures of the environment. While individual
microsensor nodes are not as accurate as their macrosensor counterparts, the networking
of a large number of nodes enables high quality sensing networks with the additional
advantages of easy deployment and faulttolerance. These characteristics that make
microsensorsideal for deployment in otherwise inaccessible environmentswhere
maintenance would be inconvenient or impossible.
The potential for collaborative, robust networks of microsensors has attracted a great
deal of research attention. The WINS and PicoRadio and projects, for instance, aim to
integrate sensing, processing and radio communication onto a microsensor node. Current
prototypes are custom circuit boards with mostly commercial, off-the-shelf components.
The Smart Dust project seeks a minimum-size solution to the distributed sensing
problem, choosing optical communication on coin-sized motes. The prospect of
thousands of communicating nodes has sparked research into network protocols for
information flow among microsensors, such as directed diffusion [7].The unique
operating environment and performance requirements of distributed microsensor
networks require fundamentally new approaches to system design. As an
example,consider the expected performance versus longevity of the microsensor node,
compared with current battery-powered portable devices.

Fig1.1-wireless sensor network
The node, complete with sensors, DSP, and radio, is capable of a tremendous
diversity of functionality.Throughout its lifetime, a node may be called upon to be a data
gatherer, a signal processor, and a relay station. Its lifetime, however, must be on the
order of months to years, since battery replacement for thousands of nodes is not an
option. In contrast, much less capable devices such as cellular telephones are only
expected to run for days on a single battery charge. High diversity also exists within the
environment and user demands upon the sensor network. Ambient noise in the
environment, the rate of event arrival, and the users quality requirements of the data may
vary considerably over time. A long node lifetime under diverse operating conditions
demands power-aware system design. In a power-aware design, the nodes energy
consumption displays a graceful scalability in energy consumption at all levels of the
system hierarchy, including the signal processing algorithms, operating system, network
protocols, and even the integrated circuits themselves. Computation and

Fig-wireless sensor network with gateway sensor node
communication are partitioned and balanced for minimum energy consumption. Software that
understands the energy-quality tradeoff collaborates with hardware that scales its own energy
consumption accordingly.








Chapter 3
Related Work















Chapter 4
System Analysis
4.1 Present System
Enenrgy harvesting sensor network is relatively new concept and not many proposals have
suitably offered solutions for this. Most of the conventional techniques offers wither 1) An
energy aware route 2) Cluster based Solutions and 3) Scheduling Techniques
Existing work had the objective of minimizing the completion time of converge casts.
However, none of the previous work discussed the effect of multi-channel scheduling
together with the comparisons of different channel assignment techniques and the impact of
routing trees and none considered the problems of aggregated and raw converge cast, which
represent two extreme cases of data collection,

4.2 Proposed SYstem
Even though the main objective here is to analyze the effect of Centralized and decentralized
scheduling, we emphesize on appropriate scheduling techniques over tree based network. i.e.
Scheduling for minimum spanning tree.
Many wireless sensor networks (WSNs) employ battery-powered sensor nodes.
Communication in such networks is very taxing on its scarce energy resources. Convergecast
process of routing data from many sources to a sink is commonly performed operation in
WSNs. Data aggregation is a frequently used energy-conversing technique in WSNs. The
rationale is to reduce volume of communicated data by using in-network processing
capability at sensor nodes. In this paper, we address the problem of performing the operation
of data aggregation enhanced convergecast in an energy and latency efficient manner. We
assume that all the nodes in the network have a data item and there is an a priori known
application dependent data compression factor (or compression factor), c, that approximates
the useful fraction of the total data collected.
One is a variant of the Minimum Spanning Tree (MST) algorithm and the other is a variant of
the Single Source Shortest Path Spanning Tree (SPT) algorithm. These two algorithms serve
as a motivation for our Combined algorithm which generalized the SPT and MST based
algorithm.
The algorithm tries to construct an energy optimal tree for any fixed value of a (= 1 _ c), the
data growth factor. The nodes of these trees are scheduled for collision-free communication
using a channel allocation algorithm. To achieve low latency, these algorithms use the b-
constraint, which puts a soft limit on the maximum number of children a node can have in a
tree. The tree obtained from energy minimizing phase of tree construction algorithms is
restructured using the b-constraint (in the latency minimizing phase) to reduce latency (at the
expense of increasing energy cost). The effectiveness of these algorithms is evaluated by
using energy efficiency, latency and network lifetime as metrics. With these metrics, the
algorithms performance is compared with an existing data aggregation technique. From the
experimental results, for a given network density and data compression factor c at
intermediate nodes, one can choose an appropriate algorithm depending upon whether the
primary goal is to minimize the latency or the energy consumption.










Chapter 5
System Design












5.2 DLEG
5.3 DLEX
5.4 Implementation
Explain Matlab code Here



Sensor nodes
Spanning Tree
Shortest Path
Directed Diffusion,
Flooding
Data Acquiring
Energy Harvesting
Flow Based Scheduling LP Based Scheduling
Sink
Scheduling Control
Chapter 6
Results and Discussion




















Chapter 7
Conclusion