Plotting X graph in NS2

Description:

     X, Y coordinates points for more than one graph is generated randomly and put it in the trace files. All the trace files are given as input file to xgraph to plot all the graphs in the same plot.

File name: “graph2.tcl”

#-------Event scheduler object creation--------#
set ns [new Simulator]

#Creating nam file:
set nf [open Tcpred.nam w]
$ns namtrace-all $nf

#Open the trace file
set nt [open Tcpred.tr w]
$ns trace-all $nt

# graph procedure..
$ns at 1.0 "Graph"
set g [open graph.tr w]
set g1 [open graph1.tr w]

proc Graph {} {
global ns g g1
set time 1.0
set now [$ns now]
puts $g "[expr rand()*8] [expr rand()*6]"
puts $g1 "[expr rand()*8] [expr rand()*6]"
$ns at [expr $now+$time] "Graph"
}
           
                 
#Finish Procedure..
proc finish {} {
      global ns nf nt
      exec xgraph -brb -geometry 600X500 graph.tr graph1.tr &
      exit 0
      }

#Calling finish procedure
$ns at 5.0 "finish"
$ns run

# How to run
$ns filename.tcl

Plot a graph of node energy from NS2 trace file

use the below awk script to find the energy of node

#!/usr/bin/awk -f
BEGIN{
#print "energy of node 1"
data=0
}

{
if ($1=="N" && $5==0)
{
    print $3,$7
}
}
END{
#print "Completed"
}

save this file as energy.awk

in terminal type

$gawk -f energy.awk "yourtracefile.tr" > node0.dat

on executing this command you'll get a file node0.dat

in terminal

$xgraph -P node0.dat

you'll get a graph

Energy Model for Mobile Nodes ns2

set val(chan)           Channel/WirelessChannel    ;# channel type
set val(prop)           Propagation/TwoRayGround   ;# radio-propagation model
set val(netif)          Phy/WirelessPhy            ;# network interface type
set val(mac)            Mac/802_11                 ;# MAC type
set val(ifq)            Queue/DropTail/PriQueue    ;# interface queue type
set val(ll)             LL                         ;# link layer type
set val(ant)            Antenna/OmniAntenna        ;# antenna model
set val(ifqlen)         5                          ;# max packet in ifq
set val(nn)             6                           ;# number of mobilenodes
set val(rp)             DSR                        ;# routing protocol
set val(x)              750                        ;# X dimension of topography
set val(y)              550                        ;# Y dimension of topography 
set val(stop)         18.0                       ;# time of simulation end
## Create a simulator object(nothing but, a scheduler's object)..
      set ns [new Simulator]
## Create a trace file and nam file..
      set tracefd [open wireless1.tr w]
      set namtrace [open wireless1.nam w]   
## Trace the nam and trace details from the main simulation..
      $ns trace-all $tracefd
      $ns namtrace-all-wireless $namtrace $val(x) $val(y)
## set up topography object..
      set topo [new Topography]
      $topo load_flatgrid $val(x) $val(y)
      set god_ [create-god $val(nn)]
## Color Descriptions..
      $ns color 1 dodgerblue
      $ns color 2 blue
      $ns color 3 cyan
      $ns color 4 green
      $ns color 5 yellow
      $ns color 6 black
      $ns color 7 magenta
      $ns color 8 gold
      $ns color 9 red
     
# Setting The Distance Variables..
# For model 'TwoRayGround'
      set dist(5m)  7.69113e-06
      set dist(9m)  2.37381e-06
      set dist(10m) 1.92278e-06
      set dist(11m) 1.58908e-06
      set dist(12m) 1.33527e-06
      set dist(13m) 1.13774e-06
      set dist(14m) 9.81011e-07
      set dist(15m) 8.54570e-07
      set dist(16m) 7.51087e-07
      set dist(20m) 4.80696e-07
      set dist(25m) 3.07645e-07
      set dist(30m) 2.13643e-07
      set dist(35m) 1.56962e-07
      set dist(40m) 1.56962e-10
      set dist(45m) 1.56962e-11
      set dist(50m) 1.20174e-13
      #Phy/WirelessPhy set CSThresh_ $dist(50m)
      #Phy/WirelessPhy set RXThresh_ $dist(50m)
