How to Start VANET Protocols Projects Using NS3

To start Vehicular Ad Hoc Networks (VANETs) in NS3 that can replicate to utilize mobility models signifying vehicle movement and by executing the routing protocols that are customized for vehicular environments. VANETs frequently utilize some protocols including AODV (Ad hoc On-Demand Distance Vector), OLSR (Optimized Link State Routing), DSR (Dynamic Source Routing), and DSDV (Destination-Sequenced Distance Vector). In NS3, for realistic mobility patterns VANET simulations can also utilise SUMO (Simulation of Urban Mobility) that can introduce to NS3.

Following is a sequential methodology to making a VANET simulation in NS3 to concentrate on how to configuring mobility, choosing a routing protocol, and setting up applications for vehicular interactions.

Steps to Start VANET Protocols Projects in NS3

  1. Install NS3

We can configure it including the below commands (assuming a Linux environment) as NS3 doesn’t install:

# Update system and install dependencies

sudo apt update

sudo apt install -y gcc g++ python3 python3-dev cmake libgsl-dev libsqlite3-dev

# Clone the NS-3 repository

git clone https://gitlab.com/nsnam/ns-3-dev.git ns-3

cd ns-3

# Configure and build NS-3

./ns3 configure –enable-examples –enable-tests

./ns3 build

  1. Install SUMO for Realistic Mobility (Optional but Recommended)

SUMO can be utilised, making realistic vehicle mobility traces and it is frequently utilised within VANET simulations.

# Install SUMO

sudo apt update

sudo apt install sumo sumo-tools sumo-doc

  1. Create a New Script for VANET Protocol Simulation
  1. In the scratch directory of NS3, we need to make a new file then name it like vanet_protocol_simulation.cc.
  2. Configure a VANET simulation using a mobility model, WiFi ad hoc communication, and a VANET routing protocol, we can follow these code.

Basic Structure of vanet_protocol_simulation.cc:

#include “ns3/core-module.h”

#include “ns3/network-module.h”

#include “ns3/internet-module.h”

#include “ns3/aodv-helper.h”

#include “ns3/dsr-helper.h”

#include “ns3/dsdv-helper.h”

#include “ns3/olsr-helper.h”

#include “ns3/mobility-module.h”

#include “ns3/wifi-module.h”

#include “ns3/applications-module.h”

#include “ns3/netanim-module.h”

using namespace ns3;

NS_LOG_COMPONENT_DEFINE(“VanetProtocolSimulation”);

int main(int argc, char *argv[]) {

// Enable logging for debugging

LogComponentEnable(“UdpEchoClientApplication”, LOG_LEVEL_INFO);

LogComponentEnable(“UdpEchoServerApplication”, LOG_LEVEL_INFO);

// Create nodes for vehicles

NodeContainer vehicles;

vehicles.Create(20); // Example with 20 vehicles

// Configure mobility model to represent vehicle movement

MobilityHelper mobility;

mobility.SetPositionAllocator(“ns3::RandomRectanglePositionAllocator”,

“X”, StringValue(“ns3::UniformRandomVariable[Min=0.0|Max=500.0]”),

“Y”, StringValue(“ns3::UniformRandomVariable[Min=0.0|Max=500.0]”));

mobility.SetMobilityModel(“ns3::RandomWaypointMobilityModel”,

“Speed”, StringValue(“ns3::UniformRandomVariable[Min=10.0|Max=20.0]”),

“Pause”, StringValue(“ns3::ConstantRandomVariable[Constant=0.5]”));

mobility.Install(vehicles);

// Configure WiFi for ad hoc communication

WifiHelper wifi;

wifi.SetStandard(WIFI_STANDARD_80211p);  // Using 802.11p for vehicular networks

YansWifiPhyHelper wifiPhy = YansWifiPhyHelper::Default();

YansWifiChannelHelper wifiChannel = YansWifiChannelHelper::Default();

wifiPhy.SetChannel(wifiChannel.Create());

WifiMacHelper wifiMac;

wifiMac.SetType(“ns3::AdhocWifiMac”);

NetDeviceContainer devices = wifi.Install(wifiPhy, wifiMac, vehicles);

// Install Internet stack and configure a VANET routing protocol

InternetStackHelper internet;

// Uncomment one of the following lines to select a VANET routing protocol

AodvHelper aodv;

internet.SetRoutingHelper(aodv);  // Use AODV as the routing protocol

// OlsrHelper olsr;

// internet.SetRoutingHelper(olsr);  // Use OLSR as the routing protocol

// DsdvHelper dsdv;

// internet.SetRoutingHelper(dsdv);  // Use DSDV as the routing protocol

// DsrMainHelper dsrMain;

// DsrHelper dsr;

// internet.Install(vehicles);

// dsrMain.Install(dsr, vehicles);

internet.Install(vehicles);

// Assign IP addresses to devices

Ipv4AddressHelper ipv4;

ipv4.SetBase(“10.1.1.0”, “255.255.255.0”);

Ipv4InterfaceContainer interfaces = ipv4.Assign(devices);

// Set up a UDP echo server on one vehicle to test connectivity

UdpEchoServerHelper echoServer(9);

ApplicationContainer serverApps = echoServer.Install(vehicles.Get(0));

serverApps.Start(Seconds(1.0));

serverApps.Stop(Seconds(10.0));

// Set up a UDP echo client on another vehicle to communicate with the server

UdpEchoClientHelper echoClient(interfaces.GetAddress(0), 9);

echoClient.SetAttribute(“MaxPackets”, UintegerValue(5));

echoClient.SetAttribute(“Interval”, TimeValue(Seconds(1.0)));

echoClient.SetAttribute(“PacketSize”, UintegerValue(1024));

ApplicationContainer clientApps = echoClient.Install(vehicles.Get(19));

clientApps.Start(Seconds(2.0));

clientApps.Stop(Seconds(10.0));

// Enable animation tracing

AnimationInterface anim(“vanet_protocol_simulation.xml”);

// Run the simulation

Simulator::Stop(Seconds(10.0));

Simulator::Run();

Simulator::Destroy();

return 0;

}

