How to Implement Network Localization Scheme in NS2

To implement a Network Localization Scheme in NS2 has contain to mimic on how nodes in a wireless network that define their positions relative to other nodes or anchors (nodes with known positions). Localization schemes are often in Wireless Sensor Networks (WSNs), Mobile Ad Hoc Networks (MANETs), and similar systems in which absolute node positions are common unknown. The below are the given procedures to implement the network localization scheme in ns2:

Step-by-Step Implementation:

  1. Understanding Network Localization
  • Localization refers to defining the geographic positions of network nodes. In NS2, this can be completed by mimic the distance measurements, hop counts, or signal strength from neighbouring nodes or anchor nodes (nodes with known locations).
  • Common localization techniques that has Centroid Localization, DV-Hop (Distance Vector-Hop), and RSSI-based (Received Signal Strength Indicator) Localization.
  1. Approach to Implement Localization in NS2
  • Anchor Nodes: Nodes with known locations that other nodes use for position estimation.
  • Distance/Proximity Estimation: Nodes calculate their distances to anchors using hop counts, signal strength, or other metrics.
  • Localization Algorithm: Nodes use this data to calculate their position using triangulation, multilateration, or similar approaches.
  1. Basic Steps for Localization in NS2
  1. Define Anchor Nodes: Nodes with known positions.
  2. Distance Estimation: Nodes calculate distances to anchor nodes.
  3. Localization Algorithm: Nodes estimate their positions based on distance estimates.
  1. Implementing a Simple Localization Scheme in NS2

In this sample, we will use the DV-Hop Localization method, in which nodes calculate their positions according to hop counts to anchors and average hop distances.

Step-by-Step Implementation

Step 1: Define Anchor Nodes in the Simulation Environment

In the simulation, certain nodes will be chosen as anchor nodes with known positions. Other nodes will calculate their distances to the anchors and use this data to estimate their positions.

# Create a simulator instance

set ns [new Simulator]

# Define trace and nam files for output

set tracefile [open localization.tr w]

set namfile [open localization.nam w]

$ns trace-all $tracefile

$ns namtrace-all $namfile

# Define the network topology

set topo [new Topography]

$topo load_flatgrid 1000 1000  ;# Simulation area: 1000×1000 meters

# Create the General Operations Director (GOD)

set god_ [create-god 50]  ;# 50 nodes in the network

# Define node parameters

set opt(chan)       Channel/WirelessChannel

set opt(prop)       Propagation/TwoRayGround

set opt(netif)      Phy/WirelessPhy

set opt(mac)        Mac/802_11

set opt(ifq)        Queue/DropTail/PriQueue

set opt(ll)         LL

set opt(ant)        Antenna/OmniAntenna

set opt(x)          1000

set opt(y)          1000

# Define number of nodes and anchor nodes

set opt(nn) 50  ;# Total number of nodes

set opt(anchor_count) 5  ;# Number of anchor nodes

# Create the anchor nodes with known positions

for {set i 0} {$i < $opt(anchor_count)} {incr i} {

set anchor_($i) [$ns node]

set x [expr int(rand()*$opt(x))]

set y [expr int(rand()*$opt(y))]

$anchor_($i) set X_ $x

$anchor_($i) set Y_ $y

$anchor_($i) set Z_ 0.0

# Mark anchor nodes in NAM for visualization

$ns at 0.1 “$anchor_($i) color blue”

}

# Create the regular nodes with unknown positions

for {set i $opt(anchor_count)} {$i < $opt(nn)} {incr i} {

set node_($i) [$ns node]

$node_($i) random-motion 1  ;# Enable random motion for nodes

}

Step 2: Implement DV-Hop Localization

  1. Step 1 (Flooding Phase): Anchor nodes flood their positions to all other nodes in the network.
  2. Step 2 (Hop Counting): Each node estimates the minimum number of hops to each anchor node.
  3. Step 3 (Distance Estimation): Nodes calculate their distance to each anchor node by multiplying the number of hops by the average hop distance.
  4. Step 4 (Position Estimation): Nodes use triangulation or multilateration to calculate their positions.

# DV-Hop Localization Process

proc dvhop_localization {} {

global ns node_ anchor_ opt

# Step 1: Flood the network with anchor positions

for {set i 0} {$i < $opt(anchor_count)} {incr i} {

flood_anchor_position $anchor_($i)

}

# Step 2: Nodes calculate hop count to anchors

for {set i $opt(anchor_count)} {$i < $opt(nn)} {incr i} {

calculate_hop_count $node_($i)

}

# Step 3: Estimate distances to anchors

for {set i $opt(anchor_count)} {$i < $opt(nn)} {incr i} {

estimate_distance_to_anchors $node_($i)

}

# Step 4: Estimate positions using triangulation or multilateration

for {set i $opt(anchor_count)} {$i < $opt(nn)} {incr i} {

estimate_position $node_($i)

}

}

# Flood anchor positions to the network

proc flood_anchor_position {anchor} {

global ns node_ opt

# Flood anchor’s position to all nodes in the network

for {set i 0} {$i < $opt(nn)} {incr i} {

if {$node_($i) != $anchor} {

$ns at 1.0 “$node_($i) receive_anchor_position [$anchor set X_] [$anchor set Y_]”

}

}

}

# Nodes calculate hop count to anchors

proc calculate_hop_count {node} {

# Hop count calculation logic (to be implemented based on network conditions)

# This step calculates the minimum number of hops to each anchor

}

# Nodes estimate distances to anchors

proc estimate_distance_to_anchors {node} {

# Estimate the distance to each anchor based on hop count and average hop distance

}

# Nodes estimate their position

proc estimate_position {node} {

# Use triangulation or multilateration to estimate the node’s position

}

Step 3: Adjust Traffic and Mobility Models

We can adapt node movement and traffic generation to see how localization accuracy is effect by node mobility and network traffic.

# Mobility model for nodes

for {set i $opt(anchor_count)} {$i < $opt(nn)} {incr i} {

set x [expr int(rand()*$opt(x))]

set y [expr int(rand()*$opt(y))]

set speed [expr rand()*10]

$ns at 0.0 “$node_($i) setdest $x $y $speed”

}

# Traffic generation

for {set i 0} {$i < $opt(nn)} {incr i} {

# Create a UDP agent for each node

set udp_($i) [new Agent/UDP]

set null_($i) [new Agent/Null]

$ns attach-agent $node_($i) $udp_($i)

$ns attach-agent $node_($i) $null_($i)

# Generate CBR traffic

set cbr_($i) [new Application/Traffic/CBR]

$cbr_($i) set packetSize_ 512

$cbr_($i) set interval_ 0.1

$cbr_($i) attach-agent $udp_($i)

}

# Run the localization process

$ns at 1.0 “dvhop_localization”

# End the simulation

$ns at 100.0 “finish”

# Finish procedure

proc finish {} {

global ns tracefile namfile

close $tracefile

close $namfile

$ns halt

}

# Run the simulation

$ns run

  1. Explanation of the Script
  • Anchor Nodes: Anchor nodes are chosen as reference points with known positions, used by other nodes to calculate their positions.
  • Flooding Phase: Anchor nodes flood their positions to all other nodes in the network.
  • Hop Counting and Distance Estimation: Nodes count the number of hops to each anchor and calculate the distance using the average hop distance.
  • Position Estimation: Nodes use the calculated distances to anchor nodes to estimate their positions using triangulation or multilateration.
  1. Running the Simulation
  • Save the TCL script as localization.tcl.
  • Execute it in NS2 using the following command:

ns localization.tcl

  1. Analysing Results
  • After execute the simulation, measure the trace file (localization.tr) to see how precisely the nodes assessed their positions.
  • We can envision the node positions using the NAM file (localization.nam) to see how close the calculated positions are to the authentic ones.
  1. Further Enhancements
  • RSSI-Based Localization: We can mimic localization using Received Signal Strength Indicator (RSSI) to calculate distances to anchors according to signal strength.
  • Error Analysis: Execute functions to estimate localization error (the difference among the original position and the estimated position).
  • Mobile Anchors: To mimic mobile anchor nodes that move and help other nodes localize themselves as they pass by.
  • Advanced Localization Algorithms: Execute more cutting-edge localization techniques like APIT (Approximate Point-In-Triangulation) or MDS (Multidimensional Scaling).

In the conclusion, we provide more details and offer the sample snippets on executing the Network Localization Scheme in ns2 tool by using the above techniques. Additional information will be provided if needed. You can rely on ns2project.com to effectively implement the Network Localization Scheme in NS2 just for your project. Our team will take care of analyzing the project’s performance in a way that fits your needs perfectly.