## Setting node config event with set of inputs..
      puts "Node Configuration Started here...\n \
                   -channel $val(chan) \n \
                   -adhocRouting $val(rp) \n \
                   -llType $val(ll) \n \
                   -macType $val(mac) \n \
                   -ifqType $val(ifq) \n \
                   -ifqLen $val(ifqlen) \n \
                   -antType $val(ant) \n \
                   -propType $val(prop) \n \
                   -phyType $val(netif) \n"
                     
        $ns node-config -adhocRouting $val(rp) \
                   -llType $val(ll) \
                   -macType $val(mac) \
                   -ifqType $val(ifq) \
                   -ifqLen $val(ifqlen) \
                   -antType $val(ant) \
                   -propType $val(prop) \
                   -phyType $val(netif) \
                   -channelType $val(chan) \
                   -topoInstance $topo \
                   -agentTrace ON \
                   -routerTrace ON \
                   -macTrace OFF \
                   -movementTrace ON
# Energy model
      $ns node-config  -energyModel EnergyModel \
                        -initialEnergy 20 \
                        -txPower 0.9 \
                        -rxPower 0.8 \
                        -idlePower 0.0 \
                        -sensePower 0.0175
## Creating node objects..               
      for {set i 0} {$i < $val(nn) } { incr i } {
            set node_($i) [$ns node]     
      }
for {set i 0} {$i < $val(nn)} {incr i} {
      $node_($i) color darkgreen
      $ns at 0.0 "$node_($i) color darkgreen"
      }
## Provide initial location of mobilenodes..
           
      if {$val(nn) >0} {
            for {set i 1} {$i < $val(nn) } { incr i } {
                  set xx [expr rand()*600]                 
                  set yy [expr rand()*500];
                  $node_($i) set X_ $xx
                  $node_($i) set Y_ $yy
            }
      }
## set god distance..
      $god_ set-dist 0 1 2
      $god_ set-dist 0 2 2
      $god_ set-dist 0 3 2
      $god_ set-dist 0 4 1
      $god_ set-dist 0 5 2
      $god_ set-dist 1 2 3
      $god_ set-dist 1 3 3
     
## Define node initial position in nam..
      for {set i 0} {$i < $val(nn)} { incr i } {
      # 30 defines the node size for nam..
            $ns initial_node_pos $node_($i) 30
      }
## Telling nodes when the simulation ends..
for {set i 0} {$i < $val(nn) } { incr i } {
    $ns at $val(stop) "$node_($i) reset";
}
## Ending nam and the simulation..
$ns at $val(stop) "$ns nam-end-wireless $val(stop)"
$ns at $val(stop) "stop"
$ns at 16.01 "puts \"end simulation\" " ;# $ns halt

## Stop procedure..
proc stop {} {
    global ns tracefd namtrace
    $ns flush-trace
    close $tracefd
    close $namtrace
    exec nam wireless1.nam &
    exit 0
}
$ns run

ns2 program for calculating bandwidth using xgraph

#Create a simulator object

set ns [new Simulator]



#Open the output files

set f0 [open out0.tr w]

set f1 [open out1.tr w]

set f2 [open out2.tr w]



#Create 5 nodes

set n0 [$ns node]

set n1 [$ns node]

set n2 [$ns node]

set n3 [$ns node]

set n4 [$ns node]



#Connect the nodes

$ns duplex-link $n0 $n3 1Mb 100ms DropTail

$ns duplex-link $n1 $n3 1Mb 100ms DropTail

$ns duplex-link $n2 $n3 1Mb 100ms DropTail

$ns duplex-link $n3 $n4 1Mb 100ms DropTail



#Define a 'finish' procedure

proc finish {} {

    global f0 f1 f2

    #Close the output files

    close $f0

    close $f1

    close $f2

    #Call xgraph to display the results

    exec xgraph out0.tr out1.tr out2.tr -geometry 800x400 &

        exit 0

}





#Define a procedure that attaches a UDP agent to a previously created node

#'node' and attaches an Expoo traffic generator to the agent with the

#characteristic values 'size' for packet size 'burst' for burst time,

#'idle' for idle time and 'rate' for burst peak rate. The procedure connects

#the source with the previously defined traffic sink 'sink' and returns the

#source object.

