Exp 1

Department of Computer Engineering
Academic Term: Jan-Apr 2023
Class: T.E Computer Sem -VI

Subject: Mobile Computing
Practical No: 3
Title: To understand the cellular frequency reuse concept to find the

c co-channel cells for a particular cell.
Date of Performance: 09-02-2023
Date of Submission: 16-02-2023
Roll No: 9185
Name of the Student: Kris Elias Corriea
Evaluation:
Sr. No Rubric Grade

1 On time Completion & Submission(2)
2 Output(3)
3 Code Optimization(3)
4 Knowledge of the topic(2)
5 Total (10)
Signature of the Teacher
Mobile Computing Lab Manual:

Output:
Conclusion: Mobile networks using NS2 has been studied and implemented successfully.
Post Lab Questions:

1. Describe your observations about output.
2. Explain the working of DSDV protocol.
Objective: To study Routing in MANET
Pre-Requisite: Basic knowledge of wireless networking
Description:
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. It implements network protocols such as TCP and UPD, traffic source behavior such
as FTP, Telnet, Web, CBR and VBR, router queue management mechanism such as Drop Tail,
RED and CBQ, routing algorithms such as Dijkstra, and more. NS also implements multicasting
and some of the MAC layer protocols for LAN simulations.

Program description:
Each agent keeps track of what messages it has seen and only forwards those which it has seen
and only forwards those which it hasn’t seen before. Each message is of the form “ID:DATA”
where ID is some arbitrary message identifier and DATA is the payload. In order to reduce
memory usage, the agent store only the message ID.
Steps:
1. Set the following configuration for each node’s interface
- Type of channel - Wireless Channel
- Type of propagation – TwoRayGround
- Physical Layer – Wireless
- Mac Layer – MAC 802.11
- Type of Queue – DropTail / PriQueue
- LinkLayer – LL
- Type of Antenna - OmniAntenna
- Maximum Packet in Queue - 50
2. Open Trace file in write mode
3. Open NAM file in write mode.
4. Create a topology containing 6 groups each having 4 nodes. Use FlatGrid topology
5. Configure each node using the configuration set in step 1.
6. Create a simple MessagePassing/Flooding agent
7. Create Receive procedure that receives each packet and maintain list of unseen messages
8. Create send procedure that broadcasts message.
9. Create MessagePassing/Flooding agent and attach it with every node.
10. Set up some events.
11. Write finish procedure.
AODV (Ad-hoc On-demand Distance Vector):

AODV is a routing protocol designed for use in mobile ad-hoc networks (MANETs). It is
a reactive protocol, meaning that it only establishes routes when they are needed, rather than
maintaining them at all times like a proactive protocol would. When a node in the network wants to
send a packet to a destination, it first checks its routing table to see if it already has a route to that
destination. If it does not, it will broadcast a route request (RREQ) packet to its neighbouring
nodes, asking if any of them know of a route to the destination. The RREQ packet contains
information about the source node, the destination node, and a unique sequence number. When a
neighbouring node receives the RREQ packet, it checks to see if it has a route to the destination in
its routing table. If it does, it will unicast (send directly to the destination node) a route reply
(RREP) packet back to the source node, containing the route. If it does not, it will rebroadcast the
RREQ packet to its own neighbouring nodes. This process continues until the RREQ packet
reaches the destination node or a node that has recently seen the RREQ packet (determined by the
unique sequence number). The destination node or the node that has recently seen the RREQ
packet sends a RREP packet back to the source node, containing the route. Once the route is
established, the source node can send the packet to the destination node along the established route.
If a link in the route becomes broken or the destination node becomes unreachable, the source node
will detect this and send a new RREQ packet to find a new route. AODV has several advantages
over other routing protocols for MANETs, including low overhead, fast route discovery, and the
ability to handle dynamic network changes. However, it is not as efficient as some other protocols
in terms of bandwidth and power consumption.
DSR (Dynamic Source Routing):

