My Project | Low Rate Wireless Personal Area Networks in NS2

INTRODUCTION

           The IEEE 802.15.4 has recently been adopted as a communication standard for low data rate, low power consumption and low cost Wireless Personal Area Networks. This protocol is quite flexible for a wide range of applications if appropriate tuning of its parameters is carried out. Importantly, the protocol also provides real-time guarantees by using the Guaranteed Time Slot (GTS) mechanism. Indeed, the GTS mechanism is quite attractive for time-sensitive Wireless Sensor Network (WSN) applications, particularly when supported by cluster-tree network topologies, such as defined in the ZigBee standard... Continue Reading

MOTIVATION

The wireless market has been traditionally dominated by high end technologies, but so far Wireless Personal Area Networking products have not been able to make a significant impact on the market. While some technologies like the Bluetooth have been quite a success story, in the areas like computer peripherals, mobile devices, etc, they couldn’t be expanded to the automation arena. This led to the invention of the wireless low data rate personal area networking technology, Zigbee (IEEE 802.15.4),... Continue Reading

Evolution of zigbee

During the last decade there has been an explosion of devices using sensor technologies for control and monitoring purposes. Wired Sensors are now intended to be replaced with wireless technologies. Corporates have been envisioning of a digital home where every device is connected, and remotely controlled and monitored. Even though a perfect digital home is yet a mirage, we are now able to apply several technologies to suite our home and industrial networking needs. However, this concept of a digitally connected home has received a luke warm response due to lack of viable solutions... Continue Reading

Overview of our project 

The objective of our project is to build a simulation model of LR-WPAN and simulated the model using the Network simulator NS2. The WPAN Low Rate Task Group (TG4) is chartered to investigate a low data rate solution with multi-month to multi-year battery life and very low complexity.  This standard specifies two physical layers: an 868 MHz/915 MHz direct sequence spread spectrum PHY and a 2.4 GHz direct sequence spread spectrum PHY.  The 2.4 GHz PHY supports an over air data rate of 250 kb/s and the 868 MHz/915 MHz PHY supports over the air data rates of 20 kb/s and 40 kb/s.... Continue Reading

Applications

There has been tremendous excitement on part of the corporates, the market and the consumers alike because of the wide spectrum of applications that zigbee has to other. It is a revolutionary new technology built to compliment or replace existing not so successful technologies. Automation is the buzz word for zigbee. It stands to automate our household, corporate buildings and industries.... Continue Reading

AN OVERVIEW OF IEEE 802.15.4

Compared with wired networks, wireless networks provide advantages in deployment, cost, size, and distributed intelligence. Wireless technology not only enables users to set up a network quickly, but also enables them to set up a network where it is in-convenient or impossible to wire cables. The “care free” feature and convenience of deployment make a wireless network more cost-efficient than a wired network in general... Continue Reading

Network Topologies

A Low rate WPAN supports three different types of topologies.

•         Star Topology
  
•         Peer-to-Peer Topology
•         Cluster Tree/Mesh Topology... Continue Reading

Network Formation

Network formation is part of the network layer functionalities. An example run of the various steps involved for a network formation is presented:

Star-Topology

•          Assume a full function device is switched ON for the first time.
  
•         It starts scanning its operating channels for possible beacon transmissions, from other PANs... Continue Reading

Architecture

The LR-WPAN architecture is defined in terms of a number of blocks in order to simplify the standard. These blocks are called layers. Each layer is responsible for one part of the standard and offers services to the higher layers. The layout of the blocks is similar to the structure of the OSI layered architecture. But the IEEE 802.15.4 standard only defines the PHY and the MAC layers. The upper layers of networking and application have been left for the application developers. An LR-WPAN device comprises a PHY, which contains the radio frequency (RF) transceiver along with its low-level control mechanism, and a MAC sub layer that provides access to the physical channel for all types of transfer. The figure 2.3 depicts the layered architecture of IEEE 802.15.4... Continue Reading

Functional Overview

The Superframe structure

The superframe structure (Fig: 2.4) is an optional part of a WPAN. It is the time duration between two consecutive beacons. The structure of the superframe is determined by the coordinator. The coordinator can also switch off the use of a superframe by not transmitting the beacons. The superframe duration is divided into 16 concurrent slots. The beacon is transmitted in the first slot. The remaining part of the superframe duration can be described by the terms, CAP, CFP and Inactive. The superframe is used to provide vital statistics like synchronization, identifying the PAN and the superframe structure, to the devices connected in a Wireless PAN. This information is critical for the operation of the PAN in a Beacon enabled network... Continue Reading