proc attach-expoo-traffic { node sink size burst idle rate } {

    #Get an instance of the simulator

    set ns [Simulator instance]



    #Create a UDP agent and attach it to the node

    set source [new Agent/UDP]

    $ns attach-agent $node $source



    #Create an Expoo traffic agent and set its configuration parameters

    set traffic [new Application/Traffic/Exponential]

    $traffic set packetSize_ $size

    $traffic set burst_time_ $burst

    $traffic set idle_time_ $idle

    $traffic set rate_ $rate

        

        # Attach traffic source to the traffic generator

        $traffic attach-agent $source

    #Connect the source and the sink

    $ns connect $source $sink

    return $traffic

}





#Define a procedure which periodically records the bandwidth received by the

#three traffic sinks sink0/1/2 and writes it to the three files f0/1/2.

proc record {} {

        global sink0 sink1 sink2 f0 f1 f2

    #Get an instance of the simulator

    set ns [Simulator instance]

    #Set the time after which the procedure should be called again

        set time 0.5

    #How many bytes have been received by the traffic sinks?

        set bw0 [$sink0 set bytes_]

        set bw1 [$sink1 set bytes_]

        set bw2 [$sink2 set bytes_]

    #Get the current time

        set now [$ns now]

    #Calculate the bandwidth (in MBit/s) and write it to the files

        puts $f0 "$now [expr $bw0/$time*8/1000000]"

        puts $f1 "$now [expr $bw1/$time*8/1000000]"

        puts $f2 "$now [expr $bw2/$time*8/1000000]"

    #Reset the bytes_ values on the traffic sinks

        $sink0 set bytes_ 0

        $sink1 set bytes_ 0

        $sink2 set bytes_ 0

    #Re-schedule the procedure

        $ns at [expr $now+$time] "record"

}





#Create three traffic sinks and attach them to the node n4

set sink0 [new Agent/LossMonitor]

set sink1 [new Agent/LossMonitor]

set sink2 [new Agent/LossMonitor]

$ns attach-agent $n4 $sink0

$ns attach-agent $n4 $sink1

$ns attach-agent $n4 $sink2



#Create three traffic sources

set source0 [attach-expoo-traffic $n0 $sink0 200 2s 1s 100k]

set source1 [attach-expoo-traffic $n1 $sink1 200 2s 1s 200k]

set source2 [attach-expoo-traffic $n2 $sink2 200 2s 1s 300k]



#Start logging the received bandwidth

$ns at 0.0 "record"

#Start the traffic sources

$ns at 10.0 "$source0 start"

$ns at 10.0 "$source1 start"

$ns at 10.0 "$source2 start"

#Stop the traffic sources

$ns at 50.0 "$source0 stop"

$ns at 50.0 "$source1 stop"

$ns at 50.0 "$source2 stop"

#Call the finish procedure after 60 seconds simulation time

$ns at 60.0 "finish"



#Run the simulation

$ns run

Node color in ns2

Node color can be set as follows

$ns at 0.0 "$node_(0) color black"

Available colors

Black, Blue, dodgerblue, violet, darkviolet, Red, pink, Yellow, Orange, green, darkgreen, magenta, dark magenta, brown

ns2 program for wireless data transfer with xgraph

set ns [new Simulator]

set tf [open tf.tr w]
set ntf [open ntf.nam w]

$ns trace-all $tf
$ns namtrace-all-wireless $ntf 600 600

set topo [new Topography]

$topo load_flatgrid 600 600

create-god 500

$ns node-config -adhocRouting AODV
$ns node-config -antType Antenna/OmniAntenna
$ns node-config -propType Propagation/TwoRayGround
$ns node-config -channelType Channel/WirelessChannel
$ns node-config -macType Mac/802_11
$ns node-config -phyType Phy/WirelessPhy
$ns node-config -ifqType Queue/DropTail/PriQueue
$ns node-config -ifqLen 50
$ns node-config -llType LL
$ns node-config -topoInstance $topo
$ns node-config -macTrace ON
$ns node-config -movementTrace ON
$ns node-config -agentTrace ON
$ns node-config -routerTrace ON

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

$n0 set X_ 100
$n0 set Y_ 50
$n0 set Z_ 0.0
$ns initial_node_pos $n0 20

$n1 set X_ 50
$n1 set Y_ 150
$n1 set Z_ 0.0
$ns initial_node_pos $n1 20

$n2 set X_ 200
$n2 set Y_ 50
$n2 set Z_ 0.0
$ns initial_node_pos $n2 20

$n3 set X_ 100
$n3 set Y_ 300
$n3 set Z_ 0.0
$ns initial_node_pos $n3 20