Explanation of the Code

  • Node Creation: We can make 20 nodes to signify vehicles within the VANET.
  • Mobility Model: Utilise RandomWaypointMobilityModel, replicating the vehicle movement including each node to arbitrarily travel in a certain area.
  • WiFi Ad Hoc Mode (802.11p): WiFi is set up utilising the 802.11p standard that is appropriate for vehicular interaction.
  • Routing Protocols:
    • AODV (Ad hoc On-Demand Distance Vector): A reactive protocol, which launches routes only if needed. For OLSR, DSDV, or DSR, we can uncomment lines utilising other routing protocols.
  • UDP Echo Applications:
    • A UDP Echo Server is configured at vehicle 0.
    • A UDP Echo Client on vehicle 19 transmits packets to the server to experiment end-to-end connectivity over the network.
  • Animation Tracing:
    • NetAnim: Makes an animation trace file (vanet_protocol_simulation.xml), which can be envisioned using NetAnim for observing the node movements and communications.
  1. Build and Run the Simulation
  1. In the scratch directory, we can save vanet_protocol_simulation.cc.
  2. Go to terminal then pass through to the NS3 directory, and make the script:

./ns3 build

  1. Run the simulation:

./ns3 run scratch/vanet_protocol_simulation

  1. In the created vanet_protocol_simulation.xml file in NetAnim to envision the simulation:

netanim vanet_protocol_simulation.xml

  1. (Optional) Use SUMO for Realistic Mobility

If we require realistic vehicle movement patterns then making mobility traces and to introduce them to NS3 utilising SUMO.

  1. Generate Mobility Trace in SUMO:
    • In SUMO, make a simulation including vehicles to travel across a realistic road network.
    • Transfer the mobility trace depends on file like mobility.tcl.
  2. Integrate Mobility Trace in NS3:
    • In NS3, insert the SUMO mobility trace using Ns2MobilityHelper.

Ns2MobilityHelper ns2Mobility(“mobility.tcl”);

ns2Mobility.Install(vehicles);

Further Experimentation Ideas

To discover further VANET protocols, we can deliberate following experiments:

  • Adjusting Node Density: We need to maximize ore minimize the volume of vehicles, examining scalability of protocol.
  • Using Different Mobility Models: Test with other NS3 mobility models or launch more complex SUMO situations.
  • Comparing Protocols: We can execute the simulations including AODV, OLSR, DSR, and DSDV, examining the variations of performance.
  • Measure Performance Metrics: Estimate the performance indicators such as packet delivery ratio, latency, and routing overhead utilising FlowMonitor.
  • Simulate Emergency Messages: We need to execute a broadcasting mechanism to experiment how rapidly messages broadcast over the network.

From this guide, we explicitly understood the basic simulation approach with sample coding that were relates to the VANET Protocols projects, executed and simulated in the tool of NS3. If you need more information about this topic we will provide that too.

At phdprojects.org, we are dedicated to helping you discover the most suitable project topics and simulation outcomes to initiate your VANET Protocols Projects utilizing the NS3 tool. Collaborating with us will ensure you achieve impressive project results. Allow us to manage the performance aspects of your project. We provide a range of project ideas and topics related to AODV (Ad hoc On-Demand Distance Vector), OLSR (Optimized Link State Routing), DSR (Dynamic Source Routing), and DSDV (Destination-Sequenced Distance Vector). Share your project details with us, and we will guide you towards the best project solutions.