How to Implement PEGASIS Protocol in NS2

To implement Power-Efficient GAthering in Sensor Information Systems (PEGASIS) protocol in Network Simulator 2 (NS2) has needs to make a custom execution in a place of PEGASIS is not encompassed as a built-in protocol in NS2. The PEGASIS is a chain-based protocol intended for Wireless Sensor Networks (WSNs) to enhance energy efficiency by minimizing the number of transmissions and the distance over where the data is routed. The below is the procedure to implement the PEGASIS protocol in ns2:

Step-by-Step Guide to Implement PEGASIS in NS2

Step 1: Understand PEGASIS Protocol

PEGASIS is a development over the LEACH protocol, where:

  1. Nodes are organized into a chain: Each node interacts only with a close neighbour.
  2. Data is aggregated: The data is distributed along the chain, aggregated at each node, and then sent to the base station.
  3. The leader node: The node closest to the base station is often selected as the leader to transfer the aggregated data to the base station.

Step 2: Modify NS2 Source Code

Meanwhile PEGASIS is not a default protocol in NS2; we must adjust the NS2 source code. We need to execute the PEGASIS logic, commonly in C++.

  1. Add a new protocol class: We will generate a new protocol class in NS2.
    • Go to the ns-2.xx/ directory.
    • Add a new C++ file for PEGASIS, for instance, pegasis.cc, in the ns-2.xx/ directory.
    • Add a header file pegasis.h.

The PEGASIS class should come into from the Agent class or any other proper superclass.

  1. Define PEGASIS behaviours: Execute the core logic of PEGASIS in the pegasis.cc file.
    • Chain formation: Apply the logic for organizing nodes into a chain.
    • Data aggregation: Execute data aggregation as data is passed along the chain.
    • Leader selection: Execute leader selection according to proximity to the base station or other condition.

The given below is a basic structure for pegasis.h and pegasis.cc files:

pegasis.h

#include “agent.h”

class PEGASIS : public Agent {

public:

PEGASIS();

int command(int argc, const char*const* argv);

void recv(Packet* p, Handler*);

void chainFormation();  // Chain formation logic

void dataAggregation(); // Data aggregation logic

void leaderSelection(); // Leader selection logic

protected:

int nodeId;

int baseStationId;

// Other necessary member variables

};

pegasis.cc

#include “pegasis.h”

PEGASIS::PEGASIS() : Agent(PT_UDP) {

// Initialization

}

int PEGASIS::command(int argc, const char*const* argv) {

// Command handling

}

void PEGASIS::recv(Packet* p, Handler* h) {

// Packet receiving logic

}

void PEGASIS::chainFormation() {

// Chain formation logic

}

void PEGASIS::dataAggregation() {

// Data aggregation logic

}

void PEGASIS::leaderSelection() {

// Leader selection logic

}

  1. Modify the Makefile: Update the NS2 Makefile to contain the new protocol files.
    • Edit the Makefile.in or Makefile to contain the pegasis.o in the compilation process.

OBJ_CC = pegasis.o $(OBJ_CC)

  1. Rebuild NS2: After adding protocol code and updating the Makefile, we need to rebuild NS2.

cd ns-2.xx/

make clean

make

Step 3: Create a Tcl Simulation Script

Then we had to execute and compiled the PEGASIS protocol, We can generate a Tcl script to mimic a scenario using PEGASIS.

Example Tcl script:

# Create a simulator object

set ns [new Simulator]

# Define options for the simulation

set val(chan)   Channel/WirelessChannel    ;# Channel type

set val(prop)   Propagation/TwoRayGround   ;# Propagation model

set val(netif)  Phy/WirelessPhy            ;# Network interface type

set val(mac)    Mac/802_11                 ;# MAC type

set val(ifq)    Queue/DropTail/PriQueue    ;# Interface Queue type

set val(ll)     LL                         ;# Link layer type

set val(ant)    Antenna/OmniAntenna        ;# Antenna type

set val(ifqlen) 50                         ;# Max packet in ifq

set val(nn)     10                         ;# Number of nodes

set val(rp)     PEGASIS                    ;# Routing Protocol (Your new protocol)

set val(x)      500                        ;# X dimension of topography

set val(y)      500                        ;# Y dimension of topography

set val(stop)   10.0                       ;# Simulation time

# Initialize the topology object

set topo [new Topography]

$topo load_flatgrid $val(x) $val(y)

# Create the God object

create-god $val(nn)

# Configure the nodes

$ns node-config -adhocRouting $val(rp) \

-llType $val(ll) \

-macType $val(mac) \

-ifqType $val(ifq) \

-ifqLen $val(ifqlen) \

-antType $val(ant) \

-propType $val(prop) \

-phyType $val(netif) \

-channelType $val(chan) \

-topoInstance $topo \

-agentTrace ON \

-routerTrace ON \

-macTrace ON \

-movementTrace ON

# Create nodes

for {set i 0} {$i < $val(nn)} {incr i} {

set node_($i) [$ns node]

}

# Define node positions, traffic patterns, etc.

# Run the simulation

$ns run

Step 4: Run the Simulation

  1. Save the Tcl script (pegasis_example.tcl).
  2. Open a terminal and navigate to the directory that can save the Tcl script.
  3. Execute the simulation using the following command:

ns pegasis_example.tcl

This command will create trace files and optionally a network animation file (if enabled in script).

Step 5: Analyse the Results

Use trace files and network animator (NAM) to evaluate the performance of the PEGASIS protocol, that concentrates on energy efficiency, network lifetime, and other pertinent metrics.

Step 6: Visualize the Results (Optional)

If we have allowed the network animator (NAM) in script, we can visualize the simulation:

nam pegasis_example.nam

This will launch the NAM window, in which we can see the network topology and the behaviour of PEGASIS during the simulation.

Additional Considerations

  • Energy Model: Make sure that the energy model in NS2 is properly configured, as PEGASIS is concentrated on energy efficiency.
  • Chain Formation: Test with diverse algorithms for chain formation and leader selection.
  • Performance Metrics: Assess the protocol’s performance in terms of energy usage, network lifetime, and data delivery.

We understood the basic to advanced implementation process on how the Power-Efficient GAthering in Sensor Information Systems will enhance the energy efficiency in the transmitted data over the network using the ns2 tool. We also deliver how the PEGASIS will perform in other simulation tools.

We are here to help you discover the most innovative research ideas in this field. If you’re looking for the best implementation results for the PEGASIS Protocol in NS2, feel free to reach out to us. We ensure timely delivery to meet your needs.