$n4 set X_ 150
$n4 set Y_ 100
$n4 set Z_ 0.0
$ns initial_node_pos $n4 20

$n5 set X_ 200
$n5 set Y_ 30
$n5 set Z_ 0.0
$ns initial_node_pos $n5 20


set udp0 [new Agent/UDP]
set sink0 [new Agent/LossMonitor]
set vbr0 [new Application/Traffic/Exponential]
set udp1 [new Agent/UDP]
set sink1 [new Agent/LossMonitor]
set vbr1 [new Application/Traffic/Exponential]


$ns attach-agent $n4 $udp0
$ns attach-agent $n0 $sink0
$vbr0 attach-agent $udp0
$vbr0 set packetSize_ 200
$vbr0 set idle_time_ 12ms
$vbr0 set burst_time_ 20ms
$vbr0 set rate_ 100k
$ns attach-agent $n3 $udp1
$ns attach-agent $n0 $sink1
$vbr1 attach-agent $udp1
$vbr1 set packetSize_ 200
$vbr1 set idle_time_ 12ms
$vbr1 set burst_time_ 20ms
$vbr1 set rate_ 100k

$ns connect $udp0 $sink0
$ns connect $udp1 $sink1


set a1 [open a1.tr w]
set a2 [open a2.tr w]
set a3 [open a3.tr w]
set a4 [open a4.tr w]
set a5 [open a5.tr w]
set a6 [open a6.tr w]


proc record {} {

global ns sink0 sink1
global a1 a2 a3 a4 a5 a6
set time 0.5
set now [$ns now]

set bw1 [$sink0 set bytes_]
set bw2 [$sink0 set npkts_]
set bw3 [$sink0 set lastPktTime_]
set bw4 [$sink1 set bytes_]
set bw5 [$sink1 set npkts_]
set bw6 [$sink1 set lastPktTime_]

puts $a1 "$now [expr $bw1/$time*8/1000]"
puts $a2 "$now $bw2"
puts $a3 "$now $bw3"
puts $a4 "$now [expr $bw4/$time*8/1000]"
puts $a5 "$now $bw5"
puts $a6 "$now $bw6"

$sink0 set bytes_ 0
$sink0 set npkts_ 0
$sink0 set nlost_ 0
$sink1 set bytes_ 0
$sink1 set npkts_ 0
$sink1 set nlost_ 0

$ns at [expr $now+$time] "record"

}


proc finish {} {

global ns tf ntf  a1 a2 a3 a4 a5 a6
$ns flush-trace
close $tf
close $ntf
close $a1
close $a2
close $a3
close $a4
close $a5
close $a6
exec nam ntf.nam &
exec xgraph a1.tr a2.tr a3.tr a4.tr a5.tr a6.tr &
exit 0
}

$ns at 0.0 "$vbr0 start"
$ns at 0.3 "record"

$ns at 20.0 "$vbr0 stop"
$ns at 20.1 "finish"
$ns at 0.0 "$vbr1 start"
$ns at 0.3 "record"

$ns at 20.0 "$vbr1 stop"
$ns at 20.1 "finish"
$ns run

Ns2 progrm with data trnsmission shown in color

# Create a simulator object
set ns [new Simulator]
 
# Define different colors 
# for data flows (for NAM)
$ns color 1 Blue
$ns color 2 Red
 
# Open the NAM trace file
set nf [open out.nam w]
$ns namtrace-all $nf
 
# Define a 'finish' procedure

proc finish {} {

global ns nf
$ns flush-trace
close $nf
exec nam out.nam &
exit 0
}
 
# Create four nodes
set n0 [$ns node]
set n1 [$ns node]
set n2 [$ns node]
set n3 [$ns node]
 
# Create links between the nodes
$ns duplex-link $n0 $n2 2Mb 10ms DropTail
$ns duplex-link $n1 $n2 2Mb 10ms DropTail
$ns duplex-link $n2 $n3 1.7Mb 20ms DropTail
 
# Set Queue Size of link (n2-n3) to 10
$ns queue-limit $n2 $n3 10
 
# Give node position (for NAM)
$ns duplex-link-op $n0 $n2 orient right-down
$ns duplex-link-op $n1 $n2 orient right-up
$ns duplex-link-op $n2 $n3 orient right
 
