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