DSR is a routing protocol designed for use in mobile ad-hoc networks (MANETs). It is a
reactive protocol, meaning that it only establishes routes when they are needed, rather than
maintaining them at all times like a proactive protocol would. When a node in the network wants to
send a packet to a destination, it first checks its routing cache to see if it already has a route to that
destination. If it does not, it initiates a route discovery process by broadcasting a route request
(RREQ) packet to its neighbouring nodes. The RREQ packet contains information about the source
node, the destination node, and a unique identification number. When a neighbouring node
receives the RREQ packet, it checks to see if it has a route to the destination in its routing cache. If
it does, it will unicast (send directly to the source node) a route reply (RREP) packet back to the
source node, containing the route. If it does not, it will rebroadcast the RREQ packet to its own
neighbouring nodes. This process continues until the RREQ packet reaches the destination node or
a node that has recently seen the RREQ packet (determined by the unique identification number).
The destination node or the node that has recently seen the RREQ packet sends a RREP packet
back to the source node, containing the route. Once the route is established, the source node can
send the packet to the destination node along the established route. The route is also cached by
each node along the path, so that it can be used for future transmissions. DSR has several
advantages over other routing protocols for MANETs, including the ability to handle dynamic
network changes and the ability to work with multi-hop routes. However, it also has a high
overhead for route discovery, and the route caching can consume a lot of memory.
DSDV:
DSDV (Destination-Sequenced Distance-Vector) is a routing protocol designed for use in
mobile ad-hoc networks (MANETs). It is a proactive protocol, meaning that it continuously
maintains and updates routing information for all nodes in the network. Each node in the network
maintains a routing table that contains the next hop and the number of hops needed to reach each
destination. The routing table is updated by using a distance-vector algorithm, in which each node
exchanges its routing table with its neighbours at regular intervals. The routing table entries also
have a sequence number assigned by the destination node, which is used to ensure that the most
recent and accurate routing information is used. When a node receives an update from a neighbour,
it compares the sequence number in the update with the one in its own routing table. If the received
sequence number is higher, the node updates its routing table with the new information. To prevent
routing loops, DSDV uses a technique called "poison reverse", where each node sends updates to
its neighbours with a metric of infinity for any routes that lead back to itself. In addition to the
regular updates, DSDV also uses triggered updates. When a node detects a change in the network,
such as a link failure, it immediately sends a triggered update to its neighbours to inform them of
the change. This helps to quickly converge to the new state of the network. DSDV has several
advantages over other routing protocols for MANETs, including the ability to handle dynamic
network changes and the ability to work with multi-hop routes. However, it also has a high
overhead for maintaining and updating routing information, which can consume a lot of bandwidth
and power.

Code:
Simple Program:
#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 the NAM trace file
close $nf
#Execute NAM on the trace file
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