# Monitor the queue for link (n2-n3). (for NAM)
$ns duplex-link-op $n2 $n3 queuePos 0.5
 
 
# Setup a TCP connection
set tcp [new Agent/TCP]
$tcp set class_ 2
$ns attach-agent $n0 $tcp
 
set sink [new Agent/TCPSink]
$ns attach-agent $n3 $sink
$ns connect $tcp $sink
$tcp set fid_ 1
 
# Setup a FTP over TCP connection
set ftp [new Application/FTP]
$ftp attach-agent $tcp
$ftp set type_ FTP
 
 
# Setup a UDP connection
set udp [new Agent/UDP]
$ns attach-agent $n1 $udp
set null [new Agent/Null]
 
$ns attach-agent $n3 $null
$ns connect $udp $null
$udp set fid_ 2
 
# Setup a CBR over UDP connection
set cbr [new Application/Traffic/CBR]
$cbr attach-agent $udp
$cbr set type_ CBR
$cbr set packet_size_ 1000
$cbr set rate_ 1mb
$cbr set random_ false
 
 
# Schedule events for the CBR and FTP agents
$ns at 0.1 "$cbr start"
$ns at 1.0 "$ftp start"
$ns at 4.0 "$ftp stop"
$ns at 4.5 "$cbr stop"
 
# Detach tcp and sink agents
# (not really necessary)
$ns at 4.5 "$ns detach-agent $n0 $tcp ; $ns detach-agent $n3 $sink"
 
# Call the finish procedure after
# 5 seconds of simulation time
$ns at 5.0 "finish"
 
# Print CBR packet size and interval
puts "CBR packet size = [$cbr set packet_size_]"
puts "CBR interval = [$cbr set interval_]"
 
# Run the simulation
$ns run

Simple Script explanation

To start we have to set a few variables like simulator object, trace file and object, nam file and object.

set ns [new Simulator]

This would set the simulator with the simulator object which is to be accessed in the script.

set nf [open out.nam w]

$ns namtrace-all $nf

This would set the nam file (network animation file) with the object and connect to ns.

set tr [open out.tr w]

$ns trace-all $tr

This would set the trace file and would connect to the simulator. The trace file is required to analyze the various packets which are send, received type of application used etc.

set n0 [$ns node]

Now the nodes could be set as many as you want, for loop could be used if many nodes are to be made.

$ns duplex-link $n0 $n1 10Mb 10ms DropTail

The connection for the various nodes with each other with the band width and rate.

$ns duplex-link-op $n0 $n1 orient right-up

The nodes could be given with various orientations with this option. right, right-up and right down could be used depending on the node.

For the application like tcp or udp to run, we need to set two agents and the application which should run in between.

When using tcp, we have ftp as the application and tcpsink as the end agent. connection must be made between tcp and tcpsink, same in udp with cbr and null respectively.

set tcp [new Agent/TCP]
$ns attach-agent $n0 $tcp

This would make a tcp agent and connect it with the node.

set ftp [new Application/FTP]
$ftp attach-agent $tcp

Now the ftp is connected with the tcp

set agent [new Agent/TCPSink]

$ns attach-agent $n3 $sink

Now the tcpsink is set to a node where the tcp packets are received.

The tcp and sink (agents) needs to be connected, such that the network flows.

$ns connect $tcp $sink

Same for udp

set udp [new Agent/UDP]
$ns attach-agent $n2 $udp

set cbr [new Application/Traffic/CBR]
$cbr attach-agent $udp

set null [new Agent/Null]
$ns attach-agent $n3 $null

$ns connect $udp $null

We can use the routing protocols in the simulator using rtmodel (to break the link), rtproto (to use the protocol)

$ns rtmodel-at 1.0 down $n1 $n2

$ns rtmodel-at 2.0 up $n1 $n3

For distance vector we could use

$ns rtproto DV

For linkstate we could use

$ns rtproto LS

When all this is done the tcp could be started at some point and could call the finish procedure to end. 

The out.tr file is used to trace the packets. A normal awk command could be used to analyse the packets.

$ns at 0.0 "$ftp start"
$ns at 0.0 "$cbr start"

$ns at 5.0 "finish"

We could also stop the tcp or udp in between using stop instead of start, hence nam out.nam need to be used if finish is not used.

run is used to run the whole simulation.

$ns run

The file should be saved in .tcl format and should use ns filename.tcl to run