How to Implement Drone based VANET in ns2

To implement the drone-based Vehicular Ad-Hoc Network (VANET) in ns2, we have to simulate a network that has drones (Unmanned Aerial Vehicles or UAVs) which communicate with vehicles on the ground. Drones can optimize VANETs by offering aerial communication relays, enhancing coverage and enabling communication amongst distant vehicles.

Follow the below demonstration to accomplish it in ns2:

Step-by-Step Implementation:

  1. Set Up the NS2 Environment:
  • Make certain to install ns2 on your computer with helps for wireless simulations.
  • Get used to with writing TCL scripts, as NS2 simulations are controlled across TCL.
  1. Define the Network Topology:
  • Generate a network topology that contains vehicles (ground nodes) and drones (aerial nodes). The vehicles will interact with one another and with the drones.

# Define the simulator

set ns [new Simulator]

# Create a trace file for analysis

set tracefile [open out.tr w]

$ns trace-all $tracefile

# Create a NAM file for animation

set namfile [open out.nam w]

$ns namtrace-all-wireless $namfile 10

# Set up the wireless network parameters

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(x)      1000                         ;# X dimension of the topography

set opt(y)      1000                         ;# Y dimension of the topography

set opt(adhocRouting) AODV                   ;# Routing protocol for VANET

# Create a topography object

create-god 30

# Configure the nodes

$ns node-config -adhocRouting $opt(adhocRouting) \

-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 \

-agentTrace ON \

-routerTrace ON \

-macTrace OFF \

-movementTrace ON

# Create nodes: Drones and vehicles

set drone1 [$ns node]   ;# Drone 1 (aerial node)

set drone2 [$ns node]   ;# Drone 2 (aerial node)

set vehicle1 [$ns node]  ;# Vehicle 1 (ground node)

set vehicle2 [$ns node]  ;# Vehicle 2 (ground node)

set vehicle3 [$ns node]  ;# Vehicle 3 (ground node)

# Set initial positions for the drones and vehicles

$drone1 set X_ 500.0

$drone1 set Y_ 800.0

$drone1 set Z_ 300.0  ;# Higher Z coordinate indicates altitude

$drone2 set X_ 600.0

$drone2 set Y_ 900.0

$drone2 set Z_ 300.0  ;# Higher Z coordinate indicates altitude

$vehicle1 set X_ 200.0

$vehicle1 set Y_ 200.0

$vehicle1 set Z_ 0.0  ;# Ground level

$vehicle2 set X_ 300.0

$vehicle2 set Y_ 300.0

$vehicle2 set Z_ 0.0  ;# Ground level

$vehicle3 set X_ 400.0

$vehicle3 set Y_ 400.0

$vehicle3 set Z_ 0.0  ;# Ground level

  1. Define Mobility Models:
  • Build mobility for both the drones and the vehicles. Drones will have various mobility patterns related to vehicles.

# Define mobility for Drone 1

$ns at 1.0 “$drone1 setdest 700.0 900.0 20.0”

$ns at 3.0 “$drone1 setdest 400.0 600.0 20.0”

# Define mobility for Drone 2

$ns at 1.0 “$drone2 setdest 500.0 800.0 25.0”

$ns at 3.0 “$drone2 setdest 600.0 900.0 25.0”

# Define mobility for Vehicle 1

$ns at 1.0 “$vehicle1 setdest 300.0 300.0 15.0”

$ns at 3.0 “$vehicle1 setdest 400.0 400.0 15.0”

# Define mobility for Vehicle 2

$ns at 1.0 “$vehicle2 setdest 400.0 400.0 15.0”

$ns at 3.0 “$vehicle2 setdest 500.0 500.0 15.0”

# Define mobility for Vehicle 3

$ns at 1.0 “$vehicle3 setdest 500.0 500.0 15.0”