Data Transmission

There can be three different types of data transmission possible. They are

Ø Transmission from a device to the coordinator

Ø Transmission from the coordinator to the device

Ø Transmission between any two devices.

NETWORK SIMULATOR

Purpose

NS (version 2) is an object-oriented, discrete event driven network simulator developed at UC Berkely written in C++ and OTcl. NS is primarily useful for simulating local and wide area networks. Although NS is fairly easy to use once you get to know the simulator, it is quite difficult for a first time user, because there are few user-friendly manuals. Even though there is a lot of documentation written by the developers which has in depth explanation of the simulator, it is written with the depth of a skilled NS user. The purpose of this project is to give a new user some basic idea of how the simulator works, how to setup simulation networks, where to look for further information about network components in simulator codes, how to create new network components, etc., mainly by giving simple examples and brief explanations based on our experiences. Although all the usage of the simulator or possible network simulation setups may not be covered in this project, the project should help a new user to get started quickly.

3.1.2 Overview

NS is an event driven network simulator developed at UC Berkeley that simulates variety of IP networks. It implements network protocols such as TCP and UPD, traffic source behavior such as... Continue Reading

Simple simulation

This section shows a simple NS simulation script and explains what each line does. An OTcl script that creates the simple network configuration and runs the simulation scenario is shown... Continue Reading

EXPLANATION FOR A SIMPLE PROGRAM

The following is the explanation of the script above. In general, an NS script starts with making a Simulator object instance.

set ns [new Simulator]: generates an NS simulator object instance, and assigns it to variable ns (italics is used for variables and values in this section).

What this line does is the following:

Initialize the packet format (ignore this for now)

Create a scheduler (default is calendar scheduler)

Select the default address format (ignore this for now)

 The "Simulator" object has member functions that do the following:

  Create compound objects such as nodes and links (described later)

Connect network component objects created (ex. attach-agent)

Set network component parameters (mostly for compound objects)

Create connections between agents (ex. make connection between a "tcp" and "sink")

Specify NAM display options

Etc... Continue Reading

The Network Animator

The network simulator (ns) comes along with an interesting tool, called the Network Animator (NAM). Nam is a Tcl/TK based animation tool for viewing network simulation traces and real world packet trace data. The design theory behind nam was to create an animator that is able to read large animation data sets and be extensible enough so that it could be used in different network visualization situations... Continue Reading

 SIMULATION SETUP

First the simulation model of star and peer-to-peer technology is designed. The following steps are done to simulate the model,

·        Generate the scripts for node arrangement

·        Creating TCL scripts for both the topologies

·        Running the simulation... Continue Reading

Model of Star topology

The node scenario generation is done using the star.scn file. The Start topology model has the following parameters simulated

• Simulation Parameters
  

Simulation is a flexible means for assessment of the performance offered by a telecommunication system. However, identifying the correct simulation parameters is key for a successful and nearly realistic analysis

• Traffic Parameters
  
• Traffic Type... Continue Reading

Model of Peer-to-peer topology

The simulation parameters for peer-to-peer topology are mostly simulated similar to that of star topology but for some parameters. The peer-to-peer topology has main advantage that the node can transmit data to different... Continue Reading

Simulation Results

The simulation process is carried out systematically as shown,

·        Running Ns2

·        Path setting for NS2

·        Opening Terminal window

·        Running Star.tcl an d Peer.tcl

·        NAM Analysis

Steps to Simulate our project

Ø Firstly the Terminal window in fedora is opened

Ø The path for the NS is loaded

Ø Run the command ns star.tcl or peer.tcl

Continue Reading

LR-WPAN is a promising new wireless short range communications technology. It may not have yet swept the short range communications market but it is surely making its presence felt. An alliance of companies called the Zibgbee alliance, have already joined hands to benefit from this new technology and share information and develop new applications. With its promises of short range communications with very low datarates and ultra low power consumption, it has created a market for itself.
A detailed study of the zigbee technology with its internal architecture, and the layered structure has been conducted. Followed by it is a similar study of the simulator environment (ns-2). A detailed study of the zigbee modules built under ns-2 with reference to its implementation in the standard also has been done. Later a well behaved and near realistic simulation scenario is built in TCL. The zigbee modules have been exclusively tested for the simulator environment and several loopholes have been identified. These loopholes are further investigated to replace them with working modules. Both Star and Peer-to-peer topologies have been studied and finalized that the star topology can be used effectively for short range application whereas the peer-to-peer can be used for large application which involves many number of devices.

