How to implement reactive protocol in OMNeT++
To implement a reactive routing protocol in OMNeT++ has numerous steps and the reactive protocol used in Mobile ad hoc networks (MANETs) that is the Ad hoc On-Demand Distance Vector (AODV) protocol. The given below is the brief procedures on how to implement the AODV in OMNeT++ using the INET framework.
Step-by-Step Implementation:
Step 1: Set Up OMNeT++ and INET Framework
- Install OMNeT++: Download and install the latest version of OMNeT++ from the OMNeT++
- Install INET Framework: Download and install the INET framework from the INET repository.
Step 2: Understand AODV Protocol
AODV is a reactive routing protocol commonly used in MANETs. Key concepts include:
- Route Requests (RREQs): Broadcast to determine routes.
- Route Replies (RREPs): Sent in response to RREQs.
- Route Errors (RERRs): Indicate link breakages.
- Hello Messages: Optional messages to detect link status to neighbours.
Step 3: Create the AODV Protocol Module
Define the Module in .ned File
Create a .ned file for the AODV protocol module.
simple AODV
{
parameters:
double helloInterval @unit(s) = default(1s);
double rreqRetryTimeout @unit(s) = default(2s);
gates:
input fromNetworkLayer;
output toNetworkLayer;
input fromMacLayer;
output toMacLayer;
}
Implement the Module in C++
Create the corresponding .cc and .h files.
AODV.h
#ifndef __AODV_H_
#define __AODV_H_
#include <omnetpp.h>
#include “inet/networklayer/contract/IRoutingTable.h”
#include “inet/networklayer/common/L3AddressResolver.h”
#include “inet/networklayer/ipv4/IPv4Datagram.h”
#include <map>
using namespace omnetpp;
using namespace inet;
class AODV : public cSimpleModule
{
private:
double helloInterval;
double rreqRetryTimeout;
IRoutingTable *routingTable;
cMessage *helloMsg;
cMessage *rreqRetryMsg;
std::map<L3Address, int> rreqCache; // Cache for RREQs to prevent flooding
protected:
virtual void initialize() override;
virtual void handleMessage(cMessage *msg) override;
void sendHello();
void processHello(cMessage *msg);
void sendRREQ(L3Address destAddr);
void processRREQ(cMessage *msg);
void sendRREP(L3Address destAddr);
void processRREP(cMessage *msg);
void processRERR(cMessage *msg);
public:
AODV();
virtual ~AODV();
};
#endif
AODV.cc
#include “AODV.h”
Define_Module(AODV);
AODV::AODV()
{
helloMsg = nullptr;
rreqRetryMsg = nullptr;
}
AODV::~AODV()
{
cancelAndDelete(helloMsg);
cancelAndDelete(rreqRetryMsg);
}
void AODV::initialize()
{
helloInterval = par(“helloInterval”);
rreqRetryTimeout = par(“rreqRetryTimeout”);
routingTable = getModuleFromPar<IRoutingTable>(par(“routingTableModule”), this);
helloMsg = new cMessage(“sendHello”);
rreqRetryMsg = new cMessage(“sendRREQRetry”);
scheduleAt(simTime() + helloInterval, helloMsg);
}
void AODV::handleMessage(cMessage *msg)
{
if (msg == helloMsg)
{
sendHello();
scheduleAt(simTime() + helloInterval, helloMsg);
}
else if (msg == rreqRetryMsg)
{
// Handle RREQ retries if necessary
scheduleAt(simTime() + rreqRetryTimeout, rreqRetryMsg);
}
else if (strcmp(msg->getName(), “RREQ”) == 0)
{
processRREQ(msg);
}
else if (strcmp(msg->getName(), “RREP”) == 0)
{
processRREP(msg);
}
else if (strcmp(msg->getName(), “RERR”) == 0)
{
processRERR(msg);
}
else if (strcmp(msg->getName(), “Hello”) == 0)
{
processHello(msg);
}
else
{
// Handle other messages
}
}
void AODV::sendHello()
{
cMessage *hello = new cMessage(“Hello”);
send(hello, “toNetworkLayer”);
}
void AODV::processHello(cMessage *msg)
{
// Implement processing of Hello message
delete msg;
}
void AODV::sendRREQ(L3Address destAddr)
{
cMessage *rreq = new cMessage(“RREQ”);
rreq->addPar(“destAddr”) = destAddr.str().c_str();
send(rreq, “toNetworkLayer”);
}
void AODV::processRREQ(cMessage *msg)
{
// Implement processing of RREQ message
delete msg;
}
void AODV::sendRREP(L3Address destAddr)
{
cMessage *rrep = new cMessage(“RREP”);
rrep->addPar(“destAddr”) = destAddr.str().c_str();
send(rrep, “toNetworkLayer”);
}
void AODV::processRREP(cMessage *msg)
{
// Implement processing of RREP message
delete msg;
}
void AODV::processRERR(cMessage *msg)
{
// Implement processing of RERR message
delete msg;
}
Step 4: Integrate with Simulation Model
Integrate AODV module into a network simulation model.
Network Configuration .ned File
network AODVNetwork
{
submodules:
host1: StandardHost {
parameters:
@display(“p=100,100”);
}
host2: StandardHost {
parameters:
@display(“p=300,100”);
}
// Add more hosts as needed
connections:
host1.pppg++ <–> { @display(“m=100,100”); } <–> host2.pppg++;
}
omnetpp.ini Configuration
network = AODVNetwork
*.host*.pppg[*].queue.typename = “DropTailQueue”
*.host*.ipv4.routingTable = “inet.networklayer.routing.manet.Router”
*.host*.networkLayer.networkProtocol.typename = “IPv4NetworkLayer”
*.host*.transportLayer.tcp.typename = “Tcp”
*.host*.transportLayer.udp.typename = “Udp”
*.host*.application[*].typename = “UdpBasicApp”
*.host*.application[*].destAddresses = “host1” // Set destination as needed
*.host*.application[*].destPort = 2000
*.host*.application[*].startTime = uniform(0s, 10s)
*.host*.application[*].sendInterval = uniform(1s, 2s)
*.host*.application[*].packetLength = 512B
*.host*.app[0].typename = “AODV”
Step 5: Test and Debug
- Run Simulations: Implement simulations to check the activities of AODV module under innumerable network conditions.
- Analyse Results: Verify the correctness and performance of implementation.
- Debugging: Use OMNeT++’s debugging tools to troubleshoot any issues.
In this page, we show the brief structure on how to setup the simulation and execute the reactive routing protocol and it is used commonly used in the MANET environment. Additional specific details were provided about the reactive routing protocol. We give complete support for the implementation of the reactive protocol in the OMNeT++ tool, including simulation results and sharing the best project performance results. According to your research, we are working on the Ad hoc On-Demand Distance Vector (AODV) protocol, which is a reactive protocol used in mobile ad hoc networks.