How to implement ZRP protocol in OMNeT++
To implement the Zone Routing Protocol (ZRP) in OMNeT++ has encompasses numerous steps that setup the simulation then familiarize the ZRP protocol then generate the protocol modules and then incorporate them with the INET framework, and validating the implementation. Here’s a detailed guide to help you through this process.
Step-by-Step Implementation:
Step 1: Set Up OMNeT++ and INET Framework
- Install OMNeT++: Download and install the latest version of OMNeT++.
- Install INET Framework: Download and install the INET framework from the INET repository.
Step 2: Understand ZRP Protocol
ZRP is a hybrid routing protocol that integrates proactive and reactive routing. It consists of:
- IntrA-zone Routing Protocol (IARP): Proactive routing inside the zones.
- Inter-zone Routing Protocol (IERP): Reactive routing among the zones.
- Bordercast Resolution Protocol (BRP): For sending route queries to border nodes.
Step 3: Create the ZRP Protocol Modules
Define the Modules in .ned Files
Create .ned files for the ZRP protocol modules: IARP, IERP, BRP, and the main ZRP module.
IARP.ned
simple IARP
{
parameters:
double helloInterval @unit(s) = default(1s);
gates:
input fromNetworkLayer;
output toNetworkLayer;
}
IERP.ned
simple IERP
{
parameters:
double routeRequestTimeout @unit(s) = default(2s);
gates:
input fromNetworkLayer;
output toNetworkLayer;
}
BRP.ned
simple BRP
{
gates:
input fromIarp;
input fromIerp;
output toNetworkLayer;
}
ZRP.ned
simple ZRP
{
parameters:
double zoneRadius @unit(m) = default(2);
gates:
input fromAppLayer;
output toAppLayer;
input fromNetworkLayer;
output toNetworkLayer;
}
Implement the Modules in C++
Create the corresponding .cc and .h files.
IARP.h
#ifndef __IARP_H_
#define __IARP_H_
#include <omnetpp.h>
#include “inet/networklayer/contract/IRoutingTable.h”
using namespace omnetpp;
using namespace inet;
class IARP : public cSimpleModule
{
private:
double helloInterval;
IRoutingTable *routingTable;
cMessage *helloMsg;
protected:
virtual void initialize() override;
virtual void handleMessage(cMessage *msg) override;
void sendHello();
void processHello(cMessage *msg);
public:
IARP();
virtual ~IARP();
};
#endif
IARP.cc
#include “IARP.h”
Define_Module(IARP);
IARP::IARP()
{
helloMsg = nullptr;
}
IARP::~IARP()
{
cancelAndDelete(helloMsg);
}
void IARP::initialize()
{
helloInterval = par(“helloInterval”);
routingTable = getModuleFromPar<IRoutingTable>(par(“routingTableModule”), this);
helloMsg = new cMessage(“sendHello”);
scheduleAt(simTime() + helloInterval, helloMsg);
}
void IARP::handleMessage(cMessage *msg)
{
if (msg == helloMsg)
{
sendHello();
scheduleAt(simTime() + helloInterval, helloMsg);
}
else
{
processHello(msg);
}
}
void IARP::sendHello()
{
cMessage *hello = new cMessage(“Hello”);
send(hello, “toNetworkLayer”);
}
void IARP::processHello(cMessage *msg)
{
// Implement processing of Hello message
delete msg;
}
IERP.h
#ifndef __IERP_H_
#define __IERP_H_
#include <omnetpp.h>
#include “inet/networklayer/contract/IRoutingTable.h”
using namespace omnetpp;
using namespace inet;
class IERP : public cSimpleModule
{
private:
double routeRequestTimeout;
IRoutingTable *routingTable;
cMessage *routeRequestMsg;
protected:
virtual void initialize() override;
virtual void handleMessage(cMessage *msg) override;
void sendRouteRequest();
void processRouteRequest(cMessage *msg);
void processRouteReply(cMessage *msg);
public:
IERP();
virtual ~IERP();
};
#endif
IERP.cc
#include “IERP.h”
Define_Module(IERP);
IERP::IERP()
{
routeRequestMsg = nullptr;
}
IERP::~IERP()
{
cancelAndDelete(routeRequestMsg);
}
void IERP::initialize()
{
routeRequestTimeout = par(“routeRequestTimeout”);
routingTable = getModuleFromPar<IRoutingTable>(par(“routingTableModule”), this);
routeRequestMsg = new cMessage(“sendRouteRequest”);
scheduleAt(simTime() + uniform(0, routeRequestTimeout), routeRequestMsg);
}
void IERP::handleMessage(cMessage *msg)
{
if (msg == routeRequestMsg)
{
sendRouteRequest();
scheduleAt(simTime() + routeRequestTimeout, routeRequestMsg);
}
else if (strcmp(msg->getName(), “RouteRequest”) == 0)
{
processRouteRequest(msg);
}
else if (strcmp(msg->getName(), “RouteReply”) == 0)
{
processRouteReply(msg);
}
else
{
// Handle other messages
}
}
void IERP::sendRouteRequest()
{
cMessage *routeRequest = new cMessage(“RouteRequest”);
send(routeRequest, “toNetworkLayer”);
}
void IERP::processRouteRequest(cMessage *msg)
{
// Implement processing of Route Request message
delete msg;
}
void IERP::processRouteReply(cMessage *msg)
{
// Implement processing of Route Reply message
delete msg;
}
BRP.h
#ifndef __BRP_H_
#define __BRP_H_
#include <omnetpp.h>
using namespace omnetpp;
class BRP : public cSimpleModule
{
protected:
virtual void initialize() override;
virtual void handleMessage(cMessage *msg) override;
public:
BRP();
virtual ~BRP();
};
#endif
BRP.cc
#include “BRP.h”
Define_Module(BRP);
BRP::BRP()
{
}
BRP::~BRP()
{
}
void BRP::initialize()
{
}
void BRP::handleMessage(cMessage *msg)
{
// Implement BRP logic
delete msg;
}
ZRP.h
#ifndef __ZRP_H_
#define __ZRP_H_
#include <omnetpp.h>
using namespace omnetpp;
class ZRP : public cSimpleModule
{
private:
double zoneRadius;
protected:
virtual void initialize() override;
virtual void handleMessage(cMessage *msg) override;
public:
ZRP();
virtual ~ZRP();
};
#endif
ZRP.cc
#include “ZRP.h”
#include “IARP.h”
#include “IERP.h”
#include “BRP.h”
Define_Module(ZRP);
ZRP::ZRP()
{
}
ZRP::~ZRP()
{
}
void ZRP::initialize()
{
zoneRadius = par(“zoneRadius”);
// Initialize IARP, IERP, and BRP modules
}
void ZRP::handleMessage(cMessage *msg)
{
// Implement handling of messages between IARP, IERP, and BRP
}
Step 4: Integrate with Simulation Model
Integrate your ZRP modules into a network simulation model.
Network Configuration .ned File
network ZRPNetwork
{
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 = ZRPNetwork
*.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 = “ZRP”
Step 5: Test and Debug
- Run Simulations: Execute simulations to verify the characteristics of ZRP modules under numerous network conditions.
- Analyse Results: Validate the correctness and performance of implementation.
- Debugging: Use OMNeT++’s debugging tools to troubleshoot any issues.
Here, we demonstrate and show how the ZRP protocol will generate the network then applies the ZRP protocol in the INET framework that used in OMNeT++ tool. We plan to provide the detailed information regarding the ZRP protocol implementation process in further scripts.
The researchers at omnet-manual.com are here to help with the implementation and simulation of the ZRP protocol in OMNeT++. If you need more support, just follow us! We’re all about working on modules with the INET framework and making sure everything’s validated.