To simulate Low-Energy Adaptive Clustering Hierarchy (LEACH) is a widely-used hierarchical routing protocol for wireless sensor networks (WSNs). It is a model to enhance the energy usage by establishing nodes into clusters, in which a cluster head gather data from other nodes and send it to a base station. Cluster heads are rotated occasionally to share the energy load between all the nodes.
To simulate LEACH Routing in OMNeT++ needs to using or implementing a LEACH protocol, that is not natively available in the INET framework. However, you can either:
- Execute the LEACH protocol from scratch using OMNeT++ modules.
- Utilize a third-party WSN framework such as Castalia that supports LEACH and other sensor network protocols.
Below is a step-by-step guide to simulate LEACH Routing using OMNeT++ and a third-party framework (e.g., Castalia).
Steps to Simulate LEACH Routing Projects in OMNeT++
Option 1: Simulating LEACH using Castalia
Castalia is a widespread simulation framework for WSNs and IoT systems according to OMNeT++. It has built-in support for energy-efficient protocols such as LEACH.
- Install OMNeT++ and Castalia
- Download OMNeT++:
- Download and install OMNeT++.
- Download Castalia:
- Download the Castalia framework from Castalia GitHub Repository.
- Unzip or clone the repository:
git clone https://github.com/boulis/Castalia.git
-
- Import Castalia into OMNeT++ through File > Import > Existing Projects into Workspace.
- Build Castalia by right-clicking the project and choose Build Project.
- Set Up LEACH in Castalia
Castalia embraces a basic implementation of LEACH for wireless sensor networks. we can set up the simulation using .ned and .ini files.
Example Network Configuration in NED (LeachNetwork.ned):
package leachrouting;
import castalia.node.sensor.SensorNode;
import castalia.simulation.BaseStation;
import castalia.mobility.static.StaticMobility;
network LeachNetwork
{
parameters:
int numNodes = default(10);
submodules:
sink: BaseStation {
@display(“p=100,100”);
}
node[numNodes]: SensorNode {
@display(“p=uniform(0,200),100+50*i”);
mobility.typename = “StaticMobility”;
}
}
Explanation:
- SensorNode: Denoted the sensor nodes that will utilize LEACH for routing and data aggregation.
- BaseStation: The central sink or base station that collects data from cluster heads.
- StaticMobility: The sensor nodes are placed statically in this case.
- Configure the LEACH Protocol in omnetpp.ini
We need to certain the LEACH routing and energy metrics in the omnetpp.ini file.
Example omnetpp.ini Configuration:
network = LeachNetwork
sim-time-limit = 1000s
# Sensor Node Configuration
*.node[*].Communication.RoutingProtocolName = “LEACH” # Use LEACH routing protocol
*.node[*].ApplicationName = “SimpleApplication” # Example application
*.node[*].Application.packetSize = 100B # Data packet size
# LEACH-specific parameters
*.node[*].LEACH.clusterHeadProbability = 0.05 # Probability of becoming a cluster head
*.node[*].LEACH.roundLength = 20s # Duration of a LEACH round
*.node[*].LEACH.maxRounds = 50 # Maximum number of LEACH rounds
*.node[*].LEACH.energyModel.initialEnergy = 2J # Initial energy of sensor nodes
*.node[*].LEACH.energyModel.txEnergy = 50e-9 # Energy consumption for transmission
*.node[*].LEACH.energyModel.rxEnergy = 50e-9 # Energy consumption for reception
# Mobility (if using dynamic node movement)
*.node[*].MobilityManager.enable = true
*.node[*].MobilityManager.updateInterval = 0.1s
*.node[*].MobilityManager.speed = uniform(0.5, 2.0)
# Traffic and application settings
*.node[*].Application.sensingInterval = 1s # Data generation interval
Explanation:
- LEACH Configuration: Requires the parameters for LEACH, like the probability of a node becoming a cluster head, the length of each LEACH round, and the energy model.
- Energy Model: Describes energy consumption rates for transmission and reception, along with the initial energy of each node.
- Traffic Configuration: Describes how frequently each sensor node creates data to transmit to the cluster head.
- Run the Simulation
- Build the Project:
- Right-click on the project and choose Build Project to compile the files.
- Run the Simulation:
- Right-click on omnetpp.ini and choose Run As > OMNeT++ Simulation.
- Utilize the Qtenv graphical interface to monitor the behaviour of the LEACH routing protocol in action that contain cluster formation and data aggregation.
- Analyse the Results
After executing the simulation, we can measure metrics such as:
- Energy Consumption: Assess on how energy is consumed via the network and how LEACH enhance energy efficiency by rotating cluster heads.
- Network Lifetime: Regulate how long the network remains functional before the nodes processed out of energy.
- Throughput: Measure how much data is routed to the base station and how LEACH enhances data aggregation.
Option 2: Implementing LEACH in OMNeT++ and INET
If you prefer not to utilize Castalia and would like to execute LEACH using the INET framework that will need to physically execute the clustering and routing logic.
- Create Custom LEACH Modules
- Create a Cluster Head Module: This module will manage data aggregation and routing from member nodes to the base station.
- Create a Sensor Node Module: This module will demonstrate the normal sensor nodes that will transfer data to the cluster head.
- Cluster Formation Logic: Apply the logic for choosing cluster heads according to node energy levels and the clusterHeadProbability parameter. Cluster heads should occasionally broadcast their status to nearby nodes.
- Data Aggregation: Cluster heads should gather data from member nodes and forward it to the base station.
- Define the Network in NED
We can describe a network similar to the one in Option 1, however this time, utilize custom modules for the sensor nodes and cluster heads.
- Implement LEACH Protocol in C++
To execute the LEACH logic, that will need to generate C++ classes for the sensor nodes and cluster heads. This will includes composing functions for:
- Cluster Head Selection: Probabilistically choosing cluster heads at the initiate of each round.
- Data Aggregation: Gather data at the cluster heads and forwarding it to the base station.
- Energy Management: handling energy levels for each node and updating energy consumption for each communication event.
We can prolong OMNeT++’s RoutingProtocolBase or similar classes to manage the LEACH routing logic.
- Configure and Run the Simulation
Once we have executed the LEACH logic, set up the simulation using the NED and omnetpp.ini files, and follow the same steps as in Option 1 to execute the simulation.
We clearly accumulated the essential data to LEACH protocol project with example coding that simulated and evaluated using the tool of OMNeT++ analysis tool. Additional specific details regarding the LEACH protocol will be provided in further manual.
Check out our LEACH Routing Projects using OMNeT++! We offer top-notch simulations and innovative research ideas, plus we can customize projects just for you. You can count on us for on-time delivery and a clear explanation of everything.