Ad-hoc Program:
set a 1
while {$a == 1 } {
puts "Enter the Routing Agents in mobile networking"
puts "1. AODV"
puts "2. DSDV"
puts "3. DSR"
set top [gets stdin]

if {$top == 1} {
set opt(chan) Channel/WirelessChannel ;# channel type
set opt(prop) Propagation/TwoRayGround ;# radio-propagation model
set opt(netif) Phy/WirelessPhy ;# network interface type
set opt(mac) Mac/802_11 ;# MAC type
set opt(ifq) Queue/DropTail/PriQueue ;# interface queue type
set opt(ll) LL ;# link layer type
set opt(ant) Antenna/OmniAntenna ;# antenna model
set opt(ifqlen) 50 ;# max packet in ifq
set opt(nn) 22 ;# number of mobilenodes
set opt(rp) AODV ;# routing protocol
set opt(x) 1800 ;# X dimension of topography
set opt(y) 840 ;# Y dimension of topography
### Setting The Simulator Objects
set ns_ [new Simulator]

#create the nam and trace file:
set tracefd [open aodv.tr w]
$ns_ trace-all $tracefd
set namtrace [open aodv.nam w]

$ns_ namtrace-all-wireless $namtrace $opt(x) $opt(y)
set topo [new Topography]

$topo load_flatgrid $opt(x) $opt(y)
create-god $opt(nn)
set chan_1_ [new $opt(chan)]
#### 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)
# Defining Node Configuration
$ns_ node-config -adhocRouting $opt(rp) \

-llType $opt(ll) \
-macType $opt(mac) \
-ifqType $opt(ifq) \
-ifqLen $opt(ifqlen) \
-antType $opt(ant) \
-propType $opt(prop) \
-phyType $opt(netif) \
-topoInstance $topo \
-agentTrace ON \
-routerTrace ON \
-macTrace ON \
-movementTrace ON \
-channel $chan_1_
### Creating The WIRELESS NODES
set Server1 [$ns_ node]

set Server2 [$ns_ node]
set n2 [$ns_ node]
set n3 [$ns_ node]
set n4 [$ns_ node]
set n5 [$ns_ node]
set n6 [$ns_ node]
set n7 [$ns_ node]
set n8 [$ns_ node]
set n9 [$ns_ node]
set n10 [$ns_ node]
set n11 [$ns_ node]
set n12 [$ns_ node]
set n13 [$ns_ node]
set n14 [$ns_ node]
set n15 [$ns_ node]
set n16 [$ns_ node]
set n17 [$ns_ node]
set n18 [$ns_ node]
set n19 [$ns_ node]
set n20 [$ns_ node]
set n21 [$ns_ node]
set n22 [$ns_ node]
set opt(seed) 0.1

set a [ns-random $opt(seed)]
set i 0
while {$i < 5} {
incr i
}
### Setting The Initial Positions of Nodes
$Server1 set X_ 513.0

$Server1 set Y_ 517.0
$Server1 set Z_ 0.0
$Server2 set X_ 1445.0

$Server2 set Y_ 474.0
$Server2 set Z_ 0.0
$n2 set X_ 36.0

$n2 set Y_ 529.0
$n2 set Z_ 0.0
$n3 set X_ 143.0

$n3 set Y_ 666.0
$n3 set Z_ 0.0
$n4 set X_ 201.0

$n4 set Y_ 552.0
$n4 set Z_ 0.0
$n5 set X_ 147.0

$n5 set Y_ 403.0
$n5 set Z_ 0.0
$n6 set X_ 230.0

$n6 set Y_ 291.0
$n6 set Z_ 0.0

$n7 set X_ 295.0
$n7 set Y_ 419.0
$n7 set Z_ 0.0
$n8 set X_ 363.0

$n8 set Y_ 335.0
$n8 set Z_ 0.0
$n9 set X_ 334.0

$n9 set Y_ 647.0
$n9 set Z_ 0.0
$n10 set X_ 304.0

$n10 set Y_ 777.0
$n10 set Z_ 0.0
$n11 set X_ 412.0

$n11 set Y_ 194.0
$n11 set Z_ 0.0
$n12 set X_ 519.0

$n12 set Y_ 361.0
$n12 set Z_ 0.0
$n13 set X_ 569.0

$n13 set Y_ 167.0
$n13 set Z_ 0.0
$n14 set X_ 349.0

$n14 set Y_ 546.0
$n14 set Z_ 0.0
$n15 set X_ 466.0

$n15 set Y_ 668.0
$n15 set Z_ 0.0
$n16 set X_ 489.0

$n16 set Y_ 794.0
$n16 set Z_ 0.0
$n17 set X_ 606.0

$n17 set Y_ 711.0
$n17 set Z_ 0.0
$n18 set X_ 630.0

$n18 set Y_ 626.0
$n18 set Z_ 0.0

$n19 set X_ 666.0
$n19 set Y_ 347.0
$n19 set Z_ 0.0
$n20 set X_ 741.0

$n20 set Y_ 152.0
$n20 set Z_ 0.0
$n21 set X_ 882.0

$n21 set Y_ 264.0
$n21 set Z_ 0.0
$n22 set X_ 761.0

$n22 set Y_ 441.0
$n22 set Z_ 0.0
## Giving Mobility to Nodes
$ns_ at 0.75 "$n2 setdest 379.0 349.0 20.0"

$ns_ at 0.75 "$n3 setdest 556.0 302.0 20.0"
$ns_ at 0.20 "$n4 setdest 309.0 211.0 20.0"
$ns_ at 1.25 "$n5 setdest 179.0 333.0 20.0"
$ns_ at 0.75 "$n6 setdest 139.0 63.0 20.0"
$ns_ at 0.75 "$n7 setdest 320.0 27.0 20.0"
$ns_ at 1.50 "$n8 setdest 505.0 124.0 20.0"
$ns_ at 1.25 "$n9 setdest 274.0 487.0 20.0"
$ns_ at 1.25 "$n10 setdest 494.0 475.0 20.0"
$ns_ at 1.25 "$n11 setdest 899.0 757.0 25.0"
$ns_ at 0.50 "$n12 setdest 598.0 728.0 25.0"
$ns_ at 0.25 "$n13 setdest 551.0 624.0 25.0"
$ns_ at 1.25 "$n14 setdest 397.0 647.0 25.0"
$ns_ at 1.25 "$n15 setdest 748.0 688.0 25.0"
$ns_ at 1.25 "$n16 setdest 842.0 623.0 25.0"
$ns_ at 1.25 "$n17 setdest 678.0 548.0 25.0"
$ns_ at 0.75 "$n18 setdest 741.0 809.0 20.0"
$ns_ at 0.75 "$n19 setdest 437.0 799.0 20.0"
$ns_ at 0.20 "$n20 setdest 159.0 722.0 20.0"
$ns_ at 1.25 "$n21 setdest 700.0 350.0 20.0"
$ns_ at 0.75 "$n22 setdest 839.0 444.0 20.0"
## Setting The Node Size
$ns_ initial_node_pos $Server1 125

$ns_ initial_node_pos $Server2 125
$ns_ initial_node_pos $n2 70
#### Setting The Labels For Nodes
$ns_ at 0.0 "$Server1 label Server1"

$ns_ at 0.0 "$Server2 label Server2"
$ns_ at 0.0 "$n2 label node2"

$n2 color green

$ns_ at 0.0 "$n2 color green"
$n3 color green
$n4 color green

$n5 color green

$n6 color green

$n7 color green

$n8 color green

$n9 color yellow

$ns_ at 0.0 "$n9 color yellow"
$n10 color yellow

$n11 color yellow

$n12 color pink

$ns_ at 0.0 "$n12 color pink"
$n13 color pink

$n14 color pink

$n15 color pink

$n16 color pink

$n17 color orange

$ns_ at 0.0 "$n17 color orange"
$n18 color orange

$n19 color orange
$n20 color orange

$n21 color orange

$n22 color orange

$Server1 color maroon

$ns_ at 0.0 "$Server1 color maroon"
$Server2 color maroon

$ns_ at 0.0 "$Server2 color maroon"
## SETTING ANIMATION RATE

$ns_ at 0.0 "$ns_ set-animation-rate 12.5ms"
# COLORING THE NODES

$n9 color blue
$ns_ at 4.71 "$n9 color blue"
$n5 color blue
$n2 color blue
$n16 color blue

$n9 color maroon

$ns_ at 7.44 "$n9 color maroon"
$ns_ at 7.43 "$n9 label TTLover"

$ns_ at 7.55 "$n9 label \"\""
$n12 color blue

#### Establishing Communication
set udp0 [$ns_ create-connection UDP $Server1 LossMonitor $n18 0]

$udp0 set fid_ 1
set cbr0 [$udp0 attach-app Traffic/CBR]
$cbr0 set packetSize_ 1000
$cbr0 set interopt_ .07
$ns_ at 0.0 "$cbr0 start"
$ns_ at 4.0 "$cbr0 stop"

$udp1 set fid_ 1
set udp2 [$ns_ create-connection UDP $n21 LossMonitor $n20 0]

$udp2 set fid_ 1

$udp3 set fid_ 1
$cbr3 set interopt_ 5

$udp4 set fid_ 1

$udp5 set fid_ 1

$udp6 set fid_ 1

$udp7 set fid_ 1

$udp8 set fid_ 1

$udp9 set fid_ 1

$udp10 set fid_ 1

$udp11 set fid_ 1

$udp12 set fid_ 1
#ANNOTATIONS DETAILS
$ns_ at 0.0 "$ns_ trace-annotate \"MOBILE NODE MOVEMENTS\""

$ns_ at 4.1 "$ns_ trace-annotate \"NODE27 CACHE THE DATA FRO SERVER\""
#$ns_ at 4.59 "$ns_ trace-annotate \"PACKET LOSS AT NODE27\""
$ns_ at 4.71 "$ns_ trace-annotate \"NODE10 CACHE THE DATA\""
### PROCEDURE TO STOP
proc stop {} {
global ns_ tracefd

$ns_ flush-trace
close $tracefd
exec nam aodv.nam &
exit 0
puts "Starting Simulation........"

$ns_ at 25.0 "stop"
$ns_ run
} elseif {$top == 2} {
# Define options
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) 50 ;# max packet in ifq
set val(nn) 7 ;# number of mobilenodes
set val(rp) DSDV ;# routing protocol
set val(x) 500 ;# X dimension of topography
set val(y) 400 ;# Y dimension of topography
set val(stop) 100 ;# time of simulation end
set tracefd [open dsdv.tr w]
set namtrace [open dsdv.nam w]
$ns use-newtrace
$ns trace-all $tracefd
$ns namtrace-all-wireless $namtrace $val(x) $val(y)
Antenna/OmniAntenna set X_ 0
Antenna/OmniAntenna set Y_ 0
Antenna/OmniAntenna set Z_ 1.5
Antenna/OmniAntenna set Gt_ 1.0
Antenna/OmniAntenna set Gr_ 1.0
# set up topography object

$topo load_flatgrid $val(x) $val(y)
create-god $val(nn)
#
# Create nn mobilenodes [$val(nn)] and attach them to the channel.
#
# configure the nodes

$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) \
-agentTrace ON \
-routerTrace ON \
-macTrace OFF \
-movementTrace ON
for {set i 0} {$i < $val(nn) } { incr i } {

set node_($i) [$ns node]
}
# Provide initial location of mobilenodes

$node_(0) set X_ 5.0
$node_(0) set Y_ 5.0
$node_(0) set Z_ 0.0
$node_(1) set X_ 490.0
$node_(1) set Y_ 285.0
$node_(2) set X_ 150.0

$node_(2) set Y_ 240.0
$node_(3) set X_ 250.0

$node_(3) set Y_ 240.0
$node_(4) set X_ 180.0

$node_(4) set Y_ 70.0
$node_(5) set X_ 100.0

$node_(5) set Y_ 70.0
$node_(6) set X_ 380.0

$node_(6) set Y_ 70.0
# Generation of movements
$ns at 10.0 "$node_(0) setdest 250.0 250.0 10.0"
# Set a TCP connection between node_(0) and node_(1)

$ns attach-agent $node_(0) $tcp
$ns attach-agent $node_(1) $sink






# 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 150.01 "puts \"end simulation\" ; $ns halt"
proc stop {} {
global ns tracefd namtrace
$ns flush-trace
close $tracefd
close $namtrace
#Execute nam on the trace file
exec nam dsdv.nam &
exit 0
}
$ns run
} elseif {$top == 3} {
set opt(chan) Channel/WirelessChannel ;# channel type
set opt(prop) Propagation/TwoRayGround ;# radio-propagation model
set opt(netif) Phy/WirelessPhy ;# network interface type
set opt(mac) Mac/802_11 ;# MAC type
set opt(ifq) Queue/DropTail/PriQueue ;# interface queue type
set opt(ll) LL ;# link layer type
set opt(ant) Antenna/OmniAntenna ;# antenna model
set opt(ifqlen) 50 ;# max packet in ifq
set opt(nn) 3 ;# number of mobilenodes
set opt(rp) DSR ;# routing protocol
set opt(x) 500 ;# X dimension of topography
set opt(y) 400 ;# Y dimension of topography
set opt(stop) 150 ;
#Creating trace file and nam file
set tracefd [open Dsr.tr w]
set namtrace [open dsr.nam w]

$ns trace-all $tracefd
$ns namtrace-all-wireless $namtrace $opt(x) $opt(y)
# set up topography object

$topo load_flatgrid $opt(x) $opt(y)
create-god $opt(nn)
# configure the nodes

$ns node-config -adhocRouting $opt(rp) \
-llType $opt(ll) \
-macType $opt(mac) \
-ifqType $opt(ifq) \
-ifqLen $opt(ifqlen) \
-antType $opt(ant) \
-propType $opt(prop) \
-phyType $opt(netif) \
-channelType $opt(chan) \
-agentTrace ON \
-routerTrace ON \
-macTrace OFF \
-movementTrace ON
for {set i 0} {$i < $opt(nn) } { incr i } {

set node_($i) [$ns node]
}
# Provide initial location of mobilenodes

$node_(0) set X_ 5.0
$node_(0) set Y_ 5.0
$node_(1) set X_ 490.0

$node_(1) set Y_ 285.0
$node_(2) set X_ 150.0

$node_(2) set Y_ 240.0
# Generation of movements

set tcp [new Agent/TCP/Newreno]
$tcp set class_ 2
# Define node initial position in nam

for {set i 0} {$i < $opt(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 < $opt(nn) } { incr i } {
$ns at $opt(stop) "$node_($i) reset";
}
# ending nam and the simulation

$ns at $opt(stop) "$ns nam-end-wireless $opt(stop)"
$ns at $opt(stop) "stop"
$ns at 150.01 "puts \"end simulation\" ; $ns halt"
proc stop {} {
global ns tracefd namtrace
$ns flush-trace
close $tracefd
close $namtrace
exec nam dsr.nam &
exit 0
}
$ns run
}
puts "want to continue (0/1)"
set a [gets stdin]
}