The simulation parameters for peer-to-peer topology are mostly simulated similar to that of star topology but for some parameters. The peer-to-peer topology has main advantage that the node can transmit data to different nodes, that is the communication is possible between the nodes.

Parameter
Value
Traffic Type
FTP
Number of nodes
11
Number of coordinator
1
Traffic direction
Node à node
Simulation time
100 seconds
Figure 4.2 Peer topology parameters

The node scenario generation is done using the star.scn file. The Start topology model has the following parameters simulated
4.1.1 Simulation Parameters
Simulation is a flexible means for assessment of the performance offered by a telecommunication system. However, identifying the correct simulation parameters is key for a successful and nearly realistic analysis
of any study. The following discussion focuses on the task of identifying the correct parameters to generate a realistic network scenario, while explaining their meaning and their reason of choice (if any) in detail. General parameters for basic simulations are described here. However, the parameters that impact the network performance are discussed in the next chapter where we introduce the performance analysis of the system.


Traffic Parameters
Traffic Type
This project report is based on results simulated with a FTP application, based on the internet protocol, UDP (User Datagram Protocol). Its primary features are:
. Single Way Transmission (No Acknowledgements)
. Defined Packet size
. Defined Packet Interval
. Unreliable Data Transmission
FTP traffic with a TCP connection is done due to its advanced features like congestion control, requiring dynamic adjustment of the transmission rate based on the traffic conditions; it is hard to implement simplistic and power efficient devices, for menial applications.
Packet Size
The packet size is assumed be to 70bytes. This is exclusive of the RTR, MAC and PHY layer headers.
Traffic Direction
The traffic flows are all one way, with the communication directed to the coordinator. The study is being investigated with particular focus on low datarate wireless sensors communicating with a central node updating it with the application information.
Number of Nodes
The simulation is carried out with 7 active nodes. One of them being the coordinator.
Coordinators
Since a simple star network topology is being simulated, only a single coordinator is present.
Node Movement
The nodes remain stationary.
Node Position
The nodes are placed along an imaginary circle around the coordinator, with radius equal to the personal operating space of the nodes.
The trace and node parameters are summarized in the following table.

Figure 4.1 Star topology parameters

scen_gen
. Parameters: It accepts the following command line parameters
– scen_gen [number-of-nodes] [X-Pos-of-coord] [Y-Pos-of-coord] [Personal-Operating-Space]
Number-of-nodes: Number of nodes to be placed around the coordinator.
X-Pos-of-coord: X position of the coordinator, with respect to the area of the network dimensions.
Y-Pos-of-coord: Y position of the coordinator, with respect to the area of operation of the network.
Personal-Operating-Space: The operating space or the reachabilitiy of the coordinator. The nodes are required to be placed equidistantly around the coordinator, for the test scenarios in this report, within the operating space of the coordinator, this parameter is utilized to arrange the nodes along an imaginary circle drawn around the coordinator with this value
as radius.
Example: scen gen 11 25 25 10
. Functionality: This utility would automatically generate the coordinates of the nodes to place them around the coordinator, along an imaginary circle drawn with a radius equal to the Personal Operating Space. The node position file, holding the positions of all the nodes around the coordinator is generated from star.scn. Currently this file is being generated with the utility, scen gen. However, it is a simple text file, which can be easily edited to place the nodes at desired positions. Note that the positions of the nodes should respect the boundaries of the network mentioned in the source file, star.tcl
Working: Running the utility would create a file, star.scn, to be used by the source scenario file, star.tcl.
The scn file for star.tcl
$node_(0) set X_ 25
$node_(0) set Y_ 25
$node_(0) set Z_ 0
$node_(1) set X_ 20
$node_(1) set Y_ 16.34
$node_(1) set Z_ 0
$node_(2) set X_ 15
$node_(2) set Y_ 25
$node_(2) set Z_ 0
$node_(3) set X_ 20
$node_(3) set Y_ 33.66
$node_(3) set Z_ 0
$node_(4) set X_ 30
$node_(4) set Y_ 33.66
$node_(4) set Z_ 0
$node_(5) set X_ 35
$node_(5) set Y_ 25
$node_(5) set Z_ 0
$node_(6) set X_ 30
$node_(6) set Y_ 16.34
$node_(6) set Z_ 0

