DEPARTMENT OF COMPUTER SCIENCE &

ENGINEERING

LAB MANUAL OF
WIRELESS COMMUNICATION LAB ETEC
463
 Index

Exp. no Experiment Name Date of Date of Remarks Marks

performan checking
ce
1 WIFI TO BUS(CSMA)
CONNECTION
2 WIFI SIMPLE
INFRASTUCTURE MODE

3 WIFI SIMPLE ADHOC MODE

4 WIFI TO WIRED BRIDGING

5 WIFI TO LTE(4G)
CONNECTION
6 CREATING A SIMPLE WIFI
ADHOC GRID
7 To Study Architecture of
GSM.
1. WIFI TO BUS(CSMA) CONNECTION
// Default Network Topology
//
// Number of wifi or csma nodes can be increased up to 250
// |
// Rank 0 | Rank 1
// -------------------------|---------------------------- //
Wifi 10.1.3.0
// AP //
* * * *
// | | | | 10.1.1.0
// n5 n6 n7 n0 -------------- n1 n2 n3 n4
// point-to-point | | | |
// ================
// LAN 10.1.2.0

#include "ns3/core-module.h"
#include "ns3/point-to-point-module.h"
#include "ns3/network-module.h"
#include "ns3/applications-module.h"
#include "ns3/wifi-module.h"
#include "ns3/mobility-module.h"
#include "ns3/csma-module.h"
#include "ns3/internet-module.h"

using namespace ns3;

NS_LOG_COMPONENT_DEFINE ("ThirdScriptExample");

int main (int argc, char

*argv[])
{
bool verbose = true;
uint32_t nCsma = 3;
uint32_t nWifi = 3;
bool tracing = false;

CommandLine cmd;
cmd.AddValue ("nCsma", "Number of \"extra\" CSMA nodes/devices", nCsma);
cmd.AddValue ("nWifi", "Number of wifi STA devices", nWifi); cmd.AddValue
("verbose", "Tell echo applications to log if true", verbose); cmd.AddValue
("tracing", "Enable pcap tracing", tracing);

cmd.Parse (argc,argv);

// Check for valid number of csma or wifi nodes

// 250 should be enough, otherwise IP addresses
// soon become an issue
if (nWifi > 250 || nCsma > 250)
{
std::cout << "Too many wifi or csma nodes, no more than 250 each." << std::endl;
return 1;
}

if (verbose)
{
LogComponentEnable ("UdpEchoClientApplication", LOG_LEVEL_INFO);
LogComponentEnable ("UdpEchoServerApplication", LOG_LEVEL_INFO);
}

NodeContainer p2pNodes;
p2pNodes.Create (2);

PointToPointHelper pointToPoint; pointToPoint.SetDeviceAttribute

("DataRate", StringValue ("5Mbps"));
pointToPoint.SetChannelAttribute ("Delay", StringValue ("2ms"));

NetDeviceContainer p2pDevices;
p2pDevices = pointToPoint.Install (p2pNodes);

NodeContainer csmaNodes;
csmaNodes.Add (p2pNodes.Get (1));
csmaNodes.Create (nCsma);

CsmaHelper csma; csma.SetChannelAttribute ("DataRate",

StringValue ("100Mbps")); csma.SetChannelAttribute ("Delay",
TimeValue (NanoSeconds (6560)));

NetDeviceContainer csmaDevices;
csmaDevices = csma.Install (csmaNodes);

NodeContainer wifiStaNodes;
wifiStaNodes.Create (nWifi);
 NodeContainer wifiApNode = p2pNodes.Get (0);

YansWifiChannelHelper channel = YansWifiChannelHelper::Default ();

YansWifiPhyHelper phy = YansWifiPhyHelper::Default ();
phy.SetChannel (channel.Create ());

WifiHelper wifi;
wifi.SetRemoteStationManager ("ns3::AarfWifiManager");

WifiMacHelper mac;
Ssid ssid = Ssid ("ns-3-ssid");
mac.SetType ("ns3::StaWifiMac",
"Ssid", SsidValue (ssid),
"ActiveProbing", BooleanValue (false));

NetDeviceContainer staDevices;
staDevices = wifi.Install (phy, mac, wifiStaNodes);

mac.SetType ("ns3::ApWifiMac",
"Ssid", SsidValue (ssid));

NetDeviceContainer apDevices;
apDevices = wifi.Install (phy, mac, wifiApNode);

MobilityHelper mobility;

mobility.SetPositionAllocator ("ns3::GridPositionAllocator",
"MinX", DoubleValue (0.0),
"MinY", DoubleValue (0.0),
"DeltaX", DoubleValue (5.0),
"DeltaY", DoubleValue (10.0),
"GridWidth", UintegerValue (3),
"LayoutType", StringValue ("RowFirst"));

mobility.SetMobilityModel ("ns3::RandomWalk2dMobilityModel",
"Bounds", RectangleValue (Rectangle (-50, 50, -50, 50)));
mobility.Install (wifiStaNodes);

mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
mobility.Install (wifiApNode);
 InternetStackHelper stack;
stack.Install (csmaNodes); stack.Install
(wifiApNode);
stack.Install (wifiStaNodes);

Ipv4AddressHelper address;

address.SetBase ("10.1.1.0", "255.255.255.0");

Ipv4InterfaceContainer p2pInterfaces;
p2pInterfaces = address.Assign (p2pDevices);

address.SetBase ("10.1.2.0", "255.255.255.0");

Ipv4InterfaceContainer csmaInterfaces;
csmaInterfaces = address.Assign (csmaDevices);

address.SetBase ("10.1.3.0", "255.255.255.0");

address.Assign (staDevices);
address.Assign (apDevices);

UdpEchoServerHelper echoServer (9);

ApplicationContainer serverApps = echoServer.Install (csmaNodes.Get (nCsma));

serverApps.Start (Seconds (1.0));
serverApps.Stop (Seconds (10.0));

UdpEchoClientHelper echoClient (csmaInterfaces.GetAddress (nCsma), 9);

echoClient.SetAttribute ("MaxPackets", UintegerValue (1)); echoClient.SetAttribute
("Interval", TimeValue (Seconds (1.0))); echoClient.SetAttribute ("PacketSize",
UintegerValue (1024));

ApplicationContainer clientApps =
echoClient.Install (wifiStaNodes.Get (nWifi - 1));
clientApps.Start (Seconds (2.0));
clientApps.Stop (Seconds (10.0));

Ipv4GlobalRoutingHelper::PopulateRoutingTables ();

Simulator::Stop (Seconds (10.0));

if (tracing == true)
{
pointToPoint.EnablePcapAll ("third");
phy.EnablePcap ("third", apDevices.Get (0));
csma.EnablePcap ("third", csmaDevices.Get (0), true);
 }

Simulator::Run ();
Simulator::Destroy ();
return 0; }

2) WIFI SIMPLE INFRASTUCTURE MODE

This script configures two nodes on an 802.11b physical layer, with 802.11b NICs in
infrastructure mode, and by default, the station sends one packet of 1000 (application) bytes to
the access point. The physical layer is configured to receive at a fixed RSS (regardless of the
distance and transmit power); therefore, changing position of the nodes has no effect.

There are a number of command-line options available to control the default behavior. The list
of available command-line options can be listed with the following command:
./waf --run "wifi-simple-infra --help" For instance, for this configuration, the physical layer
will stop successfully receiving packets when rss drops below -97 dBm. To see this effect, try
running:

./waf --run "wifi-simple-infra --rss=-97 --numPackets=20"

./waf --run "wifi-simple-infra --rss=-98 --numPackets=20"/ ./waf --run "wifi-simple-infra -rss=-
99 --numPackets=20"

Note that all ns-3 attributes (not just the ones exposed in the below script) can be changed at
command line; see the documentation.

This script can also be helpful to put the Wifi layer into verbose logging mode; this command
will turn on all wifi logging:
./waf --run "wifi-simple-infra --verbose=1"
When you are done, you will notice two pcap trace files in your directory. If you have tcpdump
installed, you can try this: tcpdump -r wifi-simple-infra-0-0.pcap -nn -tt

#include "ns3/core-module.h"
#include "ns3/network-module.h"
#include "ns3/mobility-module.h"
#include "ns3/config-store-module.h" #include
"ns3/wifi-module.h"
#include "ns3/internet-module.h"
#include <iostream>
#include <fstream>
#include <vector>
#include <string>

using namespace ns3;

NS_LOG_COMPONENT_DEFINE ("WifiSimpleInfra");

void ReceivePacket (Ptr<Socket> socket) {

while (socket->Recv ())
{
NS_LOG_UNCOND ("Received one packet!");
}
}

static void GenerateTraffic (Ptr<Socket> socket, uint32_t pktSize,

uint32_t pktCount, Time pktInterval )
{
if (pktCount > 0)
{
socket->Send (Create<Packet> (pktSize));
Simulator::Schedule (pktInterval, &GenerateTraffic,
socket, pktSize,pktCount-1, pktInterval);
}
else
{
socket->Close ();
}
}

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

{
std::string phyMode ("DsssRate1Mbps");
double rss = -80; // -dBm uint32_t
packetSize = 1000; // bytes uint32_t
numPackets = 1; double interval = 1.0; //
seconds bool verbose = false;

CommandLine cmd;
 cmd.AddValue ("phyMode", "Wifi Phy mode", phyMode); cmd.AddValue
("rss", "received signal strength", rss); cmd.AddValue ("packetSize", "size of
application packet sent", packetSize); cmd.AddValue ("numPackets", "number of
packets generated", numPackets); cmd.AddValue ("interval", "interval (seconds)
between packets", interval); cmd.AddValue ("verbose", "turn on all
WifiNetDevice log components", verbose);

cmd.Parse (argc,
argv); // Convert to time
object
Time interPacketInterval = Seconds (interval);

// disable fragmentation for frames below 2200 bytes

Config::SetDefault ("ns3::WifiRemoteStationManager::FragmentationThreshold",
StringValue ("2200"));
// turn off RTS/CTS for frames below 2200 bytes
Config::SetDefault ("ns3::WifiRemoteStationManager::RtsCtsThreshold", StringValue
("2200"));
// Fix non-unicast data rate to be the same as that of unicast
Config::SetDefault ("ns3::WifiRemoteStationManager::NonUnicastMode",
StringValue (phyMode));

NodeContainer c;
c.Create (2);

// The below set of helpers will help us to put together the wifi NICs we want
WifiHelper wifi;
if (verbose)
{
wifi.EnableLogComponents (); // Turn on all Wifi logging
}
wifi.SetStandard (WIFI_PHY_STANDARD_80211b);

YansWifiPhyHelper wifiPhy = YansWifiPhyHelper::Default ();

// This is one parameter that matters when using FixedRssLossModel
// set it to zero; otherwise, gain will be added
wifiPhy.Set ("RxGain", DoubleValue (0) );
// ns-3 supports RadioTap and Prism tracing extensions for 802.11b
wifiPhy.SetPcapDataLinkType (YansWifiPhyHelper::DLT_IEEE802_11_RADIO);

YansWifiChannelHelper wifiChannel;
wifiChannel.SetPropagationDelay ("ns3::ConstantSpeedPropagationDelayModel");
 // The below FixedRssLossModel will cause the rss to be fixed
regardless // of the distance between the two stations, and the transmit
power
wifiChannel.AddPropagationLoss ("ns3::FixedRssLossModel","Rss",DoubleValue (rss));
wifiPhy.SetChannel (wifiChannel.Create ());

// Add a mac and disable rate control

WifiMacHelper wifiMac;
wifi.SetRemoteStationManager ("ns3::ConstantRateWifiManager",
"DataMode",StringValue (phyMode),
"ControlMode",StringValue (phyMode));

// Setup the rest of the mac

Ssid ssid = Ssid ("wifi-default");
// setup sta.
wifiMac.SetType ("ns3::StaWifiMac",
"Ssid", SsidValue (ssid),
"ActiveProbing", BooleanValue (false));
NetDeviceContainer staDevice = wifi.Install (wifiPhy, wifiMac, c.Get (0));
NetDeviceContainer devices =
staDevice; // setup ap.
wifiMac.SetType ("ns3::ApWifiMac",
"Ssid", SsidValue (ssid));
NetDeviceContainer apDevice = wifi.Install (wifiPhy, wifiMac, c.Get (1));
devices.Add (apDevice);

// Note that with FixedRssLossModel, the positions below are

not // used for received signal strength.
MobilityHelper mobility;
Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator> ();
positionAlloc->Add (Vector (0.0, 0.0, 0.0)); positionAlloc->Add (Vector (5.0, 0.0,
0.0)); mobility.SetPositionAllocator (positionAlloc);
mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
mobility.Install (c);

InternetStackHelper internet;
internet.Install (c);

Ipv4AddressHelper ipv4;
NS_LOG_INFO ("Assign IP Addresses.");
ipv4.SetBase ("10.1.1.0", "255.255.255.0");
Ipv4InterfaceContainer i = ipv4.Assign (devices);

TypeId tid = TypeId::LookupByName ("ns3::UdpSocketFactory");

 Ptr<Socket> recvSink = Socket::CreateSocket (c.Get (0), tid);
InetSocketAddress local = InetSocketAddress (Ipv4Address::GetAny (), 80); recvSink-
>Bind (local);
recvSink->SetRecvCallback (MakeCallback (&ReceivePacket));

Ptr<Socket> source = Socket::CreateSocket (c.Get (1), tid);

InetSocketAddress remote = InetSocketAddress (Ipv4Address ("255.255.255.255"), 80);
source->SetAllowBroadcast (true);
source->Connect (remote);

// Tracing
wifiPhy.EnablePcap ("wifi-simple-infra", devices);

// Output what we are doing

NS_LOG_UNCOND ("Testing " << numPackets << " packets sent with receiver rss " << rss
);

Simulator::ScheduleWithContext (source->GetNode ()->GetId (),

Seconds (1.0), &GenerateTraffic,
source, packetSize, numPackets, interPacketInterval);

Simulator::Stop (Seconds (30.0));

Simulator::Run ();
Simulator::Destroy ();

return 0;
}
 3. WIFI SIMPLE ADHOC MODE
This script configures two nodes on an 802.11b physical layer, with 802.11b NICs in adhoc mode,
and by default, sends one packet of 1000 (application) bytes to the other node. The physical
layer is configured to receive at a fixed RSS (regardless of the distance and transmit power);
therefore, changing position of the nodes has no effect.

There are a number of command-line options available to control the default behavior. The list
of available command-line options can be listed with the following command: ./waf --run
"wifisimple-adhoc --help" For instance, for this configuration, the physical layer will stop
successfully receiving packets when rss drops below -97 dBm To see this effect, try running:

./waf --run "wifi-simple-adhoc --rss=-97 --numPackets=20"

./waf --run "wifi-simple-adhoc --rss=-98 --numPackets=20"
./waf --run "wifi-simple-adhoc --rss=-99 --numPackets=20"

Note that all ns-3 attributes (not just the ones exposed in the below script) can be changed at
ommand line; see the documentation.

This script can also be helpful to put the Wifi layer into verbose logging mode; this command
will turn on all wifi logging:

./waf --run "wifi-simple-adhoc --verbose=1"

 When you are done, you will notice two pcap trace files in your directory. If you have tcpdump
installed, you can try this:
tcpdump -r wifi-simple-adhoc-0-0.pcap -nn -tt

#include "ns3/core-module.h"
#include "ns3/network-module.h"
#include "ns3/mobility-module.h"
#include "ns3/config-store-module.h"
#include "ns3/wifi-module.h"
#include "ns3/internet-module.h"

#include <iostream>
#include <fstream>
#include <vector>
#include <string>

using namespace ns3;

NS_LOG_COMPONENT_DEFINE ("WifiSimpleAdhoc");

void ReceivePacket (Ptr<Socket> socket)

{
while (socket->Recv ())
{
NS_LOG_UNCOND ("Received one packet!");
}
}

static void GenerateTraffic (Ptr<Socket> socket, uint32_t pktSize,

uint32_t pktCount, Time pktInterval )
{
if (pktCount > 0)
{
socket->Send (Create<Packet> (pktSize));
Simulator::Schedule (pktInterval, &GenerateTraffic,
socket, pktSize,pktCount-1, pktInterval);
}
else
{
socket->Close ();
}
}
int main (int argc, char *argv[])
{
std::string phyMode ("DsssRate1Mbps");
double rss = -80; // -dBm uint32_t
packetSize = 1000; // bytes uint32_t
numPackets = 1; double interval = 1.0; //
seconds bool verbose = false;

CommandLine cmd;

cmd.AddValue ("phyMode", "Wifi Phy mode", phyMode);

cmd.AddValue ("rss", "received signal strength", rss);
cmd.AddValue ("packetSize", "size of application packet sent", packetSize);
cmd.AddValue ("numPackets", "number of packets generated", numPackets);
cmd.AddValue ("interval", "interval (seconds) between packets", interval); cmd.AddValue
("verbose", "turn on all WifiNetDevice log components", verbose);

cmd.Parse (argc,
argv); // Convert to time
object
Time interPacketInterval = Seconds (interval);

// disable fragmentation for frames below 2200 bytes

Config::SetDefault ("ns3::WifiRemoteStationManager::FragmentationThreshold",
StringValue ("2200"));
// turn off RTS/CTS for frames below 2200 bytes
Config::SetDefault ("ns3::WifiRemoteStationManager::RtsCtsThreshold", StringValue
("2200"));
// Fix non-unicast data rate to be the same as that of unicast
Config::SetDefault ("ns3::WifiRemoteStationManager::NonUnicastMode",
StringValue (phyMode));

NodeContainer c;
c.Create (2);

// The below set of helpers will help us to put together the wifi NICs we want
WifiHelper wifi;
if (verbose)
{
wifi.EnableLogComponents (); // Turn on all Wifi logging
}
wifi.SetStandard (WIFI_PHY_STANDARD_80211b);
 YansWifiPhyHelper wifiPhy = YansWifiPhyHelper::Default ();
// This is one parameter that matters when using FixedRssLossModel
// set it to zero; otherwise, gain will be added
wifiPhy.Set ("RxGain", DoubleValue (0) );
// ns-3 supports RadioTap and Prism tracing extensions for 802.11b
wifiPhy.SetPcapDataLinkType (YansWifiPhyHelper::DLT_IEEE802_11_RADIO);

YansWifiChannelHelper wifiChannel;
wifiChannel.SetPropagationDelay ("ns3::ConstantSpeedPropagationDelayModel");
// The below FixedRssLossModel will cause the rss to be fixed
regardless // of the distance between the two stations, and the transmit
power
wifiChannel.AddPropagationLoss ("ns3::FixedRssLossModel","Rss",DoubleValue (rss));
wifiPhy.SetChannel (wifiChannel.Create ());

// Add a mac and disable rate control

WifiMacHelper wifiMac;
wifi.SetRemoteStationManager ("ns3::ConstantRateWifiManager",
"DataMode",StringValue (phyMode),
"ControlMode",StringValue (phyMode));
// Set it to adhoc mode
wifiMac.SetType ("ns3::AdhocWifiMac");
NetDeviceContainer devices = wifi.Install (wifiPhy, wifiMac, c);

// Note that with FixedRssLossModel, the positions below are

not // used for received signal strength.
MobilityHelper mobility;
Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator> ();
positionAlloc->Add (Vector (0.0, 0.0, 0.0)); positionAlloc->Add (Vector (5.0, 0.0,
0.0)); mobility.SetPositionAllocator (positionAlloc);
mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
mobility.Install (c);

InternetStackHelper internet;
internet.Install (c);

Ipv4AddressHelper ipv4;
NS_LOG_INFO ("Assign IP Addresses.");
ipv4.SetBase ("10.1.1.0", "255.255.255.0");
Ipv4InterfaceContainer i = ipv4.Assign (devices);

TypeId tid = TypeId::LookupByName ("ns3::UdpSocketFactory");

Ptr<Socket> recvSink = Socket::CreateSocket (c.Get (0), tid);
 InetSocketAddress local = InetSocketAddress (Ipv4Address::GetAny (), 80); recvSink-
>Bind (local);
recvSink->SetRecvCallback (MakeCallback (&ReceivePacket));

Ptr<Socket> source = Socket::CreateSocket (c.Get (1), tid);

InetSocketAddress remote = InetSocketAddress (Ipv4Address ("255.255.255.255"), 80);
source->SetAllowBroadcast (true);
source->Connect (remote);

// Tracing
wifiPhy.EnablePcap ("wifi-simple-adhoc", devices);

// Output what we are doing

NS_LOG_UNCOND ("Testing " << numPackets << " packets sent with receiver rss " << rss
);

Simulator::ScheduleWithContext (source->GetNode ()->GetId (),

Seconds (1.0), &GenerateTraffic,
source, packetSize, numPackets, interPacketInterval);

Simulator::Run ();
Simulator::Destroy ();

return 0;
}

4. WIFI TO WIRED BRIDGING

Default network topology includes some number of AP nodes specified by the variable nWifis
(defaults to two). Off of each AP node, there are some number of STA nodes specified by the
variable nStas (defaults to two). Each AP talks to its associated STA nodes. There are bridge net
devices on each AP node that bridge the whole thing into one network.

//
// +-----+ +-----+ +-----+ +-----+
// | STA | | STA | | STA | | STA |
// +-----+ +-----+ +-----+ +-----+
// 192.168.0.2 192.168.0.3 192.168.0.5 192.168.0.6
// -------- -------- -------- --------
// WIFI STA WIFI STA WIFI STA WIFI STA
// -------- -------- -------- --------
// ((*)) ((*)) | ((*)) ((*))
// |
// ((*)) | ((*))
// ------- -------
// WIFI AP CSMA ========= CSMA WIFI AP
// ------- ---- ---- -------
// ############## ##############
// BRIDGE BRIDGE
// ############## ##############
// 192.168.0.1 192.168.0.4
// +---------+ +---------+
// | AP Node | | AP Node |
// +---------+ +---------+
//

#include "ns3/core-module.h"
#include "ns3/mobility-module.h"
#include "ns3/applications-module.h"
#include "ns3/wifi-module.h"
#include "ns3/network-module.h"
#include "ns3/csma-module.h"
#include "ns3/internet-module.h"
#include "ns3/bridge-helper.h"
#include <vector>
#include <stdint.h>
#include <sstream>
#include <fstream>

using namespace ns3;

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

{
uint32_t nWifis = 2;
uint32_t nStas = 2;
bool sendIp = true;
bool writeMobility = false;

CommandLine cmd;
cmd.AddValue ("nWifis", "Number of wifi networks", nWifis);
cmd.AddValue ("nStas", "Number of stations per wifi network", nStas);
cmd.AddValue ("SendIp", "Send Ipv4 or raw packets", sendIp);
cmd.AddValue ("writeMobility", "Write mobility trace", writeMobility);
cmd.Parse (argc, argv);
 NodeContainer backboneNodes;
NetDeviceContainer backboneDevices;
Ipv4InterfaceContainer backboneInterfaces;
std::vector<NodeContainer> staNodes;
std::vector<NetDeviceContainer> staDevices;
std::vector<NetDeviceContainer> apDevices;
std::vector<Ipv4InterfaceContainer> staInterfaces;
std::vector<Ipv4InterfaceContainer> apInterfaces;

InternetStackHelper stack;
CsmaHelper csma;
Ipv4AddressHelper ip;
ip.SetBase ("192.168.0.0", "255.255.255.0");

backboneNodes.Create (nWifis);
stack.Install (backboneNodes);

backboneDevices = csma.Install (backboneNodes);

double wifiX = 0.0;

YansWifiPhyHelper wifiPhy = YansWifiPhyHelper::Default ();

wifiPhy.SetPcapDataLinkType (YansWifiPhyHelper::DLT_IEEE802_11_RADIO);

for (uint32_t i = 0; i < nWifis; ++i)

{
// calculate ssid for wifi subnetwork
std::ostringstream oss; oss <<
"wifi-default-" << i; Ssid ssid =
Ssid (oss.str ());

NodeContainer sta;
NetDeviceContainer staDev;
NetDeviceContainer apDev;
Ipv4InterfaceContainer staInterface;
Ipv4InterfaceContainer apInterface;
MobilityHelper mobility;
BridgeHelper bridge;
WifiHelper wifi;
WifiMacHelper wifiMac;
YansWifiChannelHelper wifiChannel = YansWifiChannelHelper::Default ();
wifiPhy.SetChannel (wifiChannel.Create ());
 sta.Create (nStas);
mobility.SetPositionAllocator ("ns3::GridPositionAllocator",
"MinX", DoubleValue (wifiX),
"MinY", DoubleValue (0.0),
"DeltaX", DoubleValue (5.0),
"DeltaY", DoubleValue (5.0),
"GridWidth", UintegerValue (1),
"LayoutType", StringValue ("RowFirst"));

// setup the AP.

mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
mobility.Install (backboneNodes.Get (i));
wifiMac.SetType ("ns3::ApWifiMac",
"Ssid", SsidValue (ssid));
apDev = wifi.Install (wifiPhy, wifiMac, backboneNodes.Get (i));

NetDeviceContainer bridgeDev;
bridgeDev = bridge.Install (backboneNodes.Get (i), NetDeviceContainer (apDev,
backboneDevices.Get (i)));

// assign AP IP address to bridge, not wifi

apInterface = ip.Assign (bridgeDev);

// setup the STAs

stack.Install (sta);
mobility.SetMobilityModel ("ns3::RandomWalk2dMobilityModel",
"Mode", StringValue ("Time"),
"Time", StringValue ("2s"),
"Speed", StringValue ("ns3::ConstantRandomVariable[Constant=1.0]"),
"Bounds", RectangleValue (Rectangle (wifiX, wifiX+5.0,0.0,
(nStas+1)*5.0)));
mobility.Install (sta);
wifiMac.SetType ("ns3::StaWifiMac",
"Ssid", SsidValue (ssid),
"ActiveProbing", BooleanValue (false));
staDev = wifi.Install (wifiPhy, wifiMac, sta); staInterface
= ip.Assign (staDev);
// save everything in containers.
staNodes.push_back (sta); apDevices.push_back
(apDev); apInterfaces.push_back (apInterface);
staDevices.push_back (staDev);
staInterfaces.push_back (staInterface);
 wifiX += 20.0;
}

Address dest;
std::string protocol; if
(sendIp)
{
dest = InetSocketAddress (staInterfaces[1].GetAddress (1), 1025);
protocol = "ns3::UdpSocketFactory";
}
else
{
PacketSocketAddress tmp; tmp.SetSingleDevice
(staDevices[0].Get (0)->GetIfIndex ()); tmp.SetPhysicalAddress
(staDevices[1].Get (0)->GetAddress ()); tmp.SetProtocol
(0x807);
dest = tmp;
protocol = "ns3::PacketSocketFactory";
}

OnOffHelper onoff = OnOffHelper (protocol, dest);

onoff.SetConstantRate (DataRate ("500kb/s"));
ApplicationContainer apps = onoff.Install (staNodes[0].Get (0));
apps.Start (Seconds (0.5));
apps.Stop (Seconds (3.0));

wifiPhy.EnablePcap ("wifi-wired-bridging", apDevices[0]);

wifiPhy.EnablePcap ("wifi-wired-bridging", apDevices[1]);

if (writeMobility)
{
AsciiTraceHelper ascii;
MobilityHelper::EnableAsciiAll (ascii.CreateFileStream ("wifi-wired-bridging.mob"));
}

Simulator::Stop (Seconds (5.0));

Simulator::Run ();
Simulator::Destroy ();
}
5. WIFI TO LTE(4G) CONNECTION

#include "ns3/lte-helper.h"
#include "ns3/epc-helper.h"

#include "ns3/core-module.h"
#include "ns3/point-to-point-module.h"
#include "ns3/wifi-module.h"
#include "ns3/csma-module.h"
#include "ns3/network-module.h"
#include "ns3/applications-module.h"
#include "ns3/mobility-module.h"
#include "ns3/config-store-module.h"
#include "ns3/wimax-module.h"
#include "ns3/internet-module.h"
#include "ns3/global-route-manager.h"
#include "ns3/ipcs-classifier-record.h"
#include "ns3/service-flow.h"
#include <iostream>
#include "ns3/ipv4-global-routing-helper.h"
#include "ns3/mobility-module.h"
#include "ns3/lte-module.h"
#include "ns3/point-to-point-helper.h"
#include <iomanip>
#include <string>
#include <fstream>
#include <vector>

NS_LOG_COMPONENT_DEFINE ("WimaxSimpleExample");

using namespace ns3;

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

{
Config::SetDefault ("ns3::LteAmc::AmcModel", EnumValue (LteAmc::PiroEW2010));
bool verbose = false;

int duration = 500, schedType = 0;

 uint16_t numberOfUEs=2; //Default number of ues attached to each eNodeB

Ptr<LteHelper> lteHelper; //Define LTE

Ptr<EpcHelper> epcHelper; //Define EPC

NodeContainer remoteHostContainer; //Define the Remote Host

NetDeviceContainer internetDevices; //Define the Network Devices in the Connection
between EPC and the remote host

Ptr<Node> pgw; //Define the Packet Data Network Gateway(P-GW)

Ptr<Node> remoteHost; //Define the node of remote Host

InternetStackHelper internet; //Define the internet stack

PointToPointHelper p2ph; //Define Connection between EPC and the
Remote Host
Ipv4AddressHelper ipv4h; //Ipv4 address helper
Ipv4StaticRoutingHelper ipv4RoutingHelper; //Ipv4 static routing helper
Ptr<Ipv4StaticRouting> remoteHostStaticRouting;

Ipv4InterfaceContainer internetIpIfaces; //Ipv4 interfaces

CommandLine cmd;
cmd.AddValue ("scheduler", "type of scheduler to use with the network devices", schedType);
cmd.AddValue ("duration", "duration of the simulation in seconds", duration); cmd.AddValue
("verbose", "turn on all WimaxNetDevice log components", verbose); cmd.Parse (argc, argv);
LogComponentEnable ("UdpClient", LOG_LEVEL_INFO);
LogComponentEnable ("UdpServer", LOG_LEVEL_INFO);
//LogComponentEnable ("UdpEchoClientApplication", LOG_LEVEL_INFO);
//LogComponentEnable ("UdpEchoServerApplication", LOG_LEVEL_INFO);

NodeContainer ssNodes;
NodeContainer bsNodes;

ssNodes.Create (2);
bsNodes.Create (1);

uint32_t nCsma = 3;

NodeContainer p2pNodes;
p2pNodes.Create (2);

PointToPointHelper pointToPoint;
 pointToPoint.SetDeviceAttribute ("DataRate", StringValue ("5Mbps"));
pointToPoint.SetChannelAttribute ("Delay", StringValue ("2ms"));

NetDeviceContainer p2pDevices;
p2pDevices = pointToPoint.Install (p2pNodes);

NodeContainer csmaNodes;
csmaNodes.Add (p2pNodes.Get (1));
csmaNodes.Create (nCsma);

CsmaHelper csma; csma.SetChannelAttribute ("DataRate",

StringValue ("100Mbps")); csma.SetChannelAttribute ("Delay",
TimeValue (NanoSeconds (6560)));

NetDeviceContainer csmaDevices;
csmaDevices = csma.Install (csmaNodes);

NodeContainer wifiApNode = p2pNodes.Get (0);

YansWifiChannelHelper channel = YansWifiChannelHelper::Default ();

YansWifiPhyHelper phy = YansWifiPhyHelper::Default ();
phy.SetChannel (channel.Create ());

WifiHelper wifi = WifiHelper::Default ();

wifi.SetRemoteStationManager ("ns3::AarfWifiManager");

NqosWifiMacHelper mac = NqosWifiMacHelper::Default ();

Ssid ssid = Ssid ("ns-3-ssid");

mac.SetType ("ns3::StaWifiMac",
"Ssid", SsidValue (ssid),
"ActiveProbing", BooleanValue (false));

NetDeviceContainer staDevices;
staDevices = wifi.Install (phy, mac, ssNodes);

mac.SetType ("ns3::ApWifiMac",
"Ssid", SsidValue (ssid));

NetDeviceContainer apDevices;
apDevices = wifi.Install (phy, mac, wifiApNode);

MobilityHelper mobility1;
 mobility1.SetPositionAllocator ("ns3::GridPositionAllocator",
"MinX", DoubleValue (0.0),
"MinY", DoubleValue (0.0),
"DeltaX", DoubleValue (5.0),
"DeltaY", DoubleValue (10.0),
"GridWidth", UintegerValue (3),
"LayoutType", StringValue ("RowFirst")); mobility1.SetMobilityModel
("ns3::ConstantPositionMobilityModel"); mobility1.Install (wifiApNode);
(wifiApNode.Get(0) -> GetObject<ConstantPositionMobilityModel>()) ->
SetPosition(Vector(100.0, 501.0, 0.0));
InternetStackHelper stack1;
stack1.Install (csmaNodes); stack1.Install
(wifiApNode);
stack1.Install (ssNodes);

Ipv4AddressHelper address1;

address1.SetBase ("11.1.1.0", "255.255.255.0");

Ipv4InterfaceContainer p2pInterfaces;
p2pInterfaces = address1.Assign (p2pDevices);

address1.SetBase ("11.1.2.0", "255.255.255.0");

Ipv4InterfaceContainer csmaInterfaces; csmaInterfaces
= address1.Assign (csmaDevices);

address1.SetBase ("11.1.3.0", "255.255.255.0");

address1.Assign (staDevices);
address1.Assign (apDevices);

UdpEchoServerHelper echoServer (9);

ApplicationContainer serverApps1 = echoServer.Install (csmaNodes.Get (nCsma));

serverApps1.Start (Seconds (1.0));
serverApps1.Stop (Seconds (duration+0.1));

UdpEchoClientHelper echoClient (csmaInterfaces.GetAddress (nCsma), 9);

echoClient.SetAttribute ("MaxPackets", UintegerValue (1000));
echoClient.SetAttribute ("Interval", TimeValue (Seconds (1.))); echoClient.SetAttribute
("PacketSize", UintegerValue (1024));

ApplicationContainer clientApps1 =
echoClient.Install (ssNodes.Get (0)); clientApps1.Start
(Seconds (2.0));
 clientApps1.Stop (Seconds (duration+0.1));

Ipv4GlobalRoutingHelper::PopulateRoutingTables ();

//pointToPoint.EnablePcapAll ("third");
phy.EnablePcap ("third", apDevices.Get (0));
//csma.EnablePcap ("third", csmaDevices.Get (0), true);

lteHelper = CreateObject<LteHelper> ();

epcHelper = CreateObject<EpcHelper> ();

lteHelper->SetEpcHelper (epcHelper);
lteHelper->SetSchedulerType("ns3::RrFfMacScheduler"); lteHelper-
>SetAttribute ("PathlossModel",
StringValue ("ns3::FriisPropagationLossModel"));
pgw = epcHelper->GetPgwNode ();

remoteHostContainer.Create (1);
remoteHost = remoteHostContainer.Get (0);
internet.Install (remoteHostContainer);

p2ph.SetDeviceAttribute ("DataRate", DataRateValue (DataRate ("100Gb/s")));

p2ph.SetDeviceAttribute ("Mtu", UintegerValue (1500)); p2ph.SetChannelAttribute
("Delay", TimeValue (Seconds (0.010))); internetDevices = p2ph.Install (pgw,
remoteHost);

ipv4h.SetBase ("1.0.0.0", "255.0.0.0");

internetIpIfaces = ipv4h.Assign (internetDevices);

remoteHostStaticRouting = ipv4RoutingHelper.GetStaticRouting (remoteHost->GetObject<Ipv4> ());

remoteHostStaticRouting->AddNetworkRouteTo (Ipv4Address ("7.0.0.0"), Ipv4Mask ("255.0.0.0"),
1);

std::cout << "2. Installing LTE+EPC+remotehost. Done!" << std::endl;

MobilityHelper mobility;
Ptr<ListPositionAllocator> positionAlloc;
positionAlloc = CreateObject<ListPositionAllocator> ();

positionAlloc->Add (Vector (0.0, 500.0, 0.0)); //STA

mobility.SetPositionAllocator (positionAlloc);
 mobility.SetMobilityModel ("ns3::ConstantVelocityMobilityModel");
mobility.Install(ssNodes.Get(0));

Ptr<ConstantVelocityMobilityModel> cvm = ssNodes.Get(0)-

>GetObject<ConstantVelocityMobilityModel>();
cvm->SetVelocity(Vector (5, 0, 0)); //move to left to right 10.0m/s

positionAlloc = CreateObject<ListPositionAllocator> ();

positionAlloc->Add (Vector (0.0, 500.0, 10.0)); //MAG1AP positionAlloc-

>Add (Vector (0.0, 510.0, 0.0)); //MAG2AP

mobility.SetPositionAllocator (positionAlloc);
mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");

mobility.Install (NodeContainer(bsNodes.Get(0),ssNodes.Get(1)));

NetDeviceContainer ssDevs, bsDevs;

bsDevs = lteHelper->InstallEnbDevice (bsNodes); ssDevs=lteHelper-

>InstallUeDevice (ssNodes);

for (uint16_t j=0; j < numberOfUEs; j++)

{
lteHelper->Attach (ssDevs.Get(j), bsDevs.Get(0));
}

Ipv4InterfaceContainer iueIpIface;
iueIpIface = epcHelper->AssignUeIpv4Address (NetDeviceContainer (ssDevs));

lteHelper->ActivateEpsBearer (ssDevs, EpsBearer (EpsBearer::NGBR_VIDEO_TCP_DEFAULT),

EpcTft::Default ());

UdpServerHelper udpServer;
ApplicationContainer serverApps;
UdpClientHelper udpClient;
ApplicationContainer clientApps;
udpServer = UdpServerHelper (100);

serverApps = udpServer.Install (ssNodes.Get (0));

serverApps.Start (Seconds (6));
serverApps.Stop (Seconds (duration));
 udpClient = UdpClientHelper (iueIpIface.GetAddress (0), 100);
udpClient.SetAttribute ("MaxPackets", UintegerValue (200000));
udpClient.SetAttribute ("Interval", TimeValue (Seconds (0.004)));
udpClient.SetAttribute ("PacketSize", UintegerValue (1024));

clientApps = udpClient.Install (remoteHost);

clientApps.Start (Seconds (6)); clientApps.Stop
(Seconds (duration)); lteHelper-
>EnableTraces ();

NS_LOG_INFO ("Starting simulation.....");

Simulator::Stop(Seconds(duration));

Simulator::Run ();
Simulator::Destroy ();
NS_LOG_INFO ("Done.");
return 0;
}
6. CREATING A SIMPLE WIFI ADHOC GRID

n20 n21 n22 n23 n24

n15 n16 n17 n18 n19
n10 n11 n12 n13 n14
n5 n6 n7 n8 n9
n0 n1 n2 n3 n4
The layout is affected by the parameters given to GridPositionAllocator; By
default, GridWidth is 5 and numNodes is 25..

Flow 1: 0->24
Flow 2: 20->4
Flow 3: 10->4

STEPS:
1. Setup a 5x5 wireless adhoc network with a grid. You may use examples/wireless/wifisimple-
adhoc-grid.cc as a base.

2. Install the OLSR routing protocol.

3. Setup three UDP traffic flows, one along each diagonal and one along the middle (at high
rates of transmission).

4. Setup the ns-3 flow monitor for each of these flows.

5. Now schedule each of the flows at times 1s, 1.5s, and 2s.

6. Now using the flow monitor, observe the throughput of each of the UDP flows. Furthermore,
use the tracing mechanism to monitor the number of packet collisions/drops at intermediary
nodes. Around which nodes are most of the collisions/drops happening?

7. Now repeat the experiment with RTS/CTS enabled on the wifi devices.

8. Show the difference in throughput and packet drops if any.

#include "ns3/core-module.h"
#include "ns3/network-module.h"
#include "ns3/mobility-module.h"
#include "ns3/config-store-module.h"
#include "ns3/wifi-module.h"
#include "ns3/internet-module.h"
#include "ns3/olsr-helper.h"
#include "ns3/flow-monitor-module.h"
#include "myapp.h"
#include <iostream>
#include <fstream>
#include <vector>
#include <string>

NS_LOG_COMPONENT_DEFINE ("Lab5");

using namespace ns3;

uint32_t MacTxDropCount, PhyTxDropCount, PhyRxDropCount;

void
MacTxDrop(Ptr<const Packet> p)
{
NS_LOG_INFO("Packet Drop");
MacTxDropCount++;
}

void PrintDrop()
{
std::cout << Simulator::Now().GetSeconds() << "\t" << MacTxDropCount << "\t"<<
PhyTxDropCount << "\t" << PhyRxDropCount << "\n";
Simulator::Schedule(Seconds(5.0), &PrintDrop);
}

void
PhyTxDrop(Ptr<const Packet> p)
{
NS_LOG_INFO("Packet Drop");
PhyTxDropCount++;
} void
PhyRxDrop(Ptr<const Packet> p)
{
NS_LOG_INFO("Packet Drop");
PhyRxDropCount++;
}
int main (int argc, char *argv[])
{
 std::string phyMode ("DsssRate1Mbps");
double distance = 500; // m
uint32_t numNodes = 25; // by default, 5x5
double interval = 0.001; // seconds uint32_t
packetSize = 600; // bytes
uint32_t numPackets = 10000000;
std::string rtslimit = "1500";
CommandLine cmd;

cmd.AddValue ("phyMode", "Wifi Phy mode", phyMode);

cmd.AddValue ("distance", "distance (m)", distance);
cmd.AddValue ("packetSize", "distance (m)", packetSize);
cmd.AddValue ("rtslimit", "RTS/CTS Threshold (bytes)", rtslimit);
cmd.Parse (argc, argv); // Convert to time object
Time interPacketInterval = Seconds (interval);

// turn off RTS/CTS for frames below 2200 bytes

Config::SetDefault ("ns3::WifiRemoteStationManager::RtsCtsThreshold", StringValue
(rtslimit));
// Fix non-unicast data rate to be the same as that of unicast
Config::SetDefault ("ns3::WifiRemoteStationManager::NonUnicastMode", StringValue
(phyMode));

NodeContainer c;
c.Create (numNodes);

// The below set of helpers will help us to put together the wifi NICs we want
WifiHelper wifi;

YansWifiPhyHelper wifiPhy = YansWifiPhyHelper::Default ();

// set it to zero; otherwise, gain will be added
wifiPhy.Set ("RxGain", DoubleValue (-10) );
// ns-3 supports RadioTap and Prism tracing extensions for 802.11b
wifiPhy.SetPcapDataLinkType (YansWifiPhyHelper::DLT_IEEE802_11_RADIO);

YansWifiChannelHelper wifiChannel;
wifiChannel.SetPropagationDelay
("ns3::ConstantSpeedPropagationDelayModel"); wifiChannel.AddPropagationLoss
("ns3::FriisPropagationLossModel"); wifiPhy.SetChannel (wifiChannel.Create ());

// Add a non-QoS upper mac, and disable rate control

NqosWifiMacHelper wifiMac = NqosWifiMacHelper::Default ();
wifi.SetStandard (WIFI_PHY_STANDARD_80211b);
 wifi.SetRemoteStationManager ("ns3::ConstantRateWifiManager",
"DataMode",StringValue (phyMode),
"ControlMode",StringValue (phyMode));
// Set it to adhoc mode
wifiMac.SetType ("ns3::AdhocWifiMac");
NetDeviceContainer devices = wifi.Install (wifiPhy, wifiMac, c);

MobilityHelper mobility;
mobility.SetPositionAllocator ("ns3::GridPositionAllocator",
"MinX", DoubleValue (0.0),
"MinY", DoubleValue (0.0),
"DeltaX", DoubleValue (distance),
"DeltaY", DoubleValue (distance),
"GridWidth", UintegerValue (5),
"LayoutType", StringValue ("RowFirst"));
mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel"); mobility.Install
(c);

// Enable OLSR
OlsrHelper olsr;

Ipv4ListRoutingHelper list;
list.Add (olsr, 10);

InternetStackHelper internet;
internet.SetRoutingHelper (list); // has effect on the next Install ()
internet.Install (c);

Ipv4AddressHelper ipv4;
NS_LOG_INFO ("Assign IP Addresses.");
ipv4.SetBase ("10.1.1.0", "255.255.255.0");
Ipv4InterfaceContainer ifcont = ipv4.Assign (devices);

// Create Apps

uint16_t sinkPort = 6; // use the same for all apps

// UDP connection from N0 to N24

Address sinkAddress1 (InetSocketAddress (ifcont.GetAddress (24), sinkPort)); // interface of

n24
PacketSinkHelper packetSinkHelper1 ("ns3::UdpSocketFactory", InetSocketAddress
(Ipv4Address::GetAny (), sinkPort));
 ApplicationContainer sinkApps1 = packetSinkHelper1.Install (c.Get (24)); //n2 as sink
sinkApps1.Start (Seconds (0.));
sinkApps1.Stop (Seconds (100.));

Ptr<Socket> ns3UdpSocket1 = Socket::CreateSocket (c.Get (0),

UdpSocketFactory::GetTypeId ()); //source at n0

// Create UDP application at n0

Ptr<MyApp> app1 = CreateObject<MyApp> ();
app1->Setup (ns3UdpSocket1, sinkAddress1, packetSize, numPackets, DataRate ("1Mbps"));
c.Get (0)->AddApplication (app1); app1-
>SetStartTime (Seconds (31.));
app1->SetStopTime (Seconds (100.));

// UDP connection from N10 to N14

Address sinkAddress2 (InetSocketAddress (ifcont.GetAddress (14), sinkPort)); // interface of

n14
PacketSinkHelper packetSinkHelper2 ("ns3::UdpSocketFactory", InetSocketAddress
(Ipv4Address::GetAny (), sinkPort));
ApplicationContainer sinkApps2 = packetSinkHelper2.Install (c.Get (14)); //n14 as sink
sinkApps2.Start (Seconds (0.));
sinkApps2.Stop (Seconds (100.));

Ptr<Socket> ns3UdpSocket2 = Socket::CreateSocket (c.Get (10),

UdpSocketFactory::GetTypeId ()); //source at n10

// Create UDP application at n10

Ptr<MyApp> app2 = CreateObject<MyApp> ();
app2->Setup (ns3UdpSocket2, sinkAddress2, packetSize, numPackets, DataRate ("1Mbps"));
c.Get (10)->AddApplication (app2); app2->SetStartTime (Seconds (31.5));
app2->SetStopTime (Seconds (100.));

// UDP connection from N20 to N4

Address sinkAddress3 (InetSocketAddress (ifcont.GetAddress (4), sinkPort)); // interface of

n4
PacketSinkHelper packetSinkHelper3 ("ns3::UdpSocketFactory", InetSocketAddress
(Ipv4Address::GetAny (), sinkPort));
ApplicationContainer sinkApps3 = packetSinkHelper3.Install (c.Get (4)); //n2 as sink
sinkApps3.Start (Seconds (0.));
sinkApps3.Stop (Seconds (100.));
 Ptr<Socket> ns3UdpSocket3 = Socket::CreateSocket (c.Get (20),
UdpSocketFactory::GetTypeId ()); //source at n20

// Create UDP application at n20

Ptr<MyApp> app3 = CreateObject<MyApp> ();
app3->Setup (ns3UdpSocket3, sinkAddress3, packetSize, numPackets, DataRate
("1Mbps"));
c.Get (20)->AddApplication (app3); app3-
>SetStartTime (Seconds (32.));
app3->SetStopTime (Seconds (100.));

// Install FlowMonitor on all nodes

FlowMonitorHelper flowmon;
Ptr<FlowMonitor> monitor = flowmon.InstallAll();

// Trace Collisions

Config::ConnectWithoutContext("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Mac/MacTx
Drop", MakeCallback(&MacTxDrop));

Config::ConnectWithoutContext("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/PhyRxD
rop", MakeCallback(&PhyRxDrop));

Config::ConnectWithoutContext("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/PhyTxD
rop", MakeCallback(&PhyTxDrop));

Simulator::Schedule(Seconds(5.0), &PrintDrop);

Simulator::Stop (Seconds (100.0));

Simulator::Run ();

PrintDrop();

// Print per flow statistics monitor-

>CheckForLostPackets ();
Ptr<Ipv4FlowClassifier> classifier = DynamicCast<Ipv4FlowClassifier>
(flowmon.GetClassifier ());
std::map<FlowId, FlowMonitor::FlowStats> stats = monitor->GetFlowStats ();

for (std::map<FlowId, FlowMonitor::FlowStats>::const_iterator iter = stats.begin (); iter !=

stats.end (); ++iter)
{
 Ipv4FlowClassifier::FiveTuple t = classifier->FindFlow (iter->first);

if ((t.sourceAddress == Ipv4Address("10.1.1.1") && t.destinationAddress ==

Ipv4Address("10.1.1.25"))
|| (t.sourceAddress == Ipv4Address("10.1.1.11") && t.destinationAddress ==
Ipv4Address("10.1.1.15"))
|| (t.sourceAddress == Ipv4Address("10.1.1.21") && t.destinationAddress ==
Ipv4Address("10.1.1.5")))
{
NS_LOG_UNCOND("Flow ID: " << iter->first << " Src Addr " << t.sourceAddress
<< " Dst Addr " << t.destinationAddress);
NS_LOG_UNCOND("Tx Packets = " << iter->second.txPackets);
NS_LOG_UNCOND("Rx Packets = " << iter->second.rxPackets);
NS_LOG_UNCOND("Throughput: " << iter->second.rxBytes * 8.0 / (iter-
>second.timeLastRxPacket.GetSeconds()-iter->second.timeFirstTxPacket.GetSeconds()) / 1024
<< " Kbps");
}
}
monitor->SerializeToXmlFile("lab-5.flowmon", true, true);

Simulator::Destroy ();

return 0;
}
7. To Study Architecture of GSM.

System Architecture

• A GSM network consists of several functional entities, whose functions and

interfaces are defined. The GSM network can be divided into following broad parts.
• The Mobile Station (MS)
• The Base Station Subsystem (BSS)
• The Network Switching Subsystem (NSS)
• The Operation Support Subsystem OSS)
• A GSM Public Land Mobile Network (PLMN) consists of at least one Service Area
controlled by a Mobile Switching Center (MSC) connected to the Public Switched
Telephone Network (PSTN)
• The architecture of a GSM Public Land Mobile Network (PLMN)

• A Base Station Subsystem (BSS) consists of o A Base Station Controller (BSC)

 • At least one radio access point or Base Transceiver Station (BTS) for
Mobile Stations (MS), which are mobile phones or other handheld
devices (for example PDA computers) with phone interface.
• A BTS, with its aerial and associated radio frequency components, is the actual
transmission and reception component. A Network Cell is the area of radio coverage
by one BTS. One or more BTSs are in turn managed by a BSC. A network cell
cluster covered by one or several BSSs can be managed as a Location Area (LA).
All these BSSs must however be controlled by a single MSC.
• Figure shows three LAs of 3, 4 and 4 cells respectively with a MS moving across
cell and LA boundaries where a MS moving across cell and LA boundaries. 3 LAs
consisting of 4 and 5 cells respectively are shown.

• A more detailed architecture of a single MSC controlled Service Area is outlined in

figure below.
• components of the tree GSM network subsystems
• Radio Subsystem (RSS) consisting of the BSSs and all BSS connected MS devices.
• Network and Switching Subsystem
(NSS)
• Operation Subsystem (OSS)
• Specified in GSM 01.02 (‘General description of a GSM Public Land Mobile
Network(PLMN)’) and the GSM components are,

ME = Mobile Equipment
BTS = Base Receiving Station
BSC = Base Station Controller
MSC = Mobile Switching Center
VLR = Visitor Location Register
OMC = Operation and Maintenance Center
 AuC = Authentication Center
HLR = Home Location Register
EIR = Equipment Identity Register
SMSC = Short Message Service
Centre
• A MSC is also through a Gateway MSC (GMSC) connected to other MSCs and to the
Public Switched Telephone Network (PSTN) with the Integrated Services Digital
Network (ISDN) option. The Inter-Working Function (IWF) of GMSC connects the
circuit switched data paths of a GSM network with the PSTN/ISDN. A GMSC is
usually integrated in an MSC.
• Basic GSM network components,