How to Start Border HWMP Protocol Projects Using OMNeT++

To start Border HWMP (Hybrid Wireless Mesh Protocol) using OMNeT++ environment which is a protocol intended for wireless mesh networks. HWMP (Hybrid Wireless Mesh Protocol) is its extension that can be frequently utilised within IEEE 802.11s mesh networks. The Border HWMP protocol concentrates on routing within mesh networks by means of combining both proactive and reactive routing approaches. It normally functions within scenarios in which nodes interact through a wireless backbone in the mesh network, and the protocol is created for managing traffic over several hops and adjusting to changes within the network topology.

In OMNeT++, replicate the Border HWMP or HWMP-like protocols, in a wireless mesh network simulation environment we want to execute or prolong routing protocol. Following is a stepwise approach to get started a Border HWMP simulation project in OMNeT++.

Steps to Start Border HWMP Protocol Projects in OMNeT++

Install OMNeT++ and INET Framework

OMNeT++: It is the key simulation environment to download and install it on the system.
INET Framework: For networking protocols and devices, it is a collection of predefined models. It supports models for wireless interaction, IP routing, and other network protocols. We can utilise its GitHub repository to download and install the INET Framework.

Understand HWMP and Border HWMP

HWMP is a hybrid routing protocol, which utilises both reactive and proactive methods, in wireless mesh networks determining the best routes.
- Proactive routing: Routes are continuously sustained, making sure that fast response times.
- Reactive routing: Routes are only launched as required (on-demand).
Border HWMP prolongs HWMP that specifically within multi-hop wireless mesh networks, to permit for more effective routing on the borders or among various mesh networks or subnets.

Set Up a New OMNeT++ Project

Make a new project for the Border HWMP simulation in OMNeT++:
- Go to OMNeT++ IDE and select the File → New → OMNeT++ Project.
- Name it to the project like BorderHWMPProject.

Create the Wireless Mesh Network Topology (NED Files)

We can describe the network topology in OMNeT++ to utilise NED files (Network Description files).
A basic mesh network may have numerous wireless nodes (routers) including interaction links among them.

Example MeshNetwork.ned:

network MeshNetwork

{

submodules:

router1: Router;

router2: Router;

router3: Router;

host1: Host;

host2: Host;

connections:

host1.wlan[0] <–> WifiPhy <–> router1.wlan[0];

router1.wlan[1] <–> WifiPhy <–> router2.wlan[0];

router2.wlan[1] <–> WifiPhy <–> router3.wlan[0];

host2.wlan[0] <–> WifiPhy <–> router3.wlan[1];

}

Now, router1, router2, and router3 are denotes wireless routers, and host1 and host2 signify end devices.
Denote the wireless interaction among the nodes with the help of WifiPhy module.

Define the Router Modules (HWMP/Border HWMP)

We require designing a router, which assists the hybrid routing protocol for Border HWMP, and in the mesh network, manages both proactive and reactive routing.
We can make a custom Router module, which executes the Border HWMP functionality.

Example Router.ned:

simple Router

{

parameters:

string protocolType = default(“HWMP”);

gates:

input in;

output out;

submodules:

routingProtocol: BorderHWMP;

ipModule: IP;

wlanModule: WirelessLan;

}

routingProtocol: It is a custom module, which we will make executing the Border HWMP routing logic.

Implement Border HWMP Logic in C++

We need to execute the Border HWMP protocol by making or prolonging a new module, for the mesh network which mange the routing logic. It has both proactive and reactive behaviors.

Example C++ code for BorderHWMP:

BorderHWMP.cc:

class BorderHWMP : public cSimpleModule

{

private:

void handleMessage(cMessage *msg) override;

void handleRouteRequest(cMessage *msg);

void handleRouteReply(cMessage *msg);

void proactiveRoutingUpdate();

public:

BorderHWMP();

~BorderHWMP();

};

Define_Module(BorderHWMP);

void BorderHWMP::handleMessage(cMessage *msg)

{

if (msg->isSelfMessage()) {

// Perform periodic proactive routing updates

proactiveRoutingUpdate();

} else {

// Process incoming routing messages (e.g., Route Request, Route Reply)

if (msg->getKind() == ROUTE_REQUEST) {

handleRouteRequest(msg);

} else if (msg->getKind() == ROUTE_REPLY) {

handleRouteReply(msg);

}

delete msg;

}

void BorderHWMP::handleRouteRequest(cMessage *msg)

{

// Process Route Request (RREQ) message

// This could involve finding the best path for the destination

}

void BorderHWMP::handleRouteReply(cMessage *msg)

{

// Process Route Reply (RREP) message

// This could involve setting up the routing table with the new route

}

void BorderHWMP::proactiveRoutingUpdate()

{

// Handle proactive routing updates here (e.g., periodically advertise routes)

}

BorderHWMP::BorderHWMP() {}

BorderHWMP::~BorderHWMP() {}

In this example, handleMessage handles incoming messages like Route Request (RREQ) and Route Reply (RREP).
Proactive updates: These updates can be updated routes periodically to neighbours that are same to how OLSR (Optimized Link State Routing) functions.
Reactive requests: Once a node requires a route to a destination then it transmits Route Request message. It transmits a Route Reply message depends on determining a route.

Define Routing Message Types

We can be described the message types like Route Request and Route Reply, which are transmitted among the nodes. We may utilise OMNeT++ message definitions, describing these message types within project.

Example RoutingMessage.msg:

message RouteRequest

{

int destinationAddress;

string originAddress;

}

message RouteReply

{

int destinationAddress;

string routePath;

}

Configure Simulation Parameters (INI File)

Utilise omnetpp.ini file to set simulation metrics such as simulation duration, the routing protocol type, network sets up, and more.

Example omnetpp.ini:

network = MeshNetwork

sim-time-limit = 100s

**.router1.routingProtocol.protocolType = “BorderHWMP”

**.router2.routingProtocol.protocolType = “BorderHWMP”

**.router3.routingProtocol.protocolType = “BorderHWMP”

You can set protocolType to “BorderHWMP” for all the routers in the network.

Build and Compile the Project

When we configure the NED files, C++ code, and set up then execute the projects to utilise OMNeT++ IDE or via the command line including the make command.

Run the Simulation

Execute the simulation, after the project is compiled. We can be utilised Cmdenv or Tkenv envisioning the outcomes through below command line.

Command to run:

./run -u Cmdenv

Analyze the Simulation Results

OMNeT++ offers numerous ways for envisioning the outcomes like:
- Result files: Explore routing table updates, packet loss, and routing convergence time.
- Animation: To utilise Tkenv or other OMNeT++ visualization tools, envision the performance of network and packet flow.

Additional Tips:

Mesh Network Performance: For Border HWMP, we need to observe the performance parameters like throughput, delay, packet delivery ratio, and routing overhead.
Error Handling: In the mesh network, execute the mechanisms to manage broken links or failed routes.
Scalability: Experiment how the Border HWMP executes like the network size grows, and to deliberate integrating the aspects such as mesh network security or mobility.

We have conducted the simulations for Border HWMP Protocol projects using a methodical step-by-step approach that were replicated and examined its behaviour under diverse wireless Network scenarios using OMNeT++. More innovative insights and concepts will be provided in the future.

If you require professional support for HWMP Protocol Projects using OMNeT++, we are here to help you manage your projects with expertise. At phdprojects.org, our dedicated team focuses on delivering thorough research, well-organized content, and effective writing. For personalized assistance, please do not hesitate to contact us at phdprojects.org. We possess significant experience with HWMP and related protocols.