The resultant position file for the nodes would like some think like this:
Figure 4.1 Node arrangement

SIMULATION MODEL
First the simulation model of star and peer-to-peer technology is designed. The following steps are done to simulate the model,
· Generate the scripts for node arrangement
· Creating TCL scripts for both the topologies
· Running the simulation in network simulator
· Analyzing using network simulator
System Requirements
· Operating system – Linux fedora 7
· Package – Ns allinone 2.30
· Scripts – TCL, C++

This section shows a simple NS simulation script and explains what each line does. An OTcl script that creates the simple network configuration and runs the simulation scenario is shown.

A Simple Network Topology and Simulation Scenario

This network consists of 4 nodes (n0, n1, n2, n3) as shown in above figure. The duplex links between n0 and n2, and n1 and n2 have 2 Mbps of bandwidth and 10 ms of delay. The duplex link between n2 and n3 has 1.7 Mbps of bandwidth and 20 ms of delay. Each node uses a DropTail queue, of which the maximum size is 10. A "tcp" agent is attached to n0, and a connection is established to a tcp "sink" agent attached to n3. As default, the maximum size of a packet that a "tcp" agent can generate is 1KByte. A tcp "sink" agent generates and sends ACK packets to the sender (tcp agent) and frees the received packets. A "udp" agent that is attached to n1 is connected to a "null" agent attached to n3. A "null" agent just frees the packets received. A "ftp" and a "cbr" traffic generator are attached to "tcp" and "udp" agents respectively, and the "cbr" is configured to generate 1 KByte packets at the rate of 1 Mbps. The "cbr" is set to start at 0.1 sec and stop at 4.5 sec, and "ftp" is set to start at 1.0 sec and stop at 4.0 sec.
A Simple NS Simulation Script is shown below
set ns [new Simulator]
$ns color 0 blue
$ns color 1 red
$ns color 2 white

set n0 [$ns node]
set n1 [$ns node]
set n2 [$ns node]
set n3 [$ns node]

set f [open out.tr w]
$ns trace-all $f
set nf [open out.nam w]
$ns namtrace-all $nf

$ns duplex-link $n0 $n2 5Mb 2ms DropTail
$ns duplex-link $n1 $n2 5Mb 2ms DropTail
$ns duplex-link $n2 $n3 1.5Mb 10ms DropTail

$ns duplex-link-op $n0 $n2 orient right-up
$ns duplex-link-op $n1 $n2 orient right-down
$ns duplex-link-op $n2 $n3 orient right
$ns duplex-link-op $n2 $n3 queuePos 0.5
set udp0 [new Agent/UDP]
$ns attach-agent $n0 $udp0
set cbr0 [new Application/Traffic/CBR]
$cbr0 attach-agent $udp0
set udp1 [new Agent/UDP]
$ns attach-agent $n3 $udp1
$udp1 set class_ 1
set cbr1 [new Application/Traffic/CBR]
$cbr1 attach-agent $udp1
Set null0 [new Agent/Null]
$ns attach-agent $n3 $null0
set null1 [new Agent/Null]
$ns attach-agent $n1 $null1
$ns connect $udp0 $null0
$ns connect $udp1 $null1
$ns at 1.0 "$cbr0 start"
$ns at 1.1 "$cbr1 start"
set tcp [new Agent/TCP]
$tcp set class_ 2
set sink [new Agent/TCPSink]
$ns attach-agent $n0 $tcp
$ns attach-agent $n3 $sink
$ns connect $tcp $sink
set ftp [new Application/FTP]
$ftp attach-agent $tcp
$ns at 1.2 "$ftp start"
$ns at 1.35 "$ns detach-agent $n0 $tcp ; $ns detach-agent $n3 $sink"
puts [$cbr0 set packetSize_]
puts [$cbr0 set interval_]
$ns at 3.0 "finish"
proc finish {} {
global ns f nf
$ns flush-trace
close $f
close $nf
puts "running nam..."
exec nam out.nam &
exit 0
}
$ns run