Computer Networks Lab (17CSL57)
Note: Multiple spaces are used in the program to improve readability. Use single spaces for
execution.
1. Implement three nodes point-to-point network with duplex links between them.
Set the queue size, vary the bandwidth and find the number of packets dropped.
gedit program1.tcl Create a Simulator object and give it a name “ns”
Opens file program1.nam in “write” mode and assigns it a
set ns [new Simulator]
pointer “nf”
Record all simulation traces in NAM input format
set nf [open program1.nam w]
$ns namtrace-all $nf
Create a data trace file “program1.tr” & assign it a pointer “tf”
set tf [open program1.tr w]
$ns trace-all $tf The traces will go to the file program1.tr pointed by “tf”
“proc” - declares a procedure “finish”
proc finish {} {
“global” - tells that we are using variables declared outside
global ns nf tf the procedure.
$ns flush-trace “flush-trace” – a simulator method to dump the traces on
close $tf the respective files.
exec nam program1.nam & “close” - closes the trace files defined before
exit 0 “exec” executes the nam program for visualization.
} “exit 0” - ends the application and return the number 0
(clean exit) as status to the system.
set n0 [$ns node] Creates a node pointed by “n0”. To refer this node
set n1 [$ns node] in the script, we should use “$n0”
set n2 [$ns node] $n0 and $n2 are connected using bidirectional link with
set n3 [$ns node] bandwidth = 200 Mb, Propagation delay=10ms, Droptail –
the way to handle buffer overflow. If there is an overflow,
last packet to arrive is dropped.
$ns duplex-link $n0 $n2 200Mb 10ms DropTail
Shylaja B, Asst. Prof, Dept of CSE, DSATM 1 2019-20
Computer Networks Lab (17CSL57)
$ns duplex-link $n1 $n2 100Mb 5ms DropTail
$ns duplex-link $n2 $n3 1Mb 1000ms DropTail
$ns queue-limit $n0 $n2 10 Buffer capacity from node 0 to node 2 = 10 packets
$ns queue-limit $n1 $n2 10
set udp0 [new Agent/UDP] Create a UDP agent, assign it a name “udp0”
$ns attach-agent $n0 $udp0 Attach $udp0 to node 0 ($n0)
For actual data to flow, we need traffic generators.
They simulate some application traffic. Ex: CBR
set cbr0 [new Application/Traffic/CBR]
Creating CBR (Constant Bit Rate) agent cbr0,
$cbr0 set packetSize_ 500 set the packet size, packet interval.
$cbr0 set interval_ 0.005
$cbr0 attach-agent $udp0 Attach the CBR agent $cbr0 to UDP agent $udp0.
set udp1 [new Agent/UDP]
$ns attach-agent $n1 $udp1
set cbr1 [new Application/Traffic/CBR]
$cbr1 attach-agent $udp1
set udp2 [new Agent/UDP]
$ns attach-agent $n2 $udp2
set cbr2 [new Application/Traffic/CBR]
$cbr2 attach-agent $udp2
Create a null agent null0 which acts as traffic sink
(receiver)
set null0 [new Agent/Null]
Attach null agent $null0 to node n3
$ns attach-agent $n3 $null0
In UDP communication, data flows from UDP
$ns connect $udp0 $null0 agent to Null agent. So connect udp agent to null
$ns connect $udp1 $null0 agent.
Shylaja B, Asst. Prof, Dept of CSE, DSATM 2 2019-20
Computer Networks Lab (17CSL57)
$ns at 0.1 "$cbr0 start"
Start the event scheduler
$ns at 0.2 "$cbr1 start"
$ns at 1.0 "finish" Call the finish procedure defined
earlier
$ns run
Begin the simulation
gedit program1.awk
BEGIN { c=0;
}
{
if ($1=="d")
{
c++;
printf("%s\t %s\n",$5,$11);
}
}
END{
printf("The number of packets dropped =%d\n",c);
}
Execution Commands:
ns program1.tcl
awk -f program1.awk program1.tr
Shylaja B, Asst. Prof, Dept of CSE, DSATM 3 2019-20
Computer Networks Lab (17CSL57)
2. Implement transmission of ping messages/trace route over a network topology
consisting of 6 nodes and find the number of packets dropped due to congestion.
gedit program2.tcl
set ns [new Simulator]
set nf [open program2.nam w]
$ns namtrace-all $nf
set tf [open program2.tr w]
$ns trace-all $tf
set n0 [$ns node]
set n1 [$ns node]
set n2 [$ns node]
set n3 [$ns node]
set n4 [$ns node]
set n5 [$ns node]
$n4 shape box Square shape for node 4. By default, nodes are circular shaped
$ns duplex-link $n0 $n4 1005Mb 1ms DropTail
$ns duplex-link $n1 $n4 50Mb 1ms DropTail
$ns duplex-link $n2 $n4 2000Mb 1ms DropTail
$ns duplex-link $n3 $n4 200Mb 1ms DropTail
$ns duplex-link $n4 $n5 1Mb 1ms DropTail
set p1 [new Agent/Ping] Create a ping agent ‘p1’ and attach it to node 0.
$ns attach-agent $n0 $p1 Ping is a subclass of class Agent. It ensures that a
host computer the user is trying to reach is
$p1 set packetSize_ 50000
actually operating by sending an ICMP echo
$p1 set interval_ 0.0001 request and waits for a reply.
Shylaja B, Asst. Prof, Dept of CSE, DSATM 4 2019-20
Computer Networks Lab (17CSL57)
set p2 [new Agent/Ping]
$ns attach-agent $n1 $p2
set p3 [new Agent/Ping]
$ns attach-agent $n2 $p3
$p3 set packetSize_ 30000
$p3 set interval_ 0.00001
set p4 [new Agent/Ping]
$ns attach-agent $n3 $p4
instproc – adds class methods
$self – similar to “this” in java, C++ (Holds the
set p5 [new Agent/Ping] address of the current object)
$ns attach-agent $n5 $p5 instvar – adds instance variables and brings them
to the local scope
$ns queue-limit $n0 $n4 5 node_ - To get the node ID for the node the
$ns queue-limit $n2 $n4 3 agent is attached to. It is a member variable of
the base class ‘Agent’
$ns queue-limit $n4 $n5 2
instproc recv allows the user to react to the ping
result
Agent/Ping instproc recv {from rtt} {
$self instvar node_
puts "node [$node_ id] received answer from $from with round trip time $rtt msec"
}
$ns connect $p1 $p5
$ns connect $p3 $p4
$ns connect $p2 $p5
proc finish { } {
global ns nf tf
Shylaja B, Asst. Prof, Dept of CSE, DSATM 5 2019-20
Computer Networks Lab (17CSL57)
$ns flush-trace
close $nf
close $tf
exec nam program2.nam &
exit 0
}
$ns at 0.1 "$p1 send"
$ns at 0.2 "$p1 send"
$ns at 0.3 "$p1 send"
$ns at 0.4 "$p1 send"
$ns at 0.5 "$p1 send"
$ns at 0.6 "$p1 send"
$ns at 0.7 "$p1 send"
$ns at 0.8 "$p1 send"
$ns at 0.9 "$p1 send"
$ns at 1.0 "$p1 send"
$ns at 1.1 "$p1 send"
$ns at 1.2 "$p1 send"
$ns at 1.3 "$p1 send"
$ns at 1.4 "$p1 send"
$ns at 1.5 "$p1 send"
$ns at 1.6 "$p1 send"
$ns at 1.7 "$p1 send"
$ns at 1.8 "$p1 send"
$ns at 1.9 "$p1 send"
$ns at 2.0 "$p1 send"
$ns at 2.1 "$p1 send"
$ns at 2.2 "$p1 send"
$ns at 2.3 "$p1 send"
Shylaja B, Asst. Prof, Dept of CSE, DSATM 6 2019-20
Computer Networks Lab (17CSL57)
$ns at 2.4 "$p1 send"
$ns at 2.5 "$p1 send"
$ns at 2.6 "$p1 send"
$ns at 2.7 "$p1 send"
$ns at 2.8 "$p1 send"
$ns at 2.9 "$p1 send"
$ns at 0.1 "$p3 send"
$ns at 0.2 "$p3 send"
$ns at 0.3 "$p3 send"
$ns at 0.4 "$p3 send"
$ns at 0.5 "$p3 send"
$ns at 0.6 "$p3 send"
$ns at 0.7 "$p3 send"
$ns at 0.8 "$p3 send"
$ns at 0.9 "$p3 send"
$ns at 1.0 "$p3 send"
$ns at 1.1 "$p3 send"
$ns at 1.2 "$p3 send"
$ns at 1.3 "$p3 send"
$ns at 1.4 "$p3 send"
$ns at 1.5 "$p3 send"
$ns at 1.6 "$p3 send"
$ns at 1.7 "$p3 send"
$ns at 1.8 "$p3 send"
$ns at 1.9 "$p3 send"
$ns at 2.0 "$p3 send"
$ns at 2.1 "$p3 send"
$ns at 2.2 "$p3 send"
$ns at 2.3 "$p3 send"
$ns at 2.4 "$p3 send"
Shylaja B, Asst. Prof, Dept of CSE, DSATM 7 2019-20
Computer Networks Lab (17CSL57)
$ns at 2.5 "$p3 send"
$ns at 2.6 "$p3 send"
$ns at 2.7 "$p3 send"
$ns at 2.8 "$p3 send"
$ns at 2.9 "$p3 send"
$ns at 3.0 "finish"
$ns run
gedit program2.awk
BEGIN{
drop=0;
}
{
if($1=="d")
{
drop++;
}
}END{
printf("total number of %s packets dropped due to congestion= %d \n",$5,drop);
}
Execution Commands:
ns program2.tcl
awk -f program2.awk program2.tr
Shylaja B, Asst. Prof, Dept of CSE, DSATM 8 2019-20
Computer Networks Lab (17CSL57)
3. Implement an Ethernet LAN using n nodes and set multiple traffic nodes and plot
congestion window for different source / destination.
gedit program3.tcl
set ns [new Simulator]
set tf [open program3.tr w]
$ns trace-all $tf
set nf [open program3.nam w]
$ns namtrace-all $nf
set n0 [$ns node]
$n0 color "magenta"
$n0 label "src1"
set n1 [$ns node]
set n2 [$ns node]
$n2 color "magenta"
$n2 label "src2"
set n3 [$ns node]
$n3 color "blue"
$n3 label "dest2"
set n4 [$ns node]
set n5 [$ns node]
$n5 color "blue" Creates a LAN from a set of nodes given by
<node_list>, Bandwidth, Delay, Link Layer,
$n5 label "dest1"
Interface Queue, MAC Layer
$ns make-lan "$n0 $n1 $n2 $n3 $n4" 100Mb 100ms LL Queue/DropTail Mac/802_3
$ns duplex-link $n4 $n5 1Mb 1ms DropTail
Shylaja B, Asst. Prof, Dept of CSE, DSATM 9 2019-20
Computer Networks Lab (17CSL57)
Create a TCP sending module tcp0
set tcp0 [new Agent/TCP]
Attach $tcp0 to node $n0
$ns attach-agent $n0 $tcp0
Create an FTP traffic generator, ftp0
set ftp0 [new Application/FTP]
$ftp0 attach-agent $tcp0 Attach $ftp0 to $tcp0
$ftp0 set packetSize_ 500
$ftp0 set interval_ 0.0001
set sink5 [new Agent/TCPSink] Create a TCP sink agent sink5 which act as
traffic sink (receiver)
$ns attach-agent $n5 $sink5 Attach it to node n5
$ns connect $tcp0 $sink5 Connect two agents with each other
set tcp2 [new Agent/TCP]
$ns attach-agent $n2 $tcp2
set ftp2 [new Application/FTP]
$ftp2 attach-agent $tcp2
$ftp2 set packetSize_ 600
$ftp2 set interval_ 0.001
set sink3 [new Agent/TCPSink]
$ns attach-agent $n3 $sink3
$ns connect $tcp2 $sink3
set file1 [open file1.tr w]
$tcp0 attach $file1
set file2 [open file2.tr w]
$tcp2 attach $file2
Shylaja B, Asst. Prof, Dept of CSE, DSATM 10 2019-20
Computer Networks Lab (17CSL57)
$tcp0 trace cwnd_ cwnd_ Contains Congestion Window
size of the TCP module
$tcp2 trace cwnd_
(Congestion Window – is a TCP state
proc finish { } { variable that limits the amount of
data the TCP can send into the
global ns nf tf
network before receiving an ACK)
$ns flush-trace
close $tf
close $nf
exec nam program3.nam &
exit 0
}
$ns at 0.1 "$ftp0 start"
$ns at 5 "$ftp0 stop"
$ns at 7 "$ftp0 start"
$ns at 0.2 "$ftp2 start"
$ns at 8 "$ftp2 stop"
$ns at 14 "$ftp0 stop"
$ns at 10 "$ftp2 start"
$ns at 15 "$ftp2 stop"
$ns at 16 "finish"
$ns run
gedit program3.awk
BEGIN {
}
{
if($6=="cwnd_")
printf("%f \t %f\t \n",$1,$7);
}
END{
}
Shylaja B, Asst. Prof, Dept of CSE, DSATM 11 2019-20
Computer Networks Lab (17CSL57)
Execution Commands:
ns program3.tcl
awk -f program3.awk file1.tr > a1
awk -f program3.awk file2.tr > a2
xgraph a1 a2
Shylaja B, Asst. Prof, Dept of CSE, DSATM 12 2019-20
Computer Networks Lab (17CSL57)
4. Implement simple ESS and with transmitting nodes in wire-less LAN by simulation and
determine the performance with respect to transmission of packets.
gedit program4.tcl
set ns [new Simulator]
set tf [open program4.tr w]
$ns trace-all $tf
set topo [new Topography] Create a flat topology in a 1000 X 1000 m
$topo load_flatgrid 1000 1000 area
set nf [open p4.nam w]
$ns namtrace-all-wireless $nf 1000 1000
$ns node-config -adhocRouting DSDV\ Using Adhoc Routing Protocol DSDV (
Destination Sequence Distance
-llType LL\ Logical Link Vector)
-macType Mac/802_11\
-ifqType Queue/DropTail\
-ifqLen 50\ Queue Length
-phyType Phy/WirelessPhy\ Physical Layer Type
-channelType Channel/WirelessChannel\
-propType Propagation/TwoRayGround\ TwoRayGround – The phenomenon of
reflection from the ground and the
-antType Antenna/OmniAntenna\ antenna heights above the ground is
-topoInstance $topo\ considered in addition to Line-of-Sight
(LOS) path between the transmitter and
-agentTrace ON\
the receiver.
-routerTrace ON
god (General Operations Director ) is the object to
create-god 3 store global information about the state of the
environment, network or nodes.
set n0 [$ns node] value 3 – indicates the number of mobile nodes
set n1 [$ns node]
set n2 [$ns node]
Shylaja B, Asst. Prof, Dept of CSE, DSATM 13 2019-20
Computer Networks Lab (17CSL57)
$n0 label "tcp0"
$n1 label "sink1/tcp1"
$n2 label "sink2"
$n0 set X_ 50 Set the coordinates for node 0
$n0 set Y_ 50
$n0 set Z_ 0
$n1 set X_ 100
$n1 set Y_ 100
$n1 set Z_ 0
setdest – to generate the positions of nodes &
$n2 set X_ 600
their moving speed.
$n2 set Y_ 600
setdest 50 50 15 (X Y Speed in m/s)
$n2 set Z_ 0
$ns at 0.1 "$n0 setdest 50 50 15"
$ns at 0.1 "$n1 setdest 100 100 25"
$ns at 0.1 "$n2 setdest 600 600 25"
set tcp0 [new Agent/TCP]
$ns attach-agent $n0 $tcp0
set ftp0 [new Application/FTP]
$ftp0 attach-agent $tcp0
set sink1 [new Agent/TCPSink]
$ns attach-agent $n1 $sink1
Shylaja B, Asst. Prof, Dept of CSE, DSATM 14 2019-20
Computer Networks Lab (17CSL57)
$ns connect $tcp0 $sink1
set tcp1 [new Agent/TCP]
$ns attach-agent $n1 $tcp1
set ftp1 [new Application/FTP]
$ftp1 attach-agent $tcp1
set sink2 [new Agent/TCPSink]
$ns attach-agent $n2 $sink2
$ns connect $tcp1 $sink2
$ns at 5 "$ftp0 start"
$ns at 5 "$ftp1 start"
$ns at 100 "$n1 setdest 550 550 15"
$ns at 190 "$n1 setdest 70 70 15"
proc finish { } {
global ns nf tf
$ns flush-trace
exec nam program4.nam &
close $tf
exit 0
}
$ns at 250 "finish"
$ns run
Shylaja B, Asst. Prof, Dept of CSE, DSATM 15 2019-20
Computer Networks Lab (17CSL57)
gedit program4.awk
BEGIN{
count1=0 count2=0 pack1=0 pack2=0 time1=0 time2=0
}
{
if($1=="r" && $3=="_1_" && $4=="AGT")
{
count1++
pack1=pack1+$8
time1=$2
}
if($1=="r" && $3=="_2_" && $4=="AGT")
{
count2++
pack2=pack2+$8
time2=$2
}
}
END{
printf("The throughput from n0 to n1 : %f Mbps \n " , ( (count1*pack1*8) /
(time1*1000000) ) );
printf("The throughput from n0 to n2 : %f Mbps \n " , ( (count2*pack2*8) /
(time2*1000000) ) );
}
Execution Commands:
ns program4.tcl
awk -f program4.awk program4.tr
Shylaja B, Asst. Prof, Dept of CSE, DSATM 16 2019-20
Computer Networks Lab (17CSL57)
5. Implement and study the performance of GSM on NS2/NS3 (Using MAC layer) or
equivalent environment.
gedit program5.tcl
bwDL – Down Link Bandwidth in bps- from the Base
Station to the Mobile Station (downlink)
set bwDL(gsm) 9600
bwUL – Up Link Bandwidth - from the Mobile Station
set bwUL(gsm) 9600 to the Base Station (uplink)
set propDL(gsm) .500
propDL – Downlink Propagation Delay in seconds
set propUL(gsm) .500
propUL – Uplink Propagation Delay
set buf(gsm) 10
set ns [new Simulator]
set nt [open program5.tr w]
$ns trace-all $nt
set nodes(c1) [$ns node] Create nodes
set nodes(ms) [$ns node] Two Cellular Phones (c1 , c2)
Two Base Stations (bs1 , bs2)
set nodes(bs1) [$ns node]
One Mobile Station (ms)
set nodes(bs2) [$ns node]
set nodes(c2) [$ns node]
Define a procedure to create topology
proc cell_topo {} {
global ns nodes
Shylaja B, Asst. Prof, Dept of CSE, DSATM 17 2019-20
Computer Networks Lab (17CSL57)
$ns duplex-link $nodes(c1) $nodes(bs1) 3Mbps 10ms DropTail
$ns duplex-link $nodes(bs1) $nodes(ms) 1 1 RED
$ns duplex-link $nodes(ms) $nodes(bs2) 1 1 RED
$ns duplex-link $nodes(bs2) $nodes(c2) 3Mbps 50ms DropTail
}
RED (Random Early Detection) – Drops
the packets before the buffer is full.
switch gsm { Uses predictive models to decide which
packets to drop.
gsm -
gprs -
create topology
umts {cell_topo}
}
$ns bandwidth $nodes(bs1) $nodes(ms) $bwDL(gsm) simplex
$ns bandwidth $nodes(ms) $nodes(bs1) $bwUL(gsm) simplex
$ns bandwidth $nodes(bs2) $nodes(ms) $bwDL(gsm) simplex
$ns bandwidth $nodes(ms) $nodes(bs2) $bwUL(gsm) simplex
$ns delay $nodes(bs1) $nodes(ms) $propDL(gsm) simplex
$ns delay $nodes(ms) $nodes(bs1) $propDL(gsm) simplex
$ns delay $nodes(bs2) $nodes(ms) $propDL(gsm) simplex
$ns delay $nodes(ms) $nodes(bs2) $propDL(gsm) simplex
$ns queue-limit $nodes(bs1) $nodes(ms) $buf(gsm)
$ns queue-limit $nodes(ms) $nodes(bs1) $buf(gsm)
$ns queue-limit $nodes(bs2) $nodes(ms) $buf(gsm)
$ns queue-limit $nodes(ms) $nodes(bs2) $buf(gsm) Inserting delay for
Channel Allocation
$ns insert-delayer $nodes(ms) $nodes(bs1) [new Delayer]
$ns insert-delayer $nodes(bs1) $nodes(ms) [new Delayer]
$ns insert-delayer $nodes(ms) $nodes(bs2) [new Delayer]
Shylaja B, Asst. Prof, Dept of CSE, DSATM 18 2019-20
Computer Networks Lab (17CSL57)
$ns insert-delayer $nodes(bs2) $nodes(ms) [new Delayer]
Source
set tcp [new Agent/TCP]
$ns attach-agent $nodes(c1) $tcp
set ftp [new Application/FTP]
$ftp attach-agent $tcp
set sink [new Agent/TCPSink] Destination
$ns attach-agent $nodes(c2) $sink
$ns connect $tcp $sink
proc End {} {
global ns nt
$ns flush-trace
close $nt
exec awk -f program5.awk program5.tr &
exec xgraph -P -bar -x TIME -y DATA gsm.xg &
exit 0
Plot Bar graph,
} label for x –axis is “TIME”
label for y-axis is “DATA”
Read the data from the file “gsm.xg”
$ns at 0.0 "$ftp start"
$ns at 10.0 "End"
$ns run
gedit program5.awk
BEGIN {Total_no_of_pkts=0;
}
Shylaja B, Asst. Prof, Dept of CSE, DSATM 19 2019-20
Computer Networks Lab (17CSL57)
{
if($1 == "r")
{
Total_no_of_pkts = Total_no_of_pkts + $6;
printf(" %f %d \n",$2,Total_no_of_pkts) >> "gsm.xg"
}
}
END{
}
Execution Commands:
ns program5.tcl
Shylaja B, Asst. Prof, Dept of CSE, DSATM 20 2019-20
Computer Networks Lab (17CSL57)
Global System for Mobile communication (GSM).
Second Generation (2G) technology is based on the technology known as GSM.
The GSM standard originally described as a digital, circuit-switched network
optimized for full duplex voice telephony.
This expanded over time to include data communications, first by circuit-switched
transport, then by packet data transport via GPRS (General Packet Radio Services).
UMTS (Universal Mobile Telecommunications Service) is a third-generation (3G)
broadband, packet-based transmission of text, digitized voice, video, and multimedia
at data rates up to 2 megabits per second (Mbps).
UMTS is based on GSM
Shylaja B, Asst. Prof, Dept of CSE, DSATM 21 2019-20
Computer Networks Lab (17CSL57)
6. Implement and study the performance of CDMA on NS2/NS3 (Using stack called Call
net) or equivalent environment.
gedit program6.tcl
set bwDL(cdma) 384000
set bwUL(cdma) 64000
set propDL(cdma) .150
set propUL(cdma) .150
set buf(cdma) 20
set ns [new Simulator]
set nt [open program6.tr w]
$ns trace-all $nt
set nodes(c1) [$ns node]
set nodes(ms) [$ns node]
set nodes(bs1) [$ns node]
set nodes(bs2) [$ns node]
set nodes(c2) [$ns node]
proc cell_topo {} {
global ns nodes
$ns duplex-link $nodes(c1) $nodes(bs1) 3Mbps 10ms DropTail
$ns duplex-link $nodes(bs1) $nodes(ms) 1 1 RED
$ns duplex-link $nodes(ms) $nodes(bs2) 1 1 RED
$ns duplex-link $nodes(bs2) $nodes(c2) 3Mbps 50ms DropTail
}
switch umts {
cdma -
umts {cell_topo}
}
Shylaja B, Asst. Prof, Dept of CSE, DSATM 22 2019-20
Computer Networks Lab (17CSL57)
$ns bandwidth $nodes(bs1) $nodes(ms) $bwDL(cdma) simplex
$ns bandwidth $nodes(ms) $nodes(bs1) $bwUL(cdma) simplex
$ns bandwidth $nodes(bs2) $nodes(ms) $bwDL(cdma) simplex
$ns bandwidth $nodes(ms) $nodes(bs2) $bwUL(cdma) simplex
$ns delay $nodes(bs1) $nodes(ms) $propDL(cdma) simplex
$ns delay $nodes(ms) $nodes(bs1) $propDL(cdma) simplex
$ns delay $nodes(bs2) $nodes(ms) $propDL(cdma) simplex
$ns delay $nodes(ms) $nodes(bs2) $propDL(cdma) simplex
$ns queue-limit $nodes(bs1) $nodes(ms) $buf(cdma)
$ns queue-limit $nodes(ms) $nodes(bs1) $buf(cdma)
$ns queue-limit $nodes(bs2) $nodes(ms) $buf(cdma)
$ns queue-limit $nodes(ms) $nodes(bs2) $buf(cdma)
$ns insert-delayer $nodes(ms) $nodes(bs1) [new Delayer]
$ns insert-delayer $nodes(bs1) $nodes(ms) [new Delayer]
$ns insert-delayer $nodes(ms) $nodes(bs2) [new Delayer]
$ns insert-delayer $nodes(bs2) $nodes(ms) [new Delayer]
set tcp [new Agent/TCP]
$ns attach-agent $nodes(c1) $tcp
set ftp [new Application/FTP]
$ftp attach-agent $tcp
set sink [new Agent/TCPSink]
$ns attach-agent $nodes(c2) $sink
Shylaja B, Asst. Prof, Dept of CSE, DSATM 23 2019-20
Computer Networks Lab (17CSL57)
$ns connect $tcp $sink
proc End {} {
global ns nt
$ns flush-trace
close $nt
exec awk -f program6.awk program6.tr &
exec xgraph -P -bar -x TIME -y DATA cdma.xg &
exit 0
}
$ns at 0.0 "$ftp start"
$ns at 10.0 "End"
$ns run
gedit program6.awk
BEGIN {Total_no_of_pkts=0;}
{
if($1 == "r")
{
Total_no_of_pkts = Total_no_of_pkts + $6;
printf(" %f %d \n",$2,Total_no_of_pkts) >> "cdma.xg"
}
}
END{}
Execution Commands:
ns program6.tcl
Shylaja B, Asst. Prof, Dept of CSE, DSATM 24 2019-20
Computer Networks Lab (17CSL57)
CDMA (Code-Division Multiple Access)
Refers to any of several protocols used in second-generation (2G) and third-generation (3G)
wireless communications.
CDMA is a form of multiplexing, which allows numerous signals to occupy a single
transmission channel, optimizing the use of available bandwidth.
Shylaja B, Asst. Prof, Dept of CSE, DSATM 25 2019-20
