How to Develop Real Time Protocol Projects Using NS3

To develop the Real-Time Protocol (RTP) used for NS3. The Real-Time Protocol (RTP) is used for communicate the real-time audio and video over IP networks. NS3 does not distribute the built-in RTP component; nevertheless we can replicate the RTP traffic using:

• UDP-based on transmission (RTP works over UDP)
• Packet-level replication of RTP frames
• Jitter, packet loss, and delay modeling

Steps to Develop Real Time Protocol Projects Using NS3

1. Setting up NS3 for RTP Simulation

Make sure NS3 is installed. If not, install it:

git clone

cd ns-3-dev

./build.py –enable-examples

2. Designing an RTP Simulation

Basic RTP Workflow

1. RTP Sender (Source Node)
   • Create a RTP packets and forwarding them over UDP
   • We replicate the voice/video data transmission
2. RTP Receiver (Sink Node)
   • Receive the RTP packets over UDP
   • Calculate the RTP receiver in performance of metrices such as delay, jitter, and packet loss

3. Implementing RTP in NS3

C++ Code for Simulating RTP Traffic

This code designs an RTP-like UDP streaming session among their sender and receiver.

rtp-simulation.cc

#include “ns3/core-module.h”

#include “ns3/network-module.h”

#include “ns3/internet-module.h”

#include “ns3/applications-module.h”

#include “ns3/point-to-point-module.h”

using namespace ns3;

NS_LOG_COMPONENT_DEFINE (“RTP_Simulation”);

// RTP Sender (Simulating an RTP Source)

class RtpSender : public Application {

private:

Ptr<Socket> m_socket;

Address m_peerAddress;

EventId m_sendEvent;

uint32_t m_packetSize;

uint32_t m_packetInterval;

uint32_t m_packetCount;

public:

RtpSender() : m_packetSize(160), m_packetInterval(20), m_packetCount(0) {}

void Setup(Address peerAddress) {

m_peerAddress = peerAddress;

}

void StartApplication() {

m_socket = Socket::CreateSocket(GetNode(), UdpSocketFactory::GetTypeId());

m_socket->Connect(m_peerAddress);

SendPacket();

}

void SendPacket() {

if (m_packetCount < 100) {  // Simulate sending 100 RTP packets

std::string rtpPayload = “RTP Packet ” + std::to_string(m_packetCount);

Ptr<Packet> packet = Create<Packet>((uint8_t*)rtpPayload.c_str(), rtpPayload.length());

m_socket->Send(packet);

m_packetCount++;

m_sendEvent = Simulator::Schedule(MilliSeconds(m_packetInterval), &RtpSender::SendPacket, this);

}

}

};

// RTP Receiver (Simulating an RTP Sink)

class RtpReceiver : public Application {

private:

Ptr<Socket> m_socket;

uint32_t m_receivedPackets;

Time m_lastPacketTime;

double m_jitterSum;

public:

RtpReceiver() : m_receivedPackets(0), m_jitterSum(0.0) {}

void StartApplication() {

m_socket = Socket::CreateSocket(GetNode(), UdpSocketFactory::GetTypeId());

InetSocketAddress local = InetSocketAddress(Ipv4Address::GetAny(), 5000);

m_socket->Bind(local);

m_socket->SetRecvCallback(MakeCallback(&RtpReceiver::HandleRead, this));

}

void HandleRead(Ptr<Socket> socket) {

Ptr<Packet> packet = socket->Recv();

Time now = Simulator::Now();

if (m_receivedPackets > 0) {

Time diff = now – m_lastPacketTime;

double jitter = std::abs(diff.GetMilliSeconds() – 20.0); // Expected RTP interval = 20ms

m_jitterSum += jitter;

}

m_lastPacketTime = now;

m_receivedPackets++;

std::cout << “Received RTP packet ” << m_receivedPackets << ” at ” << now.GetSeconds() << “s\n”;

}

};

int main(int argc, char *argv[]) {

NodeContainer nodes;

nodes.Create(2);

PointToPointHelper p2p;

p2p.SetDeviceAttribute(“DataRate”, StringValue(“1Mbps”));

p2p.SetChannelAttribute(“Delay”, StringValue(“2ms”));

NetDeviceContainer devices = p2p.Install(nodes);

InternetStackHelper stack;

stack.Install(nodes);

Ipv4AddressHelper address;

address.SetBase(“192.168.1.0”, “255.255.255.0”);

Ipv4InterfaceContainer interfaces = address.Assign(devices);

Ptr<RtpReceiver> receiverApp = CreateObject<RtpReceiver>();

receiverApp->SetStartTime(Seconds(1.0));

receiverApp->SetStopTime(Seconds(10.0));

nodes.Get(1)->AddApplication(receiverApp);

Ptr<RtpSender> senderApp = CreateObject<RtpSender>();

senderApp->Setup(InetSocketAddress(interfaces.GetAddress(1), 5000));

senderApp->SetStartTime(Seconds(2.0));

senderApp->SetStopTime(Seconds(10.0));

nodes.Get(0)->AddApplication(senderApp);

Simulator::Run();

Simulator::Destroy();

return 0;

}

4. Running the Simulation

Steps to Compile and Run

1. Move the file to NS3’s scratch directory:

mv rtp-simulation.cc ns-3-dev/scratch/

1. Compile the code:

./waf –run scratch/rtp-simulation

1. Output Example

Received RTP packet 1 at 2.002s

Received RTP packet 2 at 2.022s

Received RTP packet 3 at 2.042s

…

1. • Demonstrate the packets received at estimated the RTP interval (20ms)
   • We can investigate the performance of parameter metrics such as delay and jitter

5. Enhancing the RTP Simulation

Add RTP Header Simulation

Alter the packet structure to contain the RTP header:

struct RtpHeader {

uint16_t sequenceNumber;

uint32_t timestamp;

uint32_t ssrc;

};

• Increase to the payload of packet monitoring and jitter calculations.

Simulate Packet Loss

We launch the arbitrary packet drops using NS3’s loss designs:

Ptr<RateErrorModel> errorModel = CreateObject<RateErrorModel>();

errorModel->SetAttribute(“ErrorRate”, DoubleValue(0.05));  // 5% packet loss

devices.Get(1)->SetAttribute(“ReceiveErrorModel”, PointerValue(errorModel));

Simulate RTP Over a Wireless Network

Exchange by PointToPointHelper:

WifiHelper wifi;

wifi.SetStandard(WIFI_STANDARD_80211n);

• We utilized the wireless settings to validate a RTP in Wi-Fi environments.

Monitor Network Metrics

• FlowMonitorHelper used to examine the performance of parameter metrices such as packet loss, jitter, and delay:

FlowMonitorHelper flowHelper;

Ptr<FlowMonitor> monitor = flowHelper.InstallAll();

Simulator::Stop(Seconds(10.0));

monitor->SerializeToXmlFile(“rtp-flow.xml”, true, true);

6. Summary

Feature	Implementation
RTP Transmission	Replicated by UDP
Packet Interval	20ms (Voice/Video RTP Standard)
Jitter Calculation	Associate the actual vs expected delay
Packet Loss Simulation	We used the NS3’s error design
Wireless RTP	Change the P2P by Wi-Fi
Performance Analysis	Use FlowMonitor

7. Future Work

• Increase the RTCP (Real-time Transport Control Protocol) for QoS monitoring
• Encompass to encourage the VoIP and Video Streaming
• Execute the Adaptive Bitrate Control

In this given module, we had explicitly focussed the novel information on how to simulate the Real-Time Protocol that were executed using ns3 tool that is used to exchange the information among the nodes in the real world scenarios. If you need more information regarding this process we will explain it based on your needs.