$ns at 3.0 “$vehicle3 setdest 600.0 600.0 15.0”

  1. Simulate Communication Between Nodes:
  • Use the TCP or UDP agents to configure communication amongst the drones and vehicles. The drones can pass information amongst vehicles or offer data to them.

# Vehicle 1 sends data to Drone 1

set udp_vehicle1 [new Agent/UDP]

$ns attach-agent $vehicle1 $udp_vehicle1

set udp_drone1 [new Agent/UDP]

$ns attach-agent $drone1 $udp_drone1

$ns connect $udp_vehicle1 $udp_drone1

# Vehicle 2 sends data to Drone 2

set udp_vehicle2 [new Agent/UDP]

$ns attach-agent $vehicle2 $udp_vehicle2

set udp_drone2 [new Agent/UDP]

$ns attach-agent $drone2 $udp_drone2

$ns connect $udp_vehicle2 $udp_drone2

# Vehicle 3 sends data to Vehicle 1 through Drone 1

set udp_vehicle3 [new Agent/UDP]

$ns attach-agent $vehicle3 $udp_vehicle3

set udp_vehicle1_sink [new Agent/UDP]

$ns attach-agent $vehicle1 $udp_vehicle1_sink

$ns connect $udp_vehicle3 $udp_vehicle1_sink

# Start sending traffic

set cbr1 [new Application/Traffic/CBR]

$cbr1 set packetSize_ 512

$cbr1 set interval_ 0.05

$cbr1 attach-agent $udp_vehicle1

$ns at 2.0 “$cbr1 start”

set cbr2 [new Application/Traffic/CBR]

$cbr2 set packetSize_ 512

$cbr2 set interval_ 0.05

$cbr2 attach-agent $udp_vehicle2

$ns at 2.5 “$cbr2 start”

set cbr3 [new Application/Traffic/CBR]

$cbr3 set packetSize_ 512

$cbr3 set interval_ 0.05

$cbr3 attach-agent $udp_vehicle3

$ns at 3.0 “$cbr3 start”

  1. Run the Simulation:
  • State when the simulation should finish and execute it. The finish procedure will close the trace files and blast-off NAM for visualization.

# Define the finish procedure

proc finish {} {

global ns tracefile namfile

$ns flush-trace

close $tracefile

close $namfile

exec nam out.nam &

exit 0

}

# Schedule the finish procedure at 10 seconds

$ns at 10.0 “finish”

# Run the simulation

$ns run

  1. Analyze the Results:
  • Evaluate the packet delivery, delays, throughput and other performance metrics by using the trace file (out.tr).
  • Open the NAM file (out.nam) to envision the network operations and monitor the interactions amongst drones and vehicles.
  1. Customize and Extend:
  • You can tailor the simulation by:
    • Attaching more drones and vehicles, changing their mobility patterns.
    • Executing certain routing protocols developed for VANETs with drone involvement.
    • Presenting environment like traffic blockage, hindrances, or network failures to observe how the drones can help in enhancing communication.
    • Replicate emergency react scenarios where drones assist in offering real-time data to vehicles.

Example Summary:

In this sample, we configure a simple drone-based VANET simulation in ns2. Drones can interact with vehicles on the ground and they support for passing information amongst vehicles or offering extra data coverage. It contains mobility and communication amidst drones and vehicles.

Advanced Considerations:

  • For more compound situations, you might want to explore adaptive routing protocols where drones dynamically fine-tuning routes depend on the network conditions.
  • Handle the communication through larger areas where task distribution, load balancing and failure recuperation occurs by executing multi-drone coordination.

Debugging and Optimization:

  • Utilize the trace-all command to debug the simulation and assess packet flows.
  • Enhance the simulation by refining mobility models, modifying the communication protocols, and change network parameters.

With the help of the step-by-step process, we provide as much information as possible to help you learn and implement the Drone-based VANET using ns2 tool. you need to start by defining network topology and their mobility models. You can also customize the protocol according to your requirements.

Count on us for the coolest project ideas and topics. Let our experts handle your Drone-based VANET implementation in ns2.