How to Implement Network Multiple Access in NS2

To implement Network Multiple Access in NS2 has needs to mimic on how multiple users or nodes access the shared communication medium effectively and without collisions. Multiple access approaches are vital in wireless networks to permit numerous nodes to interact simultaneously without interfering with each other. Maintain communication with us for innovative implementation advice, as we provide the best project concepts along with support for their execution.

There are numerous types of Multiple Access approaches, like:

  1. Time Division Multiple Access (TDMA): Nodes sends in assigned time slots to prevent collisions.
  2. Frequency Division Multiple Accesses (FDMA): Diverse frequencies are allotted to numerous users.
  3. Code Division Multiple Access (CDMA): Each user transfers simultaneously however using unique codes to isolate the signals.
  4. Carrier Sense Multiple Access (CSMA): Nodes sense the channel before routing to prevent collisions.

In this sample, we will concentrate on CSMA/CA (Carrier Sense Multiple Access with Collision Avoidance), that is usually used in IEEE 802.11 (WiFi) networks. CSMA/CA attempts to minimize the chances of collisions by sensing the channel before routing and using random backoff timers.

Step-by-Step Implementation:

  1. Understanding Multiple Access in NS2
  • CSMA/CA: In CSMA/CA, each node listens to the channel (carrier sensing) before routing. If the channel is busy, the node waits and backs off for a random period before attempting to route again.
  • Backoff Mechanism: To evade simultaneous reattempts after a collision or busy channel, nodes use a backoff mechanism that establishes random latency before rerouting.
  1. Steps to Implement Multiple Access (CSMA/CA) in NS2
  1. Configure the wireless nodes and the channel.
  2. Adapt the MAC layer to mimic CSMA/CA behaviour.
  3. Setup the backoff and retry mechanisms to manage the collisions.
  4. To mimic the traffic among multiple nodes to measure the performance.

Step 1: Set up the Wireless Nodes and Channel in TCL

Initiate by describing the wireless nodes, generating the network, and configure the channel for communication. We will generate a basic wireless network with multiple nodes using the 802.11 MAC layer (which already uses CSMA/CA).

# Create a simulator instance

set ns [new Simulator]

# Create trace and nam files for output

set tracefile [open multiple_access.tr w]

set namfile [open multiple_access.nam w]

$ns trace-all $tracefile

$ns namtrace-all $namfile

# Define 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 5]  ;# 5 nodes in the network

# Define node parameters for wireless communication

set opt(chan)       Channel/WirelessChannel

set opt(prop)       Propagation/TwoRayGround

set opt(netif)      Phy/WirelessPhy

set opt(mac)        Mac/802_11      ;# CSMA/CA via 802.11 MAC

set opt(ifq)        Queue/DropTail/PriQueue

set opt(ll)         LL

set opt(ant)        Antenna/OmniAntenna

set opt(x)          1000

set opt(y)          1000

# Create wireless nodes

for {set i 0} {$i < 5} {incr i} {

set node_($i) [$ns node]

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

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

$node_($i) set X_ $x

$node_($i) set Y_ $y

$node_($i) set Z_ 0.0

}

Step 2: Modify the MAC Layer for CSMA/CA

The Mac/802_11 in NS2 already executes CSMA/CA. To mimic CSMA/CA in detail, we can adapt or improve the backoff mechanism, collision avoidance, and channel sensing.

We can adjust or monitor the following MAC layer parameters:

  1. DIFS (Distributed Inter-frame Space): The minimum time a node must wait after the medium becomes idle.
  2. Backoff Time: Randomly selected latency before transmission to mitigate the collisions.
  3. RTS/CTS (Request to Send / Clear to Send): Optional mechanism to prevent collisions by storing the channel.

Example of Backoff Timer and DIFS in CSMA/CA

The backoff mechanism is vital to CSMA/CA. In NS2, the backoff time is set according to a random number and then minimized after each idle period (DIFS).

# Define a backoff mechanism to avoid collisions

proc backoff {node} {

set backoff_time [expr rand() * 0.01]  ;# Random backoff time (0 to 10ms)

puts “Node [$node id] backing off for $backoff_time seconds”

return $backoff_time

}

# Function to simulate carrier sensing and backoff in CSMA/CA

proc csma_ca_carrier_sense {node} {

set channel_busy 0   ;# 0 means idle, 1 means busy

# Check if the channel is busy

if {$channel_busy == 1} {

# Channel is busy, apply backoff

set backoff_time [backoff $node]

puts “Node [$node id] backing off for $backoff_time seconds”

} else {

# Channel is idle, transmit immediately

puts “Node [$node id] is transmitting”

# Trigger the transmission here

}

}

# Example traffic function where CSMA/CA is applied

proc transmit_with_csma_ca {node} {

# Simulate carrier sensing with CSMA/CA

csma_ca_carrier_sense $node

}

Step 3: Simulate Traffic with Multiple Access (CSMA/CA)

In this step, traffic is created among multiple nodes. Each node will validate for the availability of the channel using CSMA/CA before transmitting.

# Function to start traffic generation using CSMA/CA

proc start_traffic {} {

global ns node_

# Create UDP agents and attach them to nodes

for {set i 0} {$i < 5} {incr i} {

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 (constant bit rate)

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

$cbr_($i) set packetSize_ 512

$cbr_($i) set interval_ 0.1

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

# Transmit using CSMA/CA carrier sense

$ns at [expr rand() * 2.0] “transmit_with_csma_ca $node_($i)”

}

}

# Start the traffic at 1 second

$ns at 1.0 “start_traffic”

Step 4: End the Simulation

Describe the end of the simulation and execute the simulation for 100 seconds.

# End simulation after 100 seconds

$ns at 100.0 “finish”

# End simulation procedure

proc finish {} {

global ns tracefile namfile

close $tracefile

close $namfile

$ns halt

}

# Run the simulation

$ns run

  1. Explanation of the Script
  • Carrier Sensing (CSMA/CA): The csma_ca_carrier_sense function mimics on how nodes sense the channel. If the channel is busy, the node backs off for a random amount of time before trying again.
  • Backoff Mechanism: A random backoff time is created for each node if the channel is busy. This prevents collisions by make sure that nodes don’t transmit instantaneously after a busy channel.
  • Traffic Generation: CBR traffic is created among multiple nodes. Each node uses CSMA/CA to sense the channel and prevent collisions during transmission.
  1. Running the Simulation
  1. Save the TCL script as multiple_access.tcl.
  2. Execute the simulation using the following command:

ns multiple_access.tcl

  1. Analysing Results
  • After running the simulation, evaluate the trace file (multiple_access.tr) and the NAM file (multiple_access.nam) to measure the behaviour of the network.
  • Key metrics to observe include:
    • Packet Delivery Ratio: How many packets were successfully delivered without collisions?
    • Latency: Extent the latency triggered by the backoff and collision avoidance mechanism.
    • Collision Rate: Monitor on how often collisions happens when multiple nodes attempt to access the channel.
  1. Further Enhancements
  • Advanced CSMA/CA Mechanisms: We can execute more advanced versions of CSMA/CA, like dynamic backoff times or diverse channel sensing mechanisms.
  • TDMA or FDMA: If we are fascinated in other multiple access approaches such as TDMA or FDMA, that can implement time or frequency slots in which each node transmits in its allocated slot or frequency.
  • Collision Detection (CSMA/CD): To mimic CSMA/CD (used in Ethernet) in which the nodes can identify collisions and reroute the packets.

Through this brief procedure, you can get to understand more about the implementation and their approaches regarding the Network Multiple Access including sample snippets using ns2 tool. We plan to deliver the more information regarding the Network Multiple Access.