To simulate Underwater Sensor Networks (UWSNs) in NS2 has needs a modification to account for the distinctive features of underwater communication, such as:
- Acoustic signal propagation (instead of RF waves)
- Long propagation delays
- Limited bandwidth
- High error rates due to multi-path fading, noise, and attenuation
Since NS2 does not directly support the underwater environment, several extensions and patches have been established to simulate Underwater Sensor Networks (UWSNs). One often used extension is the Aqua-Sim patch, which is built on NS2 and exactly intended for replicates UWSNs.
We give best project assistance for scholars more than 15+ years, so send us all your details to get best guidance.phdprime.com possess the latest tools and resources to offer you good guidance on simulation in Underwater Sensor Network Projects Using NS2. You can receive tailored services from us to meet your specific needs we provide you original topics in your interested area that attracts the readers.
Key Components for Simulating UWSNs in NS2:
- Acoustic Modem: For underwater communication using acoustic signals.
- Underwater Nodes: Signify sensors deployed underwater to collect data.
- Underwater Channel: A communication channel that implements the features of underwater environments has contained high delay and low bandwidth.
- Energy Models: Replicate the power consumption of underwater sensor nodes because of the limited energy available in underwater scenario.
- Mobility: If the underwater nodes are mobile (e.g., underwater vehicles), we required mobility models like random or controlled movement.
Steps for Simulating Underwater Sensor Networks (UWSNs) Using Aqua-Sim and NS2
- Install NS2 and Aqua-Sim: Initially, we need to install NS2 along with the Aqua-Sim patch for underwater sensor network simulation.
- Installing NS2: On Linux systems, we can install NS2 using the following command:
sudo apt-get install ns2
Validate the installation by typing:
ns -version
-
- Install Aqua-Sim: Aqua-Sim is an NS2 extension for UWSN simulation. We can download and install Aqua-Sim from its official website or repository. To install Aqua-Sim:
git clone https://github.com/xiaosima/Aqua-Sim.git
cd Aqua-Sim
./install
This will install Aqua-Sim on top of NS2 installation.
- Create an Underwater Sensor Network Scenario Using Aqua-Sim: After installing Aqua-Sim, we need to generate a Tcl script to replicate a simple underwater sensor network. The script will describe underwater nodes, the underwater communication channel, and traffic patterns.
Example Tcl Script for Simulating Underwater Sensor Networks in NS2 with Aqua-Sim
# Load Aqua-Sim for Underwater Network Simulation
set ns_ [new Simulator]
# Open trace and NAM files for output
set tracefile [open uwsn_out.tr w]
$ns_ trace-all $tracefile
set namfile [open uwsn_out.nam w]
$ns_ namtrace-all $namfile
# Define underwater channel for UWSN
set opt(chan) Channel/UnderwaterChannel ;# Underwater acoustic channel
set opt(prop) Propagation/Underwater ;# Underwater propagation model
set opt(netif) Phy/UnderwaterPhy ;# Physical layer for underwater communication
set opt(mac) Mac/UnderwaterMac ;# MAC protocol for UWSNs
set opt(ll) LL ;# Link layer
set opt(ifq) Queue/DropTail/PriQueue ;# Interface queue type
set opt(ant) Antenna/OmniAntenna ;# Omnidirectional antenna for underwater communication
set opt(ifqlen) 50 ;# Interface queue length
set opt(energy) 100 ;# Initial energy of underwater sensor nodes
set opt(nn) 5 ;# Number of underwater nodes
set opt(x) 500 ;# X dimension of the simulation area
set opt(y) 500 ;# Y dimension of the simulation area
set opt(z) 500 ;# Z dimension (depth) of the simulation area
# Define the topology and channel model for underwater nodes
set topo [new Topography]
$topo load_flatgrid $opt(x) $opt(y)
# Configure underwater nodes with Aqua-Sim options
$ns_ node-config -llType $opt(ll) \
-macType $opt(mac) \
-ifqType $opt(ifq) \
-ifqLen $opt(ifqlen) \
-antType $opt(ant) \
-propType $opt(prop) \
-phyType $opt(netif) \
-channelType $opt(chan) \
-topoInstance $topo \
-energyModel EnergyModel \
-initialEnergy $opt(energy) \
-rxPower 0.1 \
-txPower 0.2 \
-agentTrace ON \
-routerTrace ON \
-macTrace ON
# Create underwater sensor nodes
set node_(0) [$ns_ node]
set node_(1) [$ns_ node]
set node_(2) [$ns_ node]
set node_(3) [$ns_ node]
set node_(4) [$ns_ node]
# Set initial positions for underwater sensor nodes
$node_(0) set X_ 100
$node_(0) set Y_ 100
$node_(0) set Z_ 100
$node_(1) set X_ 200
$node_(1) set Y_ 200
$node_(1) set Z_ 200
$node_(2) set X_ 300
$node_(2) set Y_ 300
$node_(2) set Z_ 100
$node_(3) set X_ 400
$node_(3) set Y_ 100
$node_(3) set Z_ 200
$node_(4) set X_ 500
$node_(4) set Y_ 300
$node_(4) set Z_ 300
# Set up routing protocols (you can choose among available Aqua-Sim routing protocols)
$ns_ at 0.0 “$node_(0) add-route 0 $node_(1)”
$ns_ at 0.0 “$node_(1) add-route 1 $node_(2)”
$ns_ at 0.0 “$node_(2) add-route 2 $node_(3)”
$ns_ at 0.0 “$node_(3) add-route 3 $node_(4)”
# Define traffic flow (CBR traffic over UDP)
set udp [new Agent/UDP]
$ns_ attach-agent $node_(0) $udp
set null [new Agent/Null]
$ns_ attach-agent $node_(4) $null
$ns_ connect $udp $null
# Create a CBR (Constant Bit Rate) application to simulate data traffic
set cbr [new Application/Traffic/CBR]
$cbr set packetSize_ 1000
$cbr set interval_ 0.1
$cbr attach-agent $udp
# Schedule traffic
$ns_ at 1.0 “$cbr start”
$ns_ at 5.0 “$cbr stop”
# Define finish procedure to close trace and NAM files
proc finish {} {
global ns_ tracefile namfile
$ns_ flush-trace
close $tracefile
close $namfile
exec nam uwsn_out.nam &
exit 0
}
# Schedule the end of the simulation
$ns_ at 10.0 “finish”
# Run the simulation
$ns_ run
Explanation of the Tcl Script:
- Aqua-Sim Configuration:
- The underwater channel (Channel/UnderwaterChannel) and underwater propagation model (Propagation/Underwater) replicate the features of underwater acoustic communication, like low data rates and long propagation delays.
- Underwater Nodes:
- Five underwater nodes are created; each allocated a unique 3D position (X, Y, Z) in the underwater simulation space.
- Energy Model:
- The nodes are set up with an energy model to replicate energy consumption in the course of packet transmission and reception, critical in UWSNs because of limited battery life.
- Traffic Model:
- UDP traffic with a CBR (Constant Bit Rate) application emulates the constant flow of data packets among the underwater nodes.
- Traffic flows from node 0 to node 4, signify data being depend via the network of underwater sensor nodes.
- Simulation End:
- The simulation executes for 10 seconds, during which data is routed among the nodes. The finish procedure closes the trace files and opens NAM for envision the underwater sensor network.
- Running the Simulation:
Save the script as uwsn_simulation.tcl and execute it using NS2 with Aqua-Sim:
ns uwsn_simulation.tcl
After the simulation completes, we need to envision the network using NAM:
nam uwsn_out.nam
- Analysing the Results:
- The trace file (uwsn_out.tr) contains logs of packet transmissions, receptions, and energy consumption. We need to evaluate this data to calculate:
- End-to-end delay because of the long propagation delay in underwater environments.
- Packet delivery ratio: The ratio of successfully delivered packets.
- Energy consumption: Energy utilized by each node in the course of the transmission and reception of data.
- Throughput: The total amount of data successfully routed via the network.
- Example AWK script to estimate throughput:
BEGIN {
packet_count = 0;
start_time = 0;
end_time = 0;
}
{
if ($1 == “r” && $4 == “AGT”) {
packet_count++;
if (start_time == 0) {
start_time = $2;
}
end_time = $2;
}
}
END {
duration = end_time – start_time;
throughput = (packet_count * 1000 * 8) / (duration * 1000); # kbps
printf(“Throughput: %.2f kbps\n”, throughput);
}
Extending the Simulation:
- Advanced Routing Protocols:
- Aqua-Sim supports numerous routing protocols like VBF (Vector-Based Forwarding), DBR (Depth-Based Routing), and QELAR (Q-learning-based routing). We can experiment with these protocols to learn their effects on network performance.
- Mobility Models:
- If UWSN that contain mobile nodes (such as Autonomous Underwater Vehicles (AUVs)), we can establish mobility models to replicate node movement.
- Advanced Energy Models:
- Simulate more complex energy models to deliberate energy harvesting or more detailed power consumption features for transmission, reception, and idle states.
- Realistic Environmental Effects:
- Incorporate environmental factors like temperature, salinity, and current to the simulation to track on how real-world underwater conditions impact network performance.
This project idea deliver a range of implementations using the Underwater Sensor Networks using acoustic signal in NS2, helping you explore numerous contexts of the protocol’s performance in scenarios. We plan to deliver the detailed instructions to these projects to in further manual.