Exp 1

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Exp 1

Uploaded by

Copyright:

Available Formats

Department of Computer Engineering

Academic Term: Jan-Apr 2023

Class: T.E Computer Sem -VI

Title: To understand the cellular frequency reuse concept to find the

Date of Submission: 16-02-2023

Roll No: 9185

Name of the Student: Kris Elias Corriea

Sr. No Rubric Grade

Signature of the Teacher

Mobile Computing Lab Manual:

Post Lab Questions:

Pre-Requisite: Basic knowledge of wireless networking

Mobile Computing Lab Manual:

AODV (Ad-hoc On-demand Distance Vector):

DSR (Dynamic Source Routing):

Mobile Computing Lab Manual:

#Create a simulator object

#Define different colors for data flows (for NAM)

#Open the NAM trace file

#Define a 'finish' procedure

#Create four nodes

#Create links between the nodes

#Set Queue Size of link (n2-n3) to 10

#Give node position (for NAM)

#Monitor the queue for link (n2-n3). (for NAM)

Mobile Computing Lab Manual:

#Setup a FTP over TCP connection

#Setup a UDP connection

#Setup a CBR over UDP connection

#Schedule events for the CBR and FTP agents

#Detach tcp and sink agents (not really necessary)

#Call the finish procedure after 5 seconds of simulation time

#Print CBR packet size and interval

Mobile Computing Lab Manual:

set top [gets stdin]

### Setting The Simulator Objects

set ns_ [new Simulator]

set namtrace [open aodv.nam w]

set topo [new Topography]

#### Setting The Distance Variables

# For model 'TwoRayGround'

# Defining Node Configuration

$ns_ node-config -adhocRouting $opt(rp) \

### Creating The WIRELESS NODES

set Server1 [$ns_ node]

set opt(seed) 0.1

### Setting The Initial Positions of Nodes

$Server1 set X_ 513.0

$Server2 set X_ 1445.0

$n2 set X_ 36.0

$n3 set X_ 143.0

$n4 set X_ 201.0

$n5 set X_ 147.0

$n6 set X_ 230.0

Mobile Computing Lab Manual:

$n8 set X_ 363.0

$n9 set X_ 334.0

$n10 set X_ 304.0

$n11 set X_ 412.0

$n12 set X_ 519.0

$n13 set X_ 569.0

$n14 set X_ 349.0