OMNeT Labs

Computer Networks Lab · OMNeT++ · The LNMIIT

OMNeT++ Lab Series — Complete Notes

Standardized code, variables & naming across all labs

Lab 1 · Two-Node Network Lab 2 · Layered Architecture Lab 3 · Packet Loss & Retransmission Lab 4 · Packet Forwarding (LUT)

📌 Standard Nomenclature Used Across All Labs

NED Modules

Node · Nl_node · Dll_node
Comp · TwoNode · Comp_network
ForwardingNetwork

Gates

gIn / gOut (Lab 1, 4)
nl_in / nl_out (NL layer)
dlln_in/out · dllc_in/out

Packets / PDUs

N_PDU (Lab 1, 4)
Nl_pkt · Dll_pkt (Lab 2, 3)
Fields: pID · pType · src · dest

C++ Variables

address · id · counter
remaining_packets · source
copy_message · timeoutEvent · LUT

Functions

initialize() · handleMessage()
scheduleAt() · send() · par()
encapsulate() · decapsulate()

ini Parameters

**.source · **.dest
**.remaining_packets
sim-time-limit · network

Jump to: Lab 1 Lab 2 Lab 3 Lab 4

Lab 1

Two Node Network Simulation

Stop-and-wait data exchange · 10 packets · ACK-based

Objective

Simulate a stop-and-wait exchange between two nodes. Node 1 sends DATA packets; Node 2 replies with ACK. Repeats 10 times then stops.

Tasks

1Create Node module with gIn / gOut gates and id parameter

2Create TwoNode network with N1 and N2 bidirectionally connected

3Define N_PDU packet with fields: pID, pType, src, dest

4Node 1 sends DATA → Node 2 replies ACK → repeat 10 times → endSimulation()

Source Code

NEDNode.ned

simple Node
{
    parameters:
        int id;            // 1 = Node1,  2 = Node2
    gates:
        input  gIn;        // incoming messages
        output gOut;       // outgoing messages
}

NEDTwoNode.ned

network TwoNode
{
    submodules:
        N1: Node { id = 1; }
        N2: Node { id = 2; @display("p=120,110"); }
    connections:
        N1.gIn  <-- N2.gOut;
        N1.gOut --> N2.gIn;
}

MSGN_PDU.msg

packet N_PDU
{
    int    pID;      // packet number: 0 .. 9
    string pType;   // "data" or "ack"
    int    src;      // sender id (1 or 2)
    int    dest;     // receiver id (1 or 2)
}

C++Node.h

#ifndef NODE_H_
#define NODE_H_

#include <omnetpp.h>
#include "N_PDU_m.h"
using namespace omnetpp;

class Node : public cSimpleModule
{
  protected:
    int    address;   // this node's id: 1 or 2
    cGate* out;       // pointer to gOut gate
    int    counter;   // completed exchanges
    int    id_num;    // next packet id

    virtual void initialize();
    virtual void handleMessage(cMessage *msg);
};
#endif

C++Node.cc

#include "Node.h"
Define_Module(Node);

void Node::initialize()
{
    address = par("id");
    out     = gate("gOut");
    counter = 0;
    id_num  = 0;
    if (address == 1) {
        cMessage* event = new cMessage();
        scheduleAt(0, event);
    }
}

void Node::handleMessage(cMessage *msg)
{
    if (msg->isSelfMessage()) {
        delete msg;
        N_PDU* p = new N_PDU();
        p->setPID(id_num++);
        p->setPType("data");
        p->setSrc(1);  p->setDest(2);
        EV << "Node1: Sending DATA id=" << p->getPID() << "\n";
        send(p, out);
    } else {
        N_PDU* pkt = check_and_cast<N_PDU*>(msg);
        if (address == 2) {           // Node2: got DATA → send ACK
            EV << "Node2: Got DATA id=" << pkt->getPID() << "\n";
            delete pkt;
            N_PDU* ack = new N_PDU();
            ack->setPID(id_num++);
            ack->setPType("ack");
            ack->setSrc(2);  ack->setDest(1);
            send(ack, out);
        } else {                       // Node1: got ACK
            EV << "Node1: Got ACK id=" << pkt->getPID() << "\n";
            delete pkt;
            if (++counter >= 10) { endSimulation(); return; }
            N_PDU* p = new N_PDU();
            p->setPID(id_num++);
            p->setPType("data");
            p->setSrc(1);  p->setDest(2);
            send(p, out);
        }
    }
}

Lab 2

Layered Architecture — NL + DLL Communication

Network Layer · Data Link Layer · PDU Encapsulation · 100ms channel

Objective

Two-node network where each node has a Network Layer (Nl_node) and Data Link Layer (Dll_node). NL creates Nl_pkt → DLL encapsulates it into Dll_pkt → sends over channel → destination DLL decapsulates → passes to NL.

Source Code

NEDNl_node.ned · Dll_node.ned · Comp.ned · Comp_network.ned

// ── Nl_node.ned ──
simple Nl_node
{
    parameters:
        int id;                   // node id (1 or 2)
        int remaining_packets;    // from omnetpp.ini
        int source;               // which node starts sending
    gates:
        input  nl_in;
        output nl_out;
}

// ── Dll_node.ned ──
simple Dll_node
{
    parameters:
        int id;
    gates:
        input  dlln_in;   // from NL
        output dlln_out;  // to NL
        input  dllc_in;   // from channel
        output dllc_out;  // to channel
}

// ── Comp.ned — compound node ──
module Comp
{
    parameters:
        int c_id;
    gates:
        input  c_in;
        output c_out;
    submodules:
        Nl:  Nl_node  { id = c_id; }
        Dll: Dll_node { id = c_id; }
    connections:
        Nl.nl_in    <-- Dll.dlln_out;
        Nl.nl_out   --> Dll.dlln_in;
        Dll.dllc_in <-- c_in;
        Dll.dllc_out --> c_out;
}

// ── Comp_network.ned ──
network Comp_network
{
    submodules:
        C1: Comp { c_id = 1; }
        C2: Comp { c_id = 2; }
    connections:
        C1.c_out --> { delay = 100ms; } --> C2.c_in;
        C2.c_out --> { delay = 100ms; } --> C1.c_in;
}

MSGNl_pkt.msg · Dll_pkt.msg

packet Nl_pkt
{
    int pID;    // packet number
    int pType;  // 1 = data
}

packet Dll_pkt
{
    int pID;    // frame number
    int pType;  // 1 = data frame,  0 = ACK frame
}

C++Nl_node.h

#ifndef NL_NODE_H_
#define NL_NODE_H_
#include <omnetpp.h>
#include "Nl_pkt_m.h"
using namespace omnetpp;

class Nl_node : public cSimpleModule
{
  protected:
    int    id;
    int    remaining_packets;
    int    source;
    cGate* out;
    virtual void initialize();
    virtual void handleMessage(cMessage *msg);
};
#endif

C++Nl_node.cc

#include "Nl_node.h"
Define_Module(Nl_node);

void Nl_node::initialize()
{
    id                = par("id");
    remaining_packets = par("remaining_packets");
    source            = par("source");
    out               = gate("nl_out");
    if (id == source && remaining_packets > 0) {
        scheduleAt(0, new cMessage("start"));
    }
}

void Nl_node::handleMessage(cMessage *msg)
{
    if (msg->isSelfMessage()) {
        delete msg;
        if (remaining_packets <= 0) return;
        Nl_pkt* pkt = new Nl_pkt();
        pkt->setPID(remaining_packets);
        pkt->setPType(1);
        --remaining_packets;
        send(pkt, out);
        if (remaining_packets > 0)
            scheduleAt(simTime() + 0.2, new cMessage("next"));
    } else {
        EV << "[NL id=" << id << "] Received pkt from remote.\n";
        delete msg;
    }
}

C++Dll_node.h

#ifndef DLL_NODE_H_
#define DLL_NODE_H_
#include <omnetpp.h>
#include "Dll_pkt_m.h"
#include "Nl_pkt_m.h"
using namespace omnetpp;

class Dll_node : public cSimpleModule
{
  protected:
    int    id;
    cGate* in_n;   // from NL
    cGate* out_n;  // to NL
    cGate* in_c;   // from channel
    cGate* out_c;  // to channel
    virtual void initialize();
    virtual void handleMessage(cMessage *msg);
};
#endif

C++Dll_node.cc

#include "Dll_node.h"
Define_Module(Dll_node);

void Dll_node::initialize()
{
    id    = par("id");
    in_n  = gate("dlln_in");
    out_n = gate("dlln_out");
    in_c  = gate("dllc_in");
    out_c = gate("dllc_out");
}

void Dll_node::handleMessage(cMessage *msg)
{
    if (msg->getArrivalGate() == in_n) {
        Nl_pkt* nlp = check_and_cast<Nl_pkt*>(msg);
        Dll_pkt* frame = new Dll_pkt();
        frame->setPID(nlp->getPID());
        frame->setPType(1);
        frame->encapsulate(nlp);
        send(frame, out_c);
    } else if (msg->getArrivalGate() == in_c) {
        Dll_pkt* frame = check_and_cast<Dll_pkt*>(msg);
        if (frame->getPType() == 1) {
            cPacket* inner = frame->decapsulate();
            send(inner, out_n);
            Dll_pkt* ack = new Dll_pkt();
            ack->setPType(0);
            send(ack, out_c);
            delete frame;
        } else { delete msg; }
    }
}

INIomnetpp.ini

[General]
network              = Comp_network
**.remaining_packets = 10
**.source            = 1

Lab 3

Packet Loss · ACK · Timeout & Retransmission

10% loss · copy_message for retransmit · cancelEvent on ACK

What's New vs Lab 2

aDLL destination simulates 10% packet loss using uniform(0,1) < 0.1

bSource DLL saves copy_message and starts a timeoutEvent

cOn ACK → cancelEvent(timeoutEvent) · On timeout → retransmit copy_message.dup()

✓ 10% loss (was 80%) ✓ decapsulate() leak fixed ✓ copy_message = nullptr ✓ old copy deleted before new save ✓ self-event memory leak

Changed Files (NED / MSG / Nl_node same as Lab 2)

C++Dll_node.h — updated with copy_message & timeoutEvent

#ifndef DLL_NODE_H_
#define DLL_NODE_H_
#include <omnetpp.h>
#include "Dll_pkt_m.h"
#include "Nl_pkt_m.h"
using namespace omnetpp;

class Dll_node : public cSimpleModule
{
  protected:
    int    id;
    cGate* in_n;
    cGate* out_n;
    cGate* in_c;
    cGate* out_c;
    Dll_pkt*  copy_message;   // saved for retransmission
    cMessage* timeoutEvent;   // retransmit timer
    virtual void initialize();
    virtual void handleMessage(cMessage *msg);
};
#endif

C++Dll_node.cc — full retransmission logic

#include "Dll_node.h"
Define_Module(Dll_node);

void Dll_node::initialize()
{
    id    = par("id");
    in_n  = gate("dlln_in");
    out_n = gate("dlln_out");
    in_c  = gate("dllc_in");
    out_c = gate("dllc_out");
    copy_message = nullptr;
    timeoutEvent = new cMessage("timeout");
}

void Dll_node::handleMessage(cMessage *msg)
{
    // ── Timeout: retransmit ──
    if (msg == timeoutEvent) {
        if (copy_message != nullptr) {
            send(copy_message->dup(), out_c);
            scheduleAt(simTime() + 0.2, timeoutEvent);
        }
        return;
    }

    // ── New packet from NL ──
    if (msg->getArrivalGate() == in_n) {
        Nl_pkt* nlp = check_and_cast<Nl_pkt*>(msg);
        Dll_pkt* frame = new Dll_pkt();
        frame->setPID(nlp->getPID());
        frame->setPType(1);
        frame->encapsulate(nlp);
        send(frame->dup(), out_c);
        if (copy_message != nullptr) delete copy_message;
        copy_message = frame;
        cancelEvent(timeoutEvent);
        scheduleAt(simTime() + 0.2, timeoutEvent);
        return;
    }

    // ── Message from channel ──
    if (msg->getArrivalGate() == in_c) {
        Dll_pkt* frame = check_and_cast<Dll_pkt*>(msg);
        if (frame->getPType() == 1) {         // DATA frame
            if (uniform(0,1) < 0.1) {            // 10% loss
                delete frame; return;
            }
            Dll_pkt* ack = new Dll_pkt();
            ack->setPID(frame->getPID());
            ack->setPType(0);
            send(ack, out_c);
            cPacket* inner = frame->decapsulate();
            delete frame;
            send(inner, out_n);
        } else if (frame->getPType() == 0) {  // ACK
            cancelEvent(timeoutEvent);
            delete frame;
        } else { delete frame; }
    }
}

INIomnetpp.ini

[General]
network              = Comp_network
sim-time-limit       = 5000s
record-eventlog      = true
**.remaining_packets = 10
**.source            = 1
**.dest              = 2

Lab 4

Packet Forwarding with Forwarding Tables (LUT)

5-node directed network · std::map LUT · gate arrays · end-to-end delay

Topology & Objective

5-node directed network. Each node has a Forwarding Table (LUT) implemented as map<int,int> — maps destination address to output gate index. Source node sends one packet, it hops through the network, destination prints end-to-end delay.

Faster path: 0→1→2→4 (400ms) | Alternate: 0→1→3→4 (500ms)

Source Code

NEDNode.ned

simple Node
{
    parameters:
        int address;        // set to index in network
        int source;         // from omnetpp.ini
        int dest;           // from omnetpp.ini
    gates:
        input  gIn[];      // auto-sized gate array
        output gOut[];
}

NEDForwardingNetwork.ned

network ForwardingNetwork
{
    parameters:
        int source;
        int dest;

    submodules:
        N[5]: Node {
            address = index;
            source  = source;
            dest    = dest;
        }

    connections allowunconnected:
        N[0].gOut[0] --> { delay = 100ms; } --> N[1].gIn[0];
        N[1].gOut[0] --> { delay = 200ms; } --> N[2].gIn[0];
        N[1].gOut[1] --> { delay = 200ms; } --> N[3].gIn[0];
        N[2].gOut[0] --> { delay = 100ms; } --> N[4].gIn[0];
        N[3].gOut[0] --> { delay = 200ms; } --> N[4].gIn[1];
}

MSGN_PDU.msg

packet N_PDU
{
    int       src;    // source node address
    int       dest;   // destination address
    simtime_t start;  // send time for delay calc
}

C++Node.h

#ifndef NODE_H_
#define NODE_H_
#include <omnetpp.h>
#include <map>
#include "N_PDU_m.h"
using namespace omnetpp;
using namespace std;

class Node : public cSimpleModule
{
  protected:
    int           address;
    int           source;
    int           dest;
    map<int,int>  LUT;   // dest → gOut index
    virtual void initialize();
    virtual void handleMessage(cMessage *msg);
};
#endif

C++Node.cc

#include "Node.h"
Define_Module(Node);

void Node::initialize()
{
    address = par("address");
    source  = par("source");
    dest    = par("dest");

    // Build LUT: destination → output gate index
    if      (address == 0) LUT = { {4,0} };
    else if (address == 1) LUT = { {4,0} }; // gOut[0]→N2 (400ms path)
    else if (address == 2) LUT = { {4,0} };
    else if (address == 3) LUT = { {4,0} };
    // Node 4 = destination, no LUT needed

    if (address == source) {
        scheduleAt(0, new cMessage());
    }
}

void Node::handleMessage(cMessage *msg)
{
    if (msg->isSelfMessage()) {
        N_PDU* pkt = new N_PDU();
        pkt->setSrc(address);
        pkt->setDest(dest);
        pkt->setStart(simTime());
        delete msg;
        send(pkt, "gOut", LUT.at(dest));
    } else {
        N_PDU* pkt = check_and_cast<N_PDU*>(msg);
        if (address == dest) {
            EV << "Delay: " << simTime() - pkt->getStart() << "\n";
            delete pkt;
        } else {
            send(pkt, "gOut", LUT.at(dest));
        }
    }
}

omnetpp.ini (Lab 4)

omnetpp.ini

[General]
network = ForwardingNetwork
**.source = 0
**.dest   = 4