You are on page 1of 64

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

1. INTRODUCTION
1.1 GENERAL OVEREVIEW OF THE PROJECT Wireless sensor networks are emerging as an important domain of research in field of Information Technology which involve hardware and system design, networking, distributed algorithms, programming models, data management and security. A wireless sensor network (WSN) is a computer network consisting of spatially distributed autonomous devices using sensors to cooperatively monitor physical or environmental conditions, such as temperature, sound, vibration, pressure, motion or pollutants, at different locations. WSNs were motivated by its first use in military applications such as battlefield surveillance but now they are used in many civilian application areas such as environmental and habitat monitoring, health care applications, home automation, and traffic control. A node in a wireless sensor network is very constrained in terms of energy, computational power and memory. Also in a deployed wireless sensor network the number of nodes run in factors of hundreds and thousands so it become a very tough job to route the information through the network keeping in mind the limited resources available with the nodes. Events such as sensing data, computation, storing data and receiving and forwarding of data from node to node of node to base station are energy consuming tasks. But most of the energy consumed is by the radio transmission and data computation. So it is very much desirable that the routing protocols designed and implemented for a wireless sensor networks are efficient in terms of energy consumption as it helps in extending the life of the WSN to longer periods.

SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY

Page 1

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

1.2 LITERATURE SURVEY

1.2.1 WSN Node Architecture


A wireless sensor networks consists of tiny sensor nodes which are electronic devices equipped with a sensor, a transceiver, a microcontroller, and an analog to digital converter. The sensor is used to sense the environment and capture the sensed data and provide it to the microcontroller through the ADC(analog to digital converter). The microcontroller performs some basic computations like aggregation of data etc. and stores it .The information is transmitted to other nodes through a wireless radio transmitter. The nodes in the network have very limited computational, memory and energy capacity. All the operations of the node are performed using the limited battery energy which may not be recharged. When the energy gets depleted completely the node is not able to function and it dies. The following figure describes the architecture of a typical WSN node:

Fig 1: A typical WSN node

SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY

Page 2

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

1.2.2 WSN Topologies


The development and deployment of wireless sensor networks(WSN) have taken the traditional network topologies in new directions. Many of todays sensor applications require networking alternatives that reduce the cost and complexity while improving the overall reliability. This section briefly describes four basic types of common wireless sensor data network topologies. i. Peer-to-Peer: Peer-to-peer networks allow each node to communicate directly with another node without needing to go through a centralized communications hub. Each peer device is able to function as both a client and server to other nodes on the network. An example of peer-to-peer network is shown in figure below.

Fig 2: a peer-to-peer network.

ii.

Star topology: Star networks are connected to a centralized communications hub. Each node cannot communicate directly with one another; all communications must be routed through the centralized hub. Each node is then a client while the central hub is the server. An example of a star network is shown in the figure below:

SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY

Page 3

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

Fig 3: a star network.

iii.

Tree Topology: Tree networks use a central hub called root node as the main communications router. One level down from the root node in the hierarchy is a central hub. This lower level then forms a star network. The tree network can be considered a hybrid of both the star and peer-to-peer networking topologies. An example of a tree network is shown in the figure below:

Fig 4: a Tree network.

SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY

Page 4

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

iv.

Mesh Topology: Mesh networks allow data to hop from node to node, this allows the network to be self-healing. Each node is then able to communicate with each other as the data is routed from node to node until it reaches the desired location. An example of a Mesh network is shown in the figure below. This type of network is one of the most complex and can cost a significant amount of money to deploy properly.

Fig 5: a Mesh network.

1.2.3 WSN Applications


Wireless sensor networks found their first use in the military for battlefield surveillance. Since then, WSNs are used in varied areas as listed below: i. Military applications a. Battlefield surveillance b. Information collection. c. Enemy tracking d. Target classification. SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY Page 5

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

ii.

Environmental monitoring a. Temperature monitoring b. Rain monitoring c. Pressure monitoring d. Weather monitoring e. Fire and smoke detection. f. Structural monitoring. g. Habitat monitoring. h. Agriculture monitoring

iii.

Support for logistics a. Inventory control. b. Asset tracking with RF ID tags. c. Anti-theft detection systems.

iv. v.

Application to robotics. Health care monitoring.

and many more. The possible use of wireless sensor networks extends over a vast area of human activity. Although most of the applications are still under research and few completed products or services have become available for public use, there is remarkable effort and progress.

1.3 ORGANISATION OF THE REPORT Being a study based project most of the points relevant to software engineering principles do not apply here but i have tried to illustrate the portions where any software engineering methodology has been applied. Thus the report contains relevant categories such as brief introduction of routing protocols, OMNET++ simulator introduction and implementation details and conclusion.

SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY

Page 6

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

2. STUDY OF ROUTING PROTOCOLS

Routing protocols are concerned with how a node communicates with any other node in a network. When a node wants to send a packet to some destination node, which path is followed is determined by the routing protocols. The routing technique is implemented in the network layer of a network communication model like ISO-OSI or TCP/IP. So routing may be defined as a process by which a node sends information messages or packets to any destination node through zero or more intermediate nodes.

2.1 Design Issues


In case of wireless sensor networks, design and implementation of routing protocols are the most important factor in determining the success of the WSN deployed. A wireless sensor network is a form of wireless ad-hoc network and as such they have very limited power resources, limited computational capabilities, limited communication capabilities and limited memory. So the routing protocols for the WSNs must be designed keeping these issues in mind.

i.

Fault Tolerance: the failure of a sensor node should not affect the overall task of the sensor network.

ii.

Scalability: the number of sensor nodes deployed in a region may be in order of hundreds or thousands or more and routing schemes must be scalable enough to respond to events.

iii.

Power Consumption: the transmission power of a wireless radio is proportional to distance squared or even higher order in presence of obstacles. Sensor nodes are equipped with limited power and node lifetime is strongly dependent on its battery lifetime.

iv.

Data Delivery Models: depending on the application of the WSN the data delivery model to the sink can be continuous, event-driven, Query-driven or hybrid. In continuous delivery model, each sensor sends data periodically. In event-driven SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY Page 7

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

models, the transmission of data is triggered when an event occurs. In query-driven model, the transmission is triggered when the sink generates some query. v. Data Aggregation: sensor nodes might generate redundant data and so similar packets from multiple nodes can be aggregated so that transmissions would be reduced. This computation will cost less energy consumption than required for transmission of redundant packets each time and such substantial energy savings can be made. vi. Quality of Service (QoS): it means the quality service required by the application, it could be the length of life time, data reliability, location awareness etc. These factors affect the selection of a routing protocol for particular application. For example: In military applications it may be required that data be delivered within a certain period of time it is sensed. vii. Data Latency and Overhead: data aggregation and multi-hop relays cause data latency. Some routing protocols also create excessive overheads to implement their algorithms, which are not suitable for serious energy constrained networks. viii. Node Deployment: the node deployment is either deterministic or self-organising. In deterministic situations the sensors are manually placed and data is routed through pre-determined paths. In self organising systems, the sensor nodes are scattered randomly creating an ad-hoc infrastructure. In that infrastructure the position of the sink or cluster head is crucial in terms of energy efficiency and performance.

2.2 Classification of WSN Routing Protocols:


In general, there are three categories of routing algorithm in Wireless Sensor networks depending on the network structure:

1. Flat based routing. 2. Cluster based routing, and 3. Location based routing.

SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY

Page 8

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

In flat based routing, all the nodes in the network have equal roles. The all perform the same job of sensing and gathering data.

In cluster based routing, different nodes play different roles in the network. Some nodes are only meant to sense the data and some nodes have the job to process and send the information.

In location based routing, nodes location in the network is used as a means for effective routing. The distance between nodes are measured based on their incoming signal strength and the appropriate route decided on that basis.

On basis of protocol operation the routing for WSN can be classified into the following:

1. Query-based. 2. Negotiation-based. 3. Multipath-based. 4. QoS based 5. Coherent-based

A routing algorithm can be adaptive if certain system parameters can be changed to adapt to the current network conditions.

In query based routing the destination node send a query of data to the network. The node which has the requested data sends the data back as per the query to the node that initiated the query.

In negotiation based routing high level data descriptors are used in order to eliminate redundant data transmissions through negotiations.

SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY

Page 9

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

In multipath based routing, multiple paths are maintained and used between the source and the destination.

In QoS based routing, the quality of service is maintained by balancing between the data quality and the energy consumption.

In coherent based routing, data processing is a major component in the operation of wireless sensor networks.

Direct Routing : This is the simplest way of routing which falls under flat based routing category. In this routing protocol each node directly communicates with the base node. But this technique although has optimal accuracy, is unrealistic in real world applications as the base has only limited number of channels to communicate with the sensor nodes. Also the communication distance of a sensor node is limited so over a large area where the nodes are very far this method cannot be applied successfully.

Multi-hop Routing: Due to the limitations in the direct routing approach, multi-hop routing is used to communicate with the base station. Here the data travels from source to destination through one or more intermediate nodes. This ensures that nodes in the network die slow as compared to the direct approach and also that the data reaches the base station.

2.3 Comparison of Routing Protocols:


In this section one protocol for each routing category is listed and summarized:

2.3.1

Flat based routing :

In flat based routing each node plays the same role and sensor nodes collaborate together to perform sensing task. Due to large number of such nodes it is not feasible to assign a global identifier to each node. This consideration has led to data-centric routing, where SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY Page 10

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

the base station sends queries to certain regions and waits for the data from the sensors located in the selected regions. Since data is being requested through queries, attribute based naming is necessary to specify the properties of data. SPIN and Directed Diffusion are two of the data centric flat based routing protocols that have motivated the design of many other similar protocols.

Sensor Protocols for Information via Negotiation (SPIN): In this protocol the information at each node is disseminated to every other node in the network assuming that all the nodes are potential base stations. This enables user to query any node and get the required information immediately. These protocols make use of the property that nodes in close proximity have similar data, and hence there is a need to only distribute the data that other nodes do not posses. Nodes running SPIN assign a high level name to completely describe their collected data (called meta-data) and perform meta-data negotiations before any data is transmitted. This assures that there is no redundant data sent throughout the network. One of the advantages of SPIN is that topological changes are localized since each node needs to know only its single hop neighbours. It provides much energy saving than flooding and meta-data negotiations almost halves the redundant data. However SPIN data advertisement mechanism cannot guarantee the delivery of data. To see this, consider the application of intrusion detection where data should be reliably reported over periodic intervals and assume that nodes in the data are located far away from the source node and the nodes between source and destination nodes are not interested in that data, such data will not be delivered to the destination at all.

2.3.2

Hierarchical routing :

Concept of hierarchical routing is also utilized to perform energy efficient routing in WSNs. In hierarchical architecture, the higher energy nodes can be used to process and send the information while low energy nodes can be used to perform the sensing in the proximity of the target. This means that creation of clusters and assigning special tasks to the cluster heads can greatly contribute to overall system scalability, lifetime, and energy SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY Page 11

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

efficiency. Hierarchical routing is mainly two layer routing where one layer is used to select cluster heads and the other layer is used for routing. However, most techniques in this category are not about routing, rather on who and when to send or process/aggregate the information, channel allocation. LEACH protocol is the foremost protocol in this category and has inspired many routing protocols designed and improved upon it.

Low Energy Adaptive Clustering Hierarchy (LEACH): It is a hierarchical protocol in which most nodes transmit to cluster heads, and the cluster heads aggregate and compress the data and forward it to the base station. Each node uses stochastic algorithm at each round to determine whether it will become a cluster head in this round. LEACH assumes that each node has a radio powerful enough to directly reach the base station or the nearest cluster head, but that using this radio at full power all the time would waste energy. Nodes that have been cluster heads cannot become cluster heads again for P rounds, where P is the desired percentage of cluster heads. Thereafter each node has a 1/P probability of becoming the cluster head in each in each round. At the end of each round, each node that is not a cluster head selects the closest cluster head and joins the cluster. The cluster head then creates a schedule for each node in its cluster to transmit its data. All nodes that are not cluster heads only communicate with the cluster head in TDMA ( Time Division Multiple Access ) fashion, according to the schedule created by the cluster head. They do so using the minimum energy needed to reach the cluster head, and only need to keep their radios on during their time slot.

The operation of LEACH is separated in two phases : i). The setup phase and ii). The steady state phase. In setup phase the clusters are organised and the cluster heads are selected. In the steady state phase the actual data transfer to the base station takes place.

SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY

Page 12

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

i). The setup phase:

During this phase a predetermined fraction of nodes, P, elect themselves as cluster heads as follows.

A sensor node chooses a random number , r, between 0 and 1. If this random number is less than a threshold value, T(n), the node becomes the cluster head for the current round. The threshold value is calculated based on a equation that incorporates the desired percentage to become a cluster head, the current round, and the set of nodes that have not been selected as a cluster head in the last (1/P) rounds, denoted by G. It is given by: ( ) ( ( ( )) , if n G.

Where G, is the set of nodes that are involved in cluster head election. Each selected cluster head broadcast an advertisement message to the rest of the nodes in the network that they are the new cluster heads. All the non- cluster head nodes, after receiving this advertisement decide in the cluster to which they want to belong to. This decision is based in the signal strength of the advertisement. The non-cluster head nodes inform the cluster heads that they will be a member of the cluster. After receiving all the message from the nodes that would like to be included in the cluster and based on the number of nodes in the cluster, the cluster head node creates a TDMA schedule and assigns each node a time slot when it can transmit. This schedule is broadcast to all nodes in the cluster.

ii). The steady state phase: during this phase, the sensor nodes can begin sensing and transmitting data to the cluster heads. The cluster head node, after receiving all the data, aggregates it before sending it to the base station. After a certain time which is determine a priori, the network goes back into the setup phase again and enters another round of selecting new cluster head. Each cluster communicates using different CDMA codes to reduce interference from nodes belonging to other clusters.

SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY

Page 13

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

Although the LEACH protocol acts in a good manner, it suffers from many drawbacks such as: 1. Cluster head selection is done randomly, that does not take into account energy consumption. All node start with equal energy residual levels. 2. It cannot cover a large area. LEACH assumes that all nodes can transmit with enough power to reach the base station if needed and each node has computational power to support different MAC protocols. 3. It also assumes that nodes always have data to send, and nodes located close to each other have correlated data. 4. Cluster heads are not uniformly distributed; whereas the cluster heads can be located at the edges of the cluster. It may also lead to concentration of cluster-head in one area of the network. 5. It is not efficient for large scale networks. 6. Fixed percentage of cluster-heads for any size networks. 7. It assumes that all nodes can communicate over one hop(directly) with the base station.

Fig 6: LEACH protocol architecture.

SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY

Page 14

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

2.3.3 Location based routing:

In this kind of routing sensor nodes are addressed by means of their locations. The distance between the neighbouring nodes can be estimated on the basis of incoming signal strengths. Relative coordinates of neighbouring nodes can be obtained by exchanging such information between neighbours. Alternatively the location of nodes may be available directly by communicating with a satellite, using GPS (Global Positioning System), if nodes are equipped with small low power GPS receiver. To save energy, some location based schemes demand that nodes should go to sleep when there is no activity. SPAN, GEAR, GAF are some examples of geographical routing protocols.

Geographic and Energy Aware Routing (GEAR) : the key idea in GEAR is to restrict the number of interests in directed diffusion by only considering a certain region rather than sending the interests to the whole network. By doing this GEAR can conserve more energy than directed diffusion. Each node in GEAR keeps an estimated cost and a learning cost of reaching the destination through its neighbours. The estimated cost is a combination of residual energy and distance to the destination. The learned cost is a refinement of the estimated cost that accounts for routing around holes in the network. A hole occurs when a node does not have any close neighbour to the target region than itself. If there are no holes, the estimated cost is equal to the learned cost. There are two phases in the algorithm: 1. Forwarding packets towards the target region: upon receiving a packet a node checks its neighbours to see if there is one neighbour, which is closer to the target region then itself. If there is more than one, the nearest neighbour to the target region is selected as the next hop. If they are all further than the node itself, this means there is a hole. In this case one of the neighbours is picked to forward the packet based on learning cost function.

2. Forwarding the packets within the region: If the packet has reached the region, it can be diffused in that region by either recursive geographic forwarding or restricted flooding. Restricted flooding is good when the sensors are not densely deployed.

SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY

Page 15

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

3. A BRIEF INTRODUCTION OF OMNET++


OMNET++ is an object-oriented modular discrete event network simulator. The simulator can be used for: Traffic modelling of telecommunication networks Protocol modelling Modelling queuing networks. Modelling multiprocessors and other distributed hardware systems. Validating hardware architectures. Evaluating performance aspects of complex software systems. Modelling any other system where discrete event approach is suitable.

OMNET++ provides the basic machinery and tools to write simulations, but itself it does not provide any components specifically for computer network simulations, queuing network simulations, system architecture simulations or any other area. Instead these application areas are supported by various simulation models and frameworks such as the Mobility Framework and the INET Framework. These models are developed completely independently of OMNET++, and follow their own release cycles. An OMNET++ model consists of hierarchically nested modules. The depth of module nesting is not limited, which allows the user to reflect the logical structure of the actual system in the model structure. Modules communicate through message passing. Messages can contain arbitrarily complex data structures. Modules can send messages either directly to their destination or along a predefined path, through gates and connections. Modules can have their own parameters. Parameters can be used to customize module behaviour and to parameterize the models topology.

SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY

Page 16

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

Modules at the lowest level of the module hierarchy encapsulate behaviour. These modules are termed simple modules, and they are programmed in C++ using the simulation library. OMNET++ simulations can feature varying user interfaces for different purposes: debugging, demonstration and batch execution. Advanced user interfaces make the inside of the model visible to the user, allow control over simulation execution and to intervene by changing variables/objects inside the model. This is very useful in the development/debugging phase of the simulation project. User interfaces also facilitate demonstration of how a model works. The simulator as well as user interfaces and tools are portable: they are known to work on windows and on several Unix flavours, using various C++ compilers. Hierarchical Modules An OMNET++ model consists of hierarchically nested modules, which communicate by passing messages to each other. OMNET++ models are often referred to as networks. The top level module is the system module. The system module contains submodules, which can also contain submodules themselves. The depth of the module nesting is not limited, this allows user to reflect the logical structure of the actual system in the model structure. Model structure is described in OMNET++s NED language.

Both simple and compound modules are instances of module types. While describing the model, the user defines module types; instances of these module types serve as components for more complex module types. Finally, the user creates the system moduls

SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY

Page 17

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

as an instance of a previously defined module type; all modules of the network are instantiated as submodules and sub-submodules of the system modules. When a module type is used as a building block, there is no distinction whether it is a simple or a compound module. This allows the user to split a simple module into several simple modules embedded into a compound module, or vice versa, aggregate the functionality of a compound module into a single module, without affecting existing users of the module type. Messages, Gates and Links Modules communicate by exchanging messages. In actual simulation messages can represent frames or packets in a computer network, jobs or customers in a queuing network or other types of mobile entities. Messages can contain arbitrarily complex data structures. Simple modules can send messages either directly to their destination or along a predefined path, through gates and connections. The local simulation time of a module advances when the module receives a message. The message can arrive from another module or from the same module( self messages are used to implement timers). Gates are the input and output interfaces of the modules; messages are sent through output gates and arrive through input gates. Each connection(also called link) is created within a single level of the module hierarchy. Within a compound module, one can connect the corresponding gates of two submodules, or a gate of one submodule and a gate of the compound module.

Fig 7: submodules connected to each other

submodules connected to parent module.

SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY

Page 18

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

The simple modules of a model contain algorithms as C++ functions. The full flexibility and power of the programming language can be used, supported by the OMNET++ simulation class library. The simulation programmer can chose between event-driven and process-style description, and can freely use object-oriented concepts and design patterns to extend the functionality of the simulator. Simulation objects(messages, modules, queues) are represented by the C++ classes. They have been designed to work together efficiently creating a powerful simulation programming framework. The following classes are part of the simulation class library: Modules, gates, connection etc. Parameters Messages Container classes(e.g. queue, array) Data collection classes Static and distribution estimation classes( histograms, P2 algorithm for calculating quantities etc.) Transient detection and result accuracy detection classes

The classes are also instruments, allowing one to traverse objects of a running simulation and display information about them such as name, class name, state variables or contents. This feature has made it possible to create a simulation GUI where all internals of the simulation are visible. Compound Modules Parameters and gates for compound modules are declared and work in the same way as with the simple modules. Typically, compound module parameters are passed to submodules and used for initializing their parameters. Parameters can also be used in defining the internal structure of the compound module: the number of submodules and iszes of gate vectors can b defines with th help of parameters, and parameters can also be used in defining the connections inside the

SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY

Page 19

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

compound module. As a practical example, you can create a router compound module with a variable number of ports, specified in a numOfPorts parameter. Parameters affecting the internal structure should always be declared const, so that accessing them always yields same value. Otherwise, if a parameter was assigned a random value, one could get a different value each time the parameter is accessed during building the internals of the compound module, which is surely not what was meant. Example: Module Router parameters: packetsPerSecond: numeric, bufferSize: numeric, numOfPorts: const; gates: in: inPort[]; out: outPort[]; submodules:// connections:// endmodule

SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY

Page 20

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

4. IMPLEMENTATION OF LEACH

This section presents a detailed implementation code for the SolarLeach- LeachFarBs which improves upon the classic LEACH code by introducing solar nodes to increase the life of the network in whole. The section is divided into two parts : the NED description for different modules and the C++ implementation code for the modules.

4.1 Network Topology Description(NED):

1.

node.ned simple Node parameters: id: const, energy, sunstart, xpos: const, ypos: const; gates: in: in[]; out: out[]; endsimple

2. bs.ned simple B parameters: id: const, xpos: const, ypos: const; gates: in: in[]; out: out[]; endsimple

SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY

Page 21

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

3. solar.ned import "node", "bs"; module Solar parameters: numNodes: numeric, trRange: numeric, rounds: numeric, frames: numeric, solarOn: numeric, sunDuration: numeric, sunNodes: numeric, xMax: numeric, yMax: numeric; submodules: bs: BS; parameters: id = 1, xpos = xMax/2, ypos = 600; node: Node[numNodes]; parameters: energy = intuniform(499900,500000), sunstart = intuniform(20,(numNodes/sunNodes)*sunDuration), //energy = energy, id = index+2, xpos = intuniform(0, xMax), ypos = intuniform(0, yMax); connections nocheck: endmodule // // Instantiates the network // network solar : Solar endnetwork msg file: cl_msg.msg

// Base class for message types // message ClusterMessage SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY Page 22

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

{ fields: int proto; int srcAddress; int destAddress; } // // Status sent from Node to BS // message Status2BSMessage extends ClusterMessage { fields: int energy; int status; int cluster; int xpos; int ypos; } // // BS sends this message to anounce cluster heads to nodes // message ClusterHeadMessage extends ClusterMessage { fields: int cHead[103]; } // // TDMA message // message TDMAMessage extends ClusterMessage { fields: int frames; int frameTime; int tdma[103]; // XXX constant } // // Data sent by nodes to cluster heads // message DataToCHMessage extends ClusterMessage { SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY Page 23

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

fields: int newSun; int data; }

// node has now sun, become new cluster head?

// // Data sent by nodes to BS // message Data2BSMessage extends ClusterMessage { fields: int data; }

4.2 C++ CODE:

node.h : #ifndef NODE_H #define NODE_H #include <omnetpp.h> #include "solar.h" #include "nodebase.h" #include "bs.h" /** * Represents a node in the network */ class Node : public NodeBase { Module_Class_Members(Node, NodeBase, 0); protected: virtual void initialize(); virtual void handleMessage(cMessage * msg); virtual void finish(); void sendExploratory(int src, int rec, char attr, int value, int data, int scount, int bcount, int hopcount, int seqNumber); void sendData(int src, int rec, char attr, int value, int data, int scount, int bcount, int mustShortest); void sendReinforcement(int src, int rec, char attr, int value, int bcount, int scount, int hops, SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY Page 24

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

int seqNumber, int period, int strategy); void send2BS(int src, int rec, int energy, int status, int cluster, int xpos, int ypos); void initNodes(); void sendTDMA(); void sendDataToCHead(int newSun); void sendData2BS(int data); void energyReceive(int bits); void energyTransmit(int bits, int dist); void energyDataAggr(int signals); public: //XXX int minhops; int minBCount; int xpos; int ypos; int nrRounds; int nrFrames; int curFrame; int frameTime; int myData; int mySlot; int bsId; double energy; int headDist; int bsDist; int myCluster; Node *nodePtr[103]; int clusterNodes; int cHead; int headId; int nrDataPackets; int sentBS; int wasHead; int headSun; int headBatt; // flag denoting if I this node is cluster head // id of cluster head (my cluster) // nr of data packets head has received in this frame // how many status updates sent to BS by this node // ctr denoting how often a node was cluster head

// min hops to sink // min hops with batteryCount // just for simulation // number of rounds (each round starts with setups) // number of "rounds in a round" (called frames) // how many slots has one frame // slot in current frame // ID of base station // XXX energy in microJoule XXX nnode.h // distance to head // to which cluster this node belongs

// variables for solar stuff int sunStart; int solarOn; int sunDuration; SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY Page 25

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

int repeatTime; int sunNodes; int expectedEndTime; }; #endif

node.cpp: #include <stdio.h> #include <string.h> #include <omnetpp.h> #include "node.h" #include "bs.h" #include "cl_msg_m.h" #include "cgate.h" Define_Module(Node); void Node::initialize() { int i; cMessage *cm; cMessage *cm2; cModule *parent = parentModule(); this->initStats(); this->myId = par("id"); this->xpos = par("xpos"); this->ypos = par("ypos"); this->nrGates = (int) parent->par("numNodes") + 3; this->energy = (double) par("energy"); this->myCluster = 0; this->nrNodes = (int) parent->par("numNodes"); this->nrFrames = (int) parent->par("frames"); this->nrRounds = (int) parent->par("rounds"); this->solarOn = (int) parent->par("solarOn"); this->sunDuration = (int) parent->par("sunDuration"); this->sunStart = par("sunstart"); this->sunNodes = (int) parent->par("sunNodes"); this->myData = 0; this->curFrame = 0; this->sentBS = 0; SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY Page 26

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

this->wasHead = 0; this->headSun = 0; this->headBatt = 0; // default, set black this->myStatus = STATUS_BATT; this->setDisplayString("p=$xpos,$ypos;o=black"); // schedule SUN //if (this->solarOn) { cm = new cMessage(); cm2 = new cMessage(); cm->setKind(SMSG_CHANGESTATUS); cm2->setKind(SMSG_CHANGESTATUS); int max = this->nrRounds * (this->nrFrames * 30); int endSun = this->sunStart + this->sunDuration; this->repeatTime = (this->nrNodes / this->sunNodes) * this->sunDuration; this->expectedEndTime = (30 * this->nrFrames) * nrRounds; ev << "repeatTime " << this->repeatTime << " expected end " << this-> expectedEndTime << "\n"; if (endSun > max) endSun = max - 100; scheduleAt(simTime() + this->sunStart, cm); // XXXXXXXX scheduleAt(simTime() + endSun, cm2); // XXXXXXXX } ev << this->myId << " energy: " << energy << "status " << this->myStatus << "\n"; { cMessage *cmsg = new cMessage(); cmsg->setKind(SMSG_INIT); scheduleAt(simTime() + INIT_WAIT, cmsg); } } // making the gates on the fly void Node::initNodes() { int i; SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY Page 27

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

cModule *parent = parentModule(); cModule *mod; cModule *myMod; // this is my Module int numNodes; int trRange; int delx, dely; int ritems; numNodes = (int) parent->par("numNodes"); ev << "numNodes is: " << numNodes << " energy: " << energy << "\n"; for (i = 1; i <= simulation.lastModuleIndex(); i++) { int x, y, id; //scan the simulation module vector mod = (cModule *) simulation.module(i); // check for nodes in transmission range if ((strcmp(mod->name(), "node") == 0) || (strcmp(mod->name(), "bs") == 0)) { if (strcmp(mod->name(), "node") == 0) { id = ((Node *) mod)->myId; x = ((Node *) mod)->xpos; y = ((Node *) mod)->ypos; nodePtr[id] = ((Node *) mod); } if (strcmp(mod->name(), "bs") == 0) { id = ((BS *) mod)->myId; this->bsId = id; x = ((BS *) mod)->xpos; y = ((BS *) mod)->ypos; this->bsDist = (x / 10 - this->xpos / 10) * (x / 10 - this->xpos / 10) + (y / 10 this->ypos / 10) * (y / 10 - this->ypos / 10); } if (id != this->myId && id == this->bsId) { cGate *g; char gName[32]; int items;

SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY

Page 28

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

// ev << this->myId << "(" << this->xpos << "," << this->ypos <<") found node with id " << id << " xpos: " << x << " ypos: " << y<< "\n"; if ((((this->ypos - ypos) * (this->ypos - ypos)) + ((this->xpos - xpos) * (this->xpos - xpos))) < 2500 || id == this->bsId) { items = this->gatev.items(); ritems = mod->gatev.items(); // make new gate here sprintf(gName, "O_%d", id); g = new cGate(gName, 'O'); this->gatev.addAt(items, g); // position, element g->setOwnerModule((cModule *) this, items); // make new gate at other side sprintf(gName, "I_%d", this->myId); g = new cGate(gName, 'I'); mod->gatev.addAt(ritems, g); // position, element g->setOwnerModule((cModule *) mod, ritems); //CHANNEL cLinkType *etere = findLink("etere"); connect((cModule *) this, items, (cLinkType *) etere, (cModule *) mod, ritems); //draw the link g = this->gate(items); //g->setDisplayString( g->displayString(), true); } } } } // send energy and solar status to BS ev << "call send2BS\n"; send2BS(this->myId, this->bsId, this->energy, this->myStatus, this->myCluster, this>xpos, this->ypos); } void Node::handleMessage(cMessage * msg) { if (!msg->isSelfMessage()) { // // BS announces head with this message SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY Page 29

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

// broadcasted to all nodes by BS // if (((ClusterMessage *) msg)->getProto() == CL_TOHEAD) { int head; // cluster head of the cluster // reduce energy for packet reception of header energyReceive(25 * 8); head = ((ClusterHeadMessage *) msg)->getCHead(this->myId); ev << this->myId << " my head is " << head << "\n"; if (head != this->myId) { // setup connection to host cGate *g; char gName[32]; int items; int xpos, ypos; cModule *mod; int ritems; ; this->cHead = 0; this->headId = head; if (myStatus == STATUS_SUN) this->setDisplayString("p=$xpos,$ypos;o=yellow"); else this->setDisplayString("p=$xpos,$ypos;o=black"); xpos = nodePtr[head]->xpos; ypos = nodePtr[head]->ypos; mod = (Node *) nodePtr[head]; items = this->gatev.items(); ritems = mod->gatev.items(); // make new gate here sprintf(gName, "O_%d", head); g = new cGate(gName, 'O'); this->gatev.addAt(items, g); // position, element g->setOwnerModule((cModule *) this, items); // make new gate at other side sprintf(gName, "I_%d", this->myId); g = new cGate(gName, 'I'); mod->gatev.addAt(ritems, g); // position, element g->setOwnerModule((cModule *) mod, ritems); SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY Page 30

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

//CHANNEL cLinkType *etere = findLink("etere"); connect((cModule *) this, items, (cLinkType *) etere, (cModule *) mod, ritems); //draw the link g = this->gate(items); //g->setDisplayString( g->displayString(), true); } else { // now this node is cluster head this->cHead = 1; this->headId = head; this->wasHead++; if (this->myStatus == STATUS_BATT) this->headBatt++; else this->headSun++; this->setDisplayString("p=$xpos,$ypos;o=red"); // want to create TDMA in next step { cMessage *cmsg = new cMessage(); cmsg->setKind(SMSG_MAKETDMA); scheduleAt(simTime() + INIT_WAIT, cmsg); } // must stay awake and receive data packets from other nodes // reset number of packets received in this frame this->nrDataPackets = 0; // must collect data and send it to BS } } // // cluster head announces its TDMA scheme with this message // received by nodes in cluster // if (((ClusterMessage *) msg)->getProto() == CL_TDMA) { int i, s; int sTime; // reset data and counters this->myData = 0; // reset myData SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY Page 31

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

this->curFrame = 0; // reduce energy for packet reception of header energyReceive(25 * 8); this->nrFrames = ((TDMAMessage *) msg)->getFrames(); this->frameTime = ((TDMAMessage *) msg)->getFrameTime(); this->headId = ((TDMAMessage *) msg)->getSrcAddress(); ev << this->myId << ": received TDMA frameTime " << this->frameTime << "\n"; // find slot for this node for (i = 0; this->frameTime; i++) { if (((TDMAMessage *) msg)->getTdma(i) == this->myId && ((TDMAMessage *) msg)->getTdma(i) != 0) { ev << this->myId << ": found slot time " << i + 1 << "\n"; sTime = i + 1; this->mySlot = i + 1; break; } } ev << "loop done\n"; // sleep until slot time, then wake up and send data { cMessage *cmsg = new cMessage(); cmsg->setKind(SMSG_SENDDATA); scheduleAt(simTime() + sTime, cmsg); } ev << "tdma " << this->myId << "done\n"; } // // cluster head receives data // if (((ClusterMessage *) msg)->getProto() == CL_CHDATA) { int newHead = 0; // XXX update in case someone // reduce energy for packet reception of data energyReceive(500 * 8); // cluster head received data this->nrDataPackets++; // check if all packets if (this->nrDataPackets == this->clusterNodes) // XXX SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY Page 32

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

{ this->nrDataPackets = 0; // if new cluster head (due to SUN reason) if (newHead) { // inform this node that it is the new head // one "seconds" until processed data is sent to BS } else { // two "seconds" until processed data is sent to BS cMessage *cmsg = new cMessage(); cmsg->setKind(SMSG_DATA2BS); scheduleAt(simTime() + 2, cmsg); } } } } else { // self message if (msg->kind() == SMSG_CHANGESTATUS) //we update the status { int receiver; if (this->myStatus != STATUS_DEAD) { if (myStatus == STATUS_SUN) { cMessage *cm; cMessage *cm2; myStatus = STATUS_BATT; this->setDisplayString("p=$xpos,$ypos;o=black"); if (simTime() + this->repeatTime < this->expectedEndTime) { cm = new cMessage(); cm2 = new cMessage(); cm->setKind(SMSG_CHANGESTATUS); cm2->setKind(SMSG_CHANGESTATUS); scheduleAt(simTime() + this->repeatTime - this->sunDuration, cm); scheduleAt(simTime() + this->repeatTime, cm2); } SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY Page 33

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

} else { myStatus = STATUS_SUN; this->setDisplayString("p=$xpos,$ypos;o=yellow"); } } ev << "new status " << this->myStatus << "\n"; } else if (msg->kind() == SMSG_INIT) { this->initNodes(); } else if (msg->kind() == SMSG_SENDDATA) { int newSun = 0; // set to 1 if you want to take over as clusterhead // node has been woken up to transmit data to clusterhead //ev << this->myId << "to send data to clusterhead\n"; sendDataToCHead(newSun); this->curFrame++; if (this->curFrame < this->nrFrames) { // sleep until slot time, then wake up and send data cMessage *cmsg = new cMessage(); cmsg->setKind(SMSG_SENDDATA); scheduleAt(simTime() + this->frameTime, cmsg); } else { // XXX must wake up to send new status to BS, so new cluster head can be chosen cMessage *cmsg = new cMessage(); cmsg->setKind(SMSG_STATUS2BS); scheduleAt(simTime() + (this->frameTime - this->mySlot), cmsg); } } else if (msg->kind() == SMSG_DATA2BS) { // cluster head sends data to BS sendData2BS(this->myId); } else if (msg->kind() == SMSG_MAKETDMA) { // reset some values SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY Page 34

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

this->curFrame = 0; // cluster head sends data to BS this->sendTDMA(); } else if (msg->kind() == SMSG_STATUS2BS) { if (this->myId == 25) ev << this->myId << ": send STATUS to BS with EL " << this-> energy << " head:" << this->cHead << "\n"; this->cHead = 0; send2BS(this->myId, this->bsId, this->energy, this->myStatus, this->myCluster, this->xpos, this->ypos); this->sentBS++; } else { ev << "got strange self-message!!\n"; } } delete(msg); } void Node::send2BS(int src, int rec, int energy, int status, int cluster, int xpos, int ypos) { // send out a TOCLUSTER message Status2BSMessage *cmsg = new Status2BSMessage(); // create new status2BS message cmsg->setProto(CL_TOBS); cmsg->setSrcAddress(this->myId); // XXX node id cmsg->setDestAddress(rec); cmsg->setStatus(status); cmsg->setEnergy(energy); cmsg->setCluster(cluster); cmsg->setYpos(ypos); cmsg->setXpos(xpos); ev << "in send2BS:" << this->myId << "\n"; { char str[32]; sprintf(str, "O_%d", rec); if (findGate(str) > 1) { cGate *g = gate(str); SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY Page 35

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

if (g->isConnected()) { ev << this->myId << ": sToCluster to" << rec << "\n"; send((Status2BSMessage *) cmsg, str); // reduce energy for header this->energyTransmit(25 * 8, this->bsDist); } } } } void Node::sendTDMA() { int n; int nrPeers = 0; // number of nodes in my cluster char str[32]; int i, j; TDMAMessage *tmsg; int items, ritems; cGate *g; char gName[32]; // create new Message including TDMA slots tmsg = new TDMAMessage(); tmsg->setProto(CL_TDMA); tmsg->setSrcAddress(this->myId); tmsg->setDestAddress(BROADCAST); // compute number of nodes in cluster and update cluster head for (n = 2; n < this->nrNodes + 2; n++) { if (n != this->myId && nodePtr[n]->headId == this->myId) { // set TDMA slot tmsg->setTdma(nrPeers, n); ev << "tdma " << nrPeers << ": " << n << "\n"; // make a connection to this node items = this->gatev.items(); ritems = nodePtr[n]->gatev.items(); // make new gate here sprintf(gName, "O_%d", nodePtr[n]->myId); g = new cGate(gName, 'O'); this->gatev.addAt(items, g); // position, element g->setOwnerModule((cModule *) this, items); SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY Page 36

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

// make new gate at other side sprintf(gName, "I_%d", this->myId); g = new cGate(gName, 'I'); nodePtr[n]->gatev.addAt(ritems, g); // position, element g->setOwnerModule(nodePtr[n], ritems); //CHANNEL cLinkType *etere = findLink("etere"); connect((cModule *) this, items, (cLinkType *) etere, nodePtr[n], ritems); //draw the link g = this->gate(items); g->setDisplayString(g->displayString(), true); // compute distance as well nodePtr[n]->headDist = (((nodePtr[n])->xpos / 10 - this->xpos / 10) * ((nodePtr[n])->xpos / 10 this->xpos / 10)) + (((nodePtr[n])->ypos / 10 - this->ypos / 10) * ((nodePtr[n])->ypos / 10 this->ypos / 10)); ev << "dist: " << nodePtr[n]->headDist << "\n"; nrPeers++; } } ev << "clusterhead " << this->myId << ": have peers " << nrPeers << "\n"; tmsg->setFrames(this->nrFrames); // XXX nr Frames ??? tmsg->setFrameTime(nrPeers + 2); // XXX frame length? this->clusterNodes = nrPeers; // give two slots to cluster head at the end of each round tmsg->setTdma(nrPeers, this->myId); tmsg->setTdma(nrPeers + 1, this->myId); for (i = 0; i < nrPeers; i++) { int rec = tmsg->getTdma(i); sprintf(str, "O_%d", rec); if (findGate(str) > 1) { cGate *g = gate(str); if (g->isConnected()) { ev << this->myId << ": sTDMA to" << rec << "\n"; send((TDMAMessage *) tmsg->dup(), str); // reduce energy for header SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY Page 37

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

this->energyTransmit(25 * 8, nodePtr[rec]->headDist); } } else ev << "no gate\n"; } // if we have 0 peers we do not do anything, so we can send our new status // to BS if (nrPeers == 0) { ev << "call send2BS\n"; send2BS(this->myId, this->bsId, this->energy, this->myStatus, this->myCluster, this->xpos, this->ypos); } } void Node::sendDataToCHead(int newSun) { int rec = this->headId; // this data is sent to the cluster head //ev << this->myId << " send data to " << rec << "\n"; // send out a TOCLUSTER message DataToCHMessage *dmsg = new DataToCHMessage(); dmsg->setProto(CL_CHDATA); dmsg->setSrcAddress(this->myId); // XXX node id dmsg->setDestAddress(rec); dmsg->setData(this->myData); this->myData++; dmsg->setNewSun(newSun); { char str[32]; sprintf(str, "O_%d", rec); if (findGate(str) > 1) { cGate *g = gate(str); if (g->isConnected()) { //ev << this->myId << ": sDataCH to" << rec << "\n"; send((DataToCHMessage *) dmsg, str); // reduce energy for data packet this->energyTransmit(500 * 8, this->headDist); } SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY Page 38

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

} } } void Node::sendData2BS(int data) { int rec = this->bsId; // this data is sent to the cluster head ev << this->myId << "send data to BBBBBSSSS\n\n\n"; // send out a TOCLUSTER message Data2BSMessage *dmsg = new Data2BSMessage(); // create new toCenter message dmsg->setProto(CL_CHDATA); dmsg->setSrcAddress(this->myId); // XXX node id dmsg->setDestAddress(rec); dmsg->setData(this->myData); this->myData++; { char str[32]; sprintf(str, "O_%d", rec); if (findGate(str) > 1) { cGate *g = gate(str); if (g->isConnected()) { //ev << this->myId << ": sDataCH to" << rec << "\n"; send((Data2BSMessage *) dmsg, str); // reduce energy for data packet to BS this->energyTransmit(500 * 8, this->bsDist); } } } // reduce energy for data aggregation energyDataAggr(this->clusterNodes); // now done with this round this->curFrame++; if (this->curFrame == this->nrFrames) { ev << "cHead: round done\n"; // reset from being a cluster head //this->cHead = 0; {

SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY

Page 39

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

// XXX must wake up to send new status to BS, so new cluster head can be chosen cMessage *cmsg = new cMessage(); cmsg->setKind(SMSG_STATUS2BS); scheduleAt(simTime(), cmsg); // XXX constant } this->curFrame = 0; } } // energy consumption for reception of bits void Node::energyReceive(int bits) { double en; // lost energy if (this->myStatus == STATUS_BATT) { en = (double) bits *50.0 * NANO; ev << "REC-energy: " << en << "\n"; this->energy = this->energy - en; } } // energy consumption for transmission of bits over distance dist // node that dist is already the square void Node::energyTransmit(int bits, int dist) { double en; if (this->myStatus == STATUS_BATT) { en = bits * 10 * PICO * dist + (double) bits *50.0 * NANO; if (this->cHead == 1) ev << "TR-energy HEAD: " << en << "\n"; this->energy = this->energy - en; } } // energy consumption for data aggregation (cluster head only) void Node::energyDataAggr(int signals) { double en; if (this->myStatus == STATUS_BATT) { en = 5 * NANO * signals; SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY Page 40

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

ev << "AGG-energy: " << en << "\n"; this->energy = this->energy - en; } } void Node::finish() { #if 0 recordScalar("node id", this->myId); recordScalar("energy", this->energy); recordScalar("xpos ", this->xpos); recordScalar("ypos ", this->ypos); recordScalar("wasHead", this->wasHead); recordScalar("sunstart", this->sunStart); recordScalar("status", this->myStatus); recordScalar("wasHead", this->wasHead); recordScalar("headSun", this->headSun); recordScalar("headBatt", this->headBatt); #endif }

bs.h: #ifndef BS_H #define BS_H #include <omnetpp.h> #include "solar.h" #include "node.h" #include "nodebase.h" /** * Implements the base station */ class BS : public NodeBase { Module_Class_Members(BS, NodeBase, 0); // this is a macro; it expands to constructor definition etc. // 0 says that we use MessageHandlers, not activity() void BS::initNodes(); virtual void initialize(void); virtual void handleMessage(cMessage * msg); void BS::resetStatus(); SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY Page 41

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

void BS::computeBest(); void BS::finish(); int xpos; int ypos; // just for simulation

int nrStatusRec; // number of received status // struct _adv advInfo[NR_CLUSTERS]; struct _adv advInfo[104]; // XXX cModule *nodePtr[104]; int roundEnergyLoss; int xMax; int yMax; int roundsDone; int nrRounds; int firstDead; int roundTimes[400]; int sunnyNodes[400]; int deadRound[400]; int sunnyCtr; int calledEnd; int solarOn; int halfDead; int halfDeadCtr; int oldDeadNodes; int deadNodes; int sunNodes; int sunDuration; }; #endif // XXX times when round starts

bs.cpp: #include <stdio.h> #include <string.h> #include <omnetpp.h> #include "node.h" #include "bs.h" #include "cl_msg_m.h"

SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY

Page 42

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

#define EXPL_TIME Define_Module(BS);

void BS::initialize() { int xpos, ypos, i; cModule *parent = parentModule(); this->myId = par("id"); this->nrGates = (int) parent->par("numNodes") + 2; this->xpos = par("xpos"); this->ypos = par("ypos"); this->nrNodes = (int) parent->par("numNodes"); this->xMax = (int) parent->par("xMax"); this->yMax = (int) parent->par("yMax"); this->resetStatus(); this->roundEnergyLoss = 80001.0; this->roundsDone = 0; this->nrRounds = (int) parent->par("rounds"); this->firstDead = 0; this->calledEnd = 0; this->solarOn = (int) parent->par("solarOn"); this->sunNodes = (int) parent->par("sunNodes"); this->sunDuration = (int) parent->par("sunDuration"); this->sunnyCtr = 0; this->halfDead = 0; this->halfDeadCtr = 0; this->deadNodes = 0; this->oldDeadNodes = 0; for (i = 0; i < 104; i++) { advInfo[i].id = 0; advInfo[i].energy = 0; advInfo[i].status = 0; } for (i = 0; i < this->nrRounds; i++) { this->roundTimes[i] = 0; this->sunnyNodes[i] = 0; } // schedule first sending this->setDisplayString("p=$xpos,$ypos;b=,,rect;o=blue"); SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY Page 43

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

ev << "BS: id " << this->myId << " nrGates: " << this->nrGates << " x,y " << this-> xpos << this->ypos << "\n"; { cMessage *cmsg = new cMessage(); cmsg->setKind(SMSG_INIT); scheduleAt(simTime(), cmsg); } } // making the gates on the fly void BS::initNodes() { int i; cModule *parent = parentModule(); cModule *mod; cModule *myMod; // this is my Module int numNodes; int trRange; int delx, dely; int ritems; // new stuff numNodes = (int) parent->par("numNodes"); ev << "BS numNodes is: " << numNodes << "\n"; // new stuff trRange = (int) parent->par("trRange"); ev << "BS trRange is: " << trRange << "\n"; for (i = 1; i <= simulation.lastModuleIndex(); i++) { int x, y, id; //scan the simulation module vector mod = (cModule *) simulation.module(i); if (strcmp(mod->name(), "node") == 0) { id = ((Node *) mod)->myId; x = ((Node *) mod)->xpos; y = ((Node *) mod)->ypos; nodePtr[id] = ((Node *) mod); if (id != this->myId) { SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY Page 44

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

cGate *g; char gName[32]; int items; ev << "BS: " << this->myId << "(" << this->xpos << "," << this-> ypos << ") found node with id " << id << " xpos: " << x << " ypos: " << y << "\n"; items = this->gatev.items(); ritems = mod->gatev.items(); ev << "items " << items << "\n"; // make new gate here sprintf(gName, "O_%d", id); g = new cGate(gName, 'O'); this->gatev.addAt(items, g); // position, element g->setOwnerModule((cModule *) this, items); // make new gate at other side sprintf(gName, "I_%d", this->myId); g = new cGate(gName, 'I'); mod->gatev.addAt(ritems, g); // position, element g->setOwnerModule((cModule *) mod, ritems); //CHANNEL cLinkType *etere = findLink("etere"); connect((cModule *) this, items, (cLinkType *) etere, (cModule *) mod, ritems); //draw the link //g = this->gate(items); //g->setDisplayString( g->displayString(), true); } } } } void BS::handleMessage(cMessage * msg) { if (msg->isSelfMessage()) { ev << "BS: got self message type " << msg->kind() << "\n"; if (msg->kind() == SMSG_INIT) { SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY Page 45

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

ev << "BS: got start message\n"; this->initNodes(); } } else { // no self message if (((ClusterMessage *) msg)->getProto() == CL_TOBS) { int energy; int cluster; int status; int sender; int clHead; int curHEnergy; // energy of current head int curHStatus; // status of current head int rating; int xpos, ypos; sender = ((Status2BSMessage *) msg)->getSrcAddress(); energy = ((Status2BSMessage *) msg)->getEnergy(); cluster = ((Status2BSMessage *) msg)->getCluster(); status = ((Status2BSMessage *) msg)->getStatus(); xpos = ((Status2BSMessage *) msg)->getXpos(); ypos = ((Status2BSMessage *) msg)->getYpos(); if (energy < 0 && this->firstDead == 0) this->firstDead = this->roundsDone; if (energy < 0 && this->halfDead == 0) this->halfDeadCtr++; if (this->roundsDone < 300) this->roundTimes[roundsDone] = (int) simTime(); advInfo[sender].id = sender; advInfo[sender].energy = energy; advInfo[sender].status = status; advInfo[sender].xpos = xpos; advInfo[sender].ypos = ypos; if (advInfo[sender].energy < 0) { if (((Node *) nodePtr[sender])->myStatus != STATUS_DEAD) this->deadNodes++; advInfo[sender].status = STATUS_DEAD; status = STATUS_DEAD; // XXX debug only SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY Page 46

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

((Node *) nodePtr[sender])->myStatus = STATUS_DEAD; } if (status == STATUS_SUN) this->sunnyCtr++; // compute rating if (this->solarOn) { if (status == STATUS_SUN) rating = energy - roundEnergyLoss / 2; else rating = energy - roundEnergyLoss; } else rating = energy - roundEnergyLoss; advInfo[sender].rating = rating; ev << "BS received from " << sender << "status " << status << " rating: " << rating << "\n"; this->nrStatusRec++; ev << "BS rec " << this->nrStatusRec << " nrNodes: " << this->nrNodes << "\n"; // check if done if (this->nrStatusRec == this->nrNodes - this->oldDeadNodes) { this->oldDeadNodes += this->deadNodes; ev << "nodes dead " << this->deadNodes << "all dead " << this>oldDeadNodes << "\n"; this->deadRound[this->roundsDone] = this->deadNodes; this->sunnyNodes[this->roundsDone] = this->sunnyCtr; if (this->halfDeadCtr > this->nrNodes / 2 && this->halfDead == 0) { this->halfDead = roundsDone; ev << " HALF DEAD\n"; this->calledEnd = 2; endSimulation(); } this->roundsDone++; if (this->roundsDone <= this->nrRounds) { ev << "BS call compute best\n"; // now compute best nodes SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY Page 47

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

computeBest(); resetStatus(); } if (this->roundsDone > this->nrRounds) { this->calledEnd = 1; endSimulation(); } } } } delete(msg); } void BS::resetStatus() { int i; this->nrStatusRec = 0; this->sunnyCtr = 0; this->deadNodes = 0; } // // Note: this method is far too long, bad programming style!! // #define FBEST 8 // best after first round #define LBEST 6 // 6 best are in last round, 5 survive void BS::computeBest() { struct _adv best[FBEST]; int i, j; int min = 999999999; int minPtr = 0; int sum = 0; int nrSolar = 0; // nr of solar nodes ev << "first 8\n"; // put FBEST nodes in best, compute min for (i = 0; i < FBEST; i++) { if (this->advInfo[i + 2].rating < min) { min = this->advInfo[i + 2].rating; SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY Page 48 // number of received status

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

minPtr = i; } best[i].id = this->advInfo[i + 2].id; best[i].xpos = this->advInfo[i + 2].xpos; best[i].ypos = this->advInfo[i + 2].ypos; best[i].status = this->advInfo[i + 2].status; best[i].rating = this->advInfo[i + 2].rating; ev << "Id: " << best[i].id << " rating: " << best[i].rating << "\n"; } for (i = FBEST; i < this->nrNodes; i++) { // ev << "i: " << i << "\n"; // search for the ones larger tha min (smallest in best) if (this->advInfo[i + 2].rating > min) { // replace min min = this->advInfo[i + 2].rating; best[minPtr].id = this->advInfo[i + 2].id; best[minPtr].rating = this->advInfo[i + 2].rating; best[minPtr].xpos = this->advInfo[i + 2].xpos; best[minPtr].ypos = this->advInfo[i + 2].ypos; // recompute min and minPtr minPtr = 0; min = 9999999; for (j = 0; j < FBEST; j++) { if (best[j].rating < min) { min = best[j].rating; minPtr = j; } } } } // print out FBEST best, count solar nodes ev << "computeBest:\n"; nrSolar = 0; for (i = 0; i < FBEST; i++) { ev << "Id: " << best[i].id << " rating: " << best[i].rating << "\n"; nodePtr[best[i].id]->setDisplayString("p=$xpos,$ypos;o=green"); if (best[i].status == STATUS_SUN) nrSolar++; } SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY Page 49

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

// now find one node with minimum distance to all other best nodes // usually one in the middle will be removed // do not through away solar nodes (if not all are solar nodes) minPtr = 0; min = 99999999; for (i = 0; i < FBEST; i++) { sum = 0; for (j = 0; j < FBEST; j++) { if (j != i) sum += ((best[i].xpos - best[j].xpos) * (best[i].xpos - best[j].xpos)) + ((best[i].ypos - best[j].ypos) * (best[i].ypos - best[j].ypos)); } //ev << "distance sum " << sum << " id " << best[i].id << " min " << min << "\n"; if (sum < min && (nrSolar < 5 && best[i].status == STATUS_BATT)) { minPtr = i; min = sum; } } ev << "remove node " << best[minPtr].id << " from cluster \n"; nodePtr[best[minPtr].id]->setDisplayString("p=$xpos,$ypos;o=red"); if (minPtr != FBEST - 1) { best[minPtr].id = best[FBEST - 1].id; best[minPtr].xpos = best[FBEST - 1].xpos; best[minPtr].ypos = best[FBEST - 1].ypos; best[minPtr].rating = best[FBEST - 1].rating; } // print out FBEST best ev << "computeBest now:\n"; for (i = 0; i < FBEST - 1; i++) { ev << "Id: " << best[i].id << " rating: " << best[i].rating << "\n"; } // search for node closest to another node, if one of them close to // the border, remove the one close to the border { int n1, n2, tmp; int close = 0; min = 9999999; SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY Page 50

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

for (i = 0; i < FBEST - 1; i++) { for (j = 0; j < FBEST - 1; j++) { if (j != i) { tmp = ((best[i].xpos - best[j].xpos) * (best[i].xpos - best[j].xpos)) + ((best[i].ypos - best[j].ypos) * (best[i].ypos - best[j].ypos)); if (tmp < min) { min = tmp; n1 = i; n2 = j; } } } } ev << "n1: " << best[n1].id << " n2: " << best[n2].id << "\n"; #define BORDER 180 // now choose one of the two if (best[n1].xpos<BORDER || best[n1].xpos>this->xMax - BORDER || best[n1].ypos<BORDER || best[n1].ypos>this->yMax - BORDER) close = n1; else close = n2; // do not remove solar if (this->solarOn && best[n1].status == STATUS_SUN && best[n2].status == STATUS_BATT) close = n2; if (this->solarOn && best[n2].status == STATUS_SUN && best[n1].status == STATUS_BATT) close = n1; // update array, remove close ev << "remove close" << best[close].id << "\n"; nodePtr[best[close].id]->setDisplayString("p=$xpos,$ypos;o=red"); if (close != FBEST - 2) { best[close].id = best[FBEST - 2].id; best[close].xpos = best[FBEST - 2].xpos; best[close].ypos = best[FBEST - 2].ypos; best[close].rating = best[FBEST - 2].rating; } // print out FBEST best ev << "computeBest now:\n"; SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY Page 51

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

for (i = 0; i < FBEST - 2; i++) { ev << "Id: " << best[i].id << " rating: " << best[i].rating << "\n"; } } // now we do a real optimization { int sumWithout[LBEST]; int n; int tmp; for (i = 0; i < LBEST; i++) { // reset sum sum = 0; // loop through all nodes to find minimun distance for (n = 2; n < this->nrNodes + 2; n++) { Node *nPtr = (Node *) nodePtr[n]; if (nPtr->myStatus != STATUS_DEAD) { min = 9999999; for (j = 0; j < LBEST; j++) { if (i != j) { tmp = (nPtr->xpos - best[j].xpos) * (nPtr->xpos - best[j].xpos) + (nPtr->ypos - best[j].ypos) * (nPtr->ypos - best[j].ypos); if (tmp < min) { // ev << "min " << j << "\n"; min = tmp; } } } sum += min; } } sumWithout[i] = sum; ev << "sumwithout " << best[i].id << ": " << sum << "\n"; } // the one is lowest number gets kicked out min = 99999999; for (i = 0; i < LBEST; i++) SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY Page 52

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

{ if (sumWithout[i] < min) { min = sumWithout[i]; n = i; } } ev << "time " << simTime() << " OUT goes " << best[n].id << "\n"; nodePtr[best[n].id]->setDisplayString("p=$xpos,$ypos;o=red"); // remove that node if (n != LBEST - 1) { best[n].id = best[LBEST - 1].id; best[n].xpos = best[LBEST - 1].xpos; best[n].ypos = best[LBEST - 1].ypos; best[n].rating = best[LBEST - 1].rating; } // print out LBEST best ev << "computeBest now:\n"; for (i = 0; i < LBEST - 1; i++) { ev << "Id: " << best[i].id << " rating: " << best[i].rating << " x,y " << best[i]. xpos << "," << best[i].ypos << "\n"; } } // now we send message to all nodes and announce their cluster head { int head = 0; int tmp; char str[32]; ClusterHeadMessage *cmsg = new ClusterHeadMessage(); ev << "send messages to nodes announcing cluster heads\n"; cmsg->setProto(CL_TOHEAD); // XXX new name (to all now) cmsg->setSrcAddress(this->myId); for (int rec = 2; rec < this->nrNodes + 2; rec++) { Node *nPtr = (Node *) nodePtr[rec]; head = 0; if (nPtr->myStatus != STATUS_DEAD) { //ev << "rec: " << rec; min = 9999999; for (j = 0; j < LBEST - 1; j++) { SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY Page 53

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

if (rec != best[j].id) { tmp = (nPtr->xpos - best[j].xpos) * (nPtr->xpos - best[j].xpos) + (nPtr->ypos - best[j].ypos) * (nPtr->ypos - best[j].ypos); //ev << " cmp with " << best[j].id << "gives" << tmp << " "; if (tmp < min) { //ev << "new min\n"; min = tmp; head = best[j].id; } } else { head = best[j].id; break; } } } ev << " BS: rec " << rec << " x,y " << nPtr->xpos << "," << nPtr-> ypos << " has head: " << head << "\n"; cmsg->setCHead(rec, head); } cmsg->setDestAddress(BROADCAST); for (int rec = 2; rec < this->nrNodes + 2; rec++) { ev << "BS sendHEAD for" << rec << ":" << cmsg->getCHead(rec) << "\n"; if (cmsg->getCHead(rec) != 0) // no head when dead { sprintf(str, "O_%d", rec); if (findGate(str) > 1) { cGate *g = gate(str); if (g->isConnected()) { //ev << this->myId << ": sToCHEAD to" << rec << "\n"; send((ClusterHeadMessage *) cmsg->dup(), str); } } } else ev << "DEAD DEAD " << rec << "\n"; } } // here we can reset everything SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY Page 54

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

this->resetStatus(); } void BS::finish() { int i; //recordScalar("BS BS node id",this->myId); recordScalar("solarOn", this->solarOn); recordScalar("sunDuration", this->sunDuration); recordScalar("roundsDone", this->roundsDone); recordScalar("nrRounds", this->nrRounds); recordScalar("firstDead", this->firstDead); recordScalar("halfDead", this->halfDead); recordScalar("sunNodes", this->sunNodes); #if 0 recordScalar("calledEnd", this->calledEnd); for (i = 0; i < this->roundsDone; i++) { recordScalar("roundsDone", this->roundTimes[i]); recordScalar("sunny nodes", this->sunnyNodes[i]); } #endif }

nodebase.h: #ifndef NNODE_H #define NNODE_H #include <omnetpp.h> #include "solar.h" /** * Base class for Node and BS. */ class NodeBase : public cSimpleModule { Module_Class_Members(NodeBase, cSimpleModule, 0); protected: virtual void initialize() = 0; virtual void handleMessage(cMessage * msg) = 0; SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY Page 55

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

virtual void finish(); void updateStats(); void initStats(); public: //XXX cArray nHosts; int myId;

// XXX IT neighbouring hosts

int myStatus; // SUNNY STUFF for stats int nrAllMsgBatt; int nrAllMsgSun; int nrDataBatt; int nrDataSun; int nrExplBatt; int sinkFromTwo; int sinkFromThree; // how many gates int nrGates; int nrNodes; }; extern void updateStats(); #endif

nodebase.cpp: #include <stdio.h> #include <string.h> #include <omnetpp.h> #include "nodebase.h" #include "cl_msg_m.h" void NodeBase::updateStats() { if (this->myStatus == STATUS_SUN) this->nrAllMsgSun++; else this->nrAllMsgBatt++; }

SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY

Page 56

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

void NodeBase::initStats() { this->nrAllMsgBatt = 0; this->nrAllMsgSun = 0; this->nrDataBatt = 0; this->nrDataSun = 0; } void NodeBase::finish() { #if 0 ev << "finished node id: "; ev << this->myId; ev << " nrAllMsgBatt: "; ev << this->nrAllMsgBatt; ev << " nrAllMsgSun "; ev << this->nrAllMsgSun; ev << " nrDataBatt "; ev << this->nrDataBatt; ev << " nrDataSun "; ev << this->nrDataSun; ev << "\n"; #endif #if 0 recordScalar(" nrAllMsgBatt", this->nrAllMsgBatt); recordScalar("nrAllMsgSun", this->nrAllMsgSun); recordScalar("nrDataBatt ", this->nrDataBatt); recordScalar("nrDataSun ", this->nrDataSun); recordScalar("nrExplBatt", this->nrExplBatt); #endif }

solar.h: #ifndef SOLAR_H #define SOLAR_H // define if we want to use NOSUN or not //#define NOSUN 1 #undef NOSUN #define NANO 0.001 #define PICO 0.000001

SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY

Page 57

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

// NEW: CLUSTER_STUFF #define NR_CLUSTERS 1 // XXX update #define BS_ID 1 // ID of base station #define CH_MIN_ENERGY 30 // XXX want to change this!! #define CLUSTER_SIZE 30 #define FRAME_TIME CLUSTER_SIZE+1 // how long is one frame (how many slots) // messagetypes for clusters #define CL_TOBS 1 #define CL_TOHEAD 2 #define CL_TDMA 3 #define CL_CHDATA 4 // self message types #define SMSG_SENDDATA 11 #define SMSG_CHANGESTATUS 12 #define SMSG_DATA2BS 13 // cluster head sends data to BS #define SMSG_STATUS2BS 14 // nodes send their new status to BS #define SMSG_SINKSTART 15 #define SMSG_SEQUPDATE 16 // nodes update seq number for expl messages #define SMSG_INIT 17 // init updates #define SMSG_MAKETDMA 18 #define BROADCAST 0 1

#define STATUS_SUN // status: running with solar energy #define STATUS_BATT 2 // status: running on battery #define STATUS_DEAD 3 // this node is dead struct _node { int id; int status; int outgate; int hops; int bcount; int scount; int seqNumber; }; struct _adv { int id; int energy; SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY

// per node

Page 58

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

int status; int rating; int xpos; int ypos; }; struct _peerInfo { int id; int xpos; int ypos; }; // status for myGrad #define GS_INIT #define GS_ACTIVE // define some events and times #define INIT_WAIT 1 // wait to init nodes #define SINK_WAIT 2 // sink waits until start #define EVENT_SENSORDATA #define EVENT_BC #define BC_TIME 1 #define EVENT_CHANGESTATUS 3 #define EVENT_PRINTSTATS //#define END_TIME 1250 #define END_TIME //#define END_TIME 1100 //#define END_TIME 1750 #define CHANGE2_1 #define CHANGE2_2 #define CHANGE3_1 #define CHANGE3_2 #define EXPL_PERIOD #define DATA_PERIOD #define MAX_NEIGHBOURS #define MAX_DOWNS #endif 4

0 1

1 2

900

200 400 100 450 300 40 5 /* for hop counter */ 2 /* how many downs */

SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY

Page 59

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

5. RESULTS
The following snapshots describe the various stages of the LEACH implementation done using OMNET++:

fig 8: initial WSN network

SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY

Page 60

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

Setup phase:

Fig 9: node discovery phase

Fig 10: cluster formation and TDMA allocation

SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY

Page 61

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

Fig 11: data transmission- node to CH & CH to Base station.

Fig 12: re-clustering for selection of new cluster heads.

SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY

Page 62

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

6. SUMMARY AND CONCLUSION


6.1 Summary of Achievements

Studied about wireless sensor networks, its node architecture and compared various categories of its routing protocols. Got an experience in using OMNET++ simulator. Studied about LEACH protocol in detail. Implemented the simulation of a LEACH variant in OMNET++ simulator.

6.2 Major difficulties encountered The major difficulty encountered during this project was learning to use the OMNET++ simulator like installation on a windows platform, understanding ned files, messages, and using simulation library. The other major difficulty was to implement the LEACH protocol in the simulator. The solarleach simulation published in the public domain by Thiemo Voigt as his research work was used to study the simulation of the leach protocol in OMNET++.

6.3 Limitations of the Project

The main limitation of the project implementation are as follows: The number of cluster heads are predetermined The base station is fixed. The nodes are not mobile. all the nodes are assumed to be of equal capabilities. Solar nodes are not stripped from the network.

6.4 Future Scope of work The sensor node can be made mobile and dynamic clustering algorithms implemented without fixing the limit on the number cluster heads. SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY Page 63

STUDY OF WSN ROUTING & IMPLEMENTATION USING OMNET++

BIBLIOGRAPHY
[1] Heinzelman W., Chandrakasan A., Balakrishnan H.: Energy-Efficient

Communication Protocol for Wireless Microsensor Networks. International Conference on System Sciences, Hawaii, January 2000.

[2] Varga A.: The OMNeT++ Discrete Event Simulation System. European Simulation Multiconference, Prague, Czech Republic, June 2001. [3] Bandyopadhyay S., Coyle E.: An Energy Efficient Hierarchical Clustering Algorithm for Wireless Sensor Networks. Infocom 2003, San Francisco, CA, USA, April 2003.

Sites:

http://www.omnetpp.org/

SIKKIM MANIPAL INSTITUTE OF TECHNOLOGY

Page 64