NETWORK SIMULATOR FOR RESEARCH

Mostly the network simulator 3 was introduced for the network research and education. In this section we discuss about the researches on following two networks:

  • M2M (Machine-to-Machine) communication network
  • Telecommunication network

M2M communication network:

  • Machine to Machine (M2M) refers to a wireless or wired network setup that allows devices of the same type and ability to communicate freely.
  • This type of system can be used in a variety of ways and has advanced over the last few decades with the creation of global Internet and IP network systems, facilitating enhanced and efficient communications over long distances and between large numbers of devices.

 

Features of M2M network:

  • Standard 3GPP compliant solution offering guaranteed QoS through smart monetization of M2M transactions
  • Robust inventory/SIM management capability provides flexibility to manage SIM/Device and allocate them to the end users or service or application, even in bulking ensuring enhanced service experience
  • Manage huge M2M traffic with flexibility
  • Support various innovative and complex business models
  • Real-time settlement and commissioning for complex patner

 

Advantages of M2M communication network:

  • Ease of integration
  • Rapid access to M2M services
  • Robust and scalable platform
  • Real-time service management
  • Future-proof solution for complex M2M business models
  • A carrier-grade pre-integrated M2M stack etc.

 

Research issues on M2M network:

  • Building resource sharing management system
  • Study on bandwidth allocation schemes
  • Introducing self organization system
  • Context management
  • Discussing effective access control strategies etc.
NETWORK SIMULATOR FOR RESEARCH

Sample code for M2M communication:
NqosWifiMacHelper wifiMac = NqosWifiMacHelper::Default ();
wifi.SetRemoteStationManager (“ns3::ConstantRateWifiManager”, “DataMode”,
StringValue (phyMode), “ControlMode”,
StringValue (phyMode));
wifiMac.SetType (“ns3::AdhocWifiMac”);

NetDeviceContainer devices = wifi.Install (wifiPhy, wifiMac, networkNodes);

MobilityHelper mobility;
Ptr positionAlloc = CreateObject ();
positionAlloc->Add (Vector (0.0, 0.0, 0.0));
positionAlloc->Add (Vector (2 * distanceToRx, 0.0, 0.0));
mobility.SetPositionAllocator (positionAlloc);
mobility.SetMobilityModel (“ns3::ConstantPositionMobilityModel”);
mobility.Install (c);

BasicEnergySourceHelper basicSourceHelper;
// configure energy source
basicSourceHelper.Set (“BasicEnergySourceInitialEnergyJ”, DoubleValue (0.1));
// install source
EnergySourceContainer sources = basicSourceHelper.Install (c);
WifiRadioEnergyModelHelper radioEnergyHelper;
// configure radio energy model
radioEnergyHelper.Set (“TxCurrentA”, DoubleValue (0.0174));
// install device model
DeviceEnergyModelContainer deviceModels = radioEnergyHelper.Install (devices, sources);

InternetStackHelper internet;
internet.Install (networkNodes);

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 recvSink = Socket::CreateSocket (networkNodes.Get (1), tid); // node 1, receiver
InetSocketAddress local = InetSocketAddress (Ipv4Address::GetAny (), 80);
recvSink->Bind (local);
recvSink->SetRecvCallback (MakeCallback (&ReceivePacket));

Ptr source = Socket::CreateSocket (networkNodes.Get (0), tid); // node 0, sender
InetSocketAddress remote = InetSocketAddress (Ipv4Address::GetBroadcast (), 80);
source->SetAllowBroadcast (true);
source->Connect (remote);

Ptr basicSourcePtr = DynamicCast (sources.Get (1));
basicSourcePtr->TraceConnectWithoutContext (“RemainingEnergy”, MakeCallback (&RemainingEnergy));
// device energy model
Ptr basicRadioModelPtr =
basicSourcePtr->FindDeviceEnergyModels (“ns3::WifiRadioEnergyModel”).Get (0);
NS_ASSERT (basicRadioModelPtr != NULL);
basicRadioModelPtr->TraceConnectWithoutContext (“TotalEnergyConsumption”, MakeCallback (&TotalEnergy));

Telecommunication network:

  • Telecommunications refers to the exchange of information by electronic and electrical means over a significant distance.
  • A complete telecommunication arrangement is made up of two or more stations equipped with transmitter and receiver devices

 

Functions of telecommunication network:

  • Transmit information
  • Establish interface between sender and receiver
  • Route messages along most efficient paths
  • Control flow of information
  • Perform editorial tasks on data
  • Covert message speed or format
  • Perform elementary processing of information

 

Types of communication channels:

  • Fiber optics and optical networks
  • Twisted wire
  • Coaxial cable
  • Bandwidth transmission
  • Wireless transmission like personal digital assistants, paging systems, cellular telephone, microwave satellites, mobile data network, personal communication services etc.

 

Research scope of telecommunication network:

  • Cellular network communications
  • Radio broadcasting system
  • Network management
  • Backup and restoration services
  • Telecommunication network interoperability etc,
NETWORK SIMULATOR FOR RESEARCH

Sample code for telecommunication network:
void
telecommunicationExample::CreateNodes ()
{
std::cout << “Creating ” << (unsigned) m_nWifis << ” nodes.\n”; nodes.Create (m_nWifis); NS_ASSERT_MSG (m_nWifis > m_nSinks, “Sinks must be less or equal to the number of nodes in network”);
}

void
telecommunicationExample::SetupMobility ()
{
MobilityHelper mobility;
ObjectFactory pos;
pos.SetTypeId (“ns3::RandomRectanglePositionAllocator”);
pos.Set (“X”, StringValue (“ns3::UniformRandomVariable[Min=0.0|Max=1500.0]”));
pos.Set (“Y”, StringValue (“ns3::UniformRandomVariable[Min=0.0|Max=800.0]”));

std::ostringstream speedConstantRandomVariableStream;
speedConstantRandomVariableStream << “ns3::ConstantRandomVariable[Constant=”
<< m_nodeSpeed
<< “]”;

Ptr taPositionAlloc = pos.Create ()->GetObject ();
mobility.SetMobilityModel (“ns3::RandomWaypointMobilityModel”, “Speed”, StringValue (speedConstantRandomVariableStream.str ()),
“Pause”, StringValue (“ns3::ConstantRandomVariable[Constant=2.0]”), “PositionAllocator”, PointerValue (taPositionAlloc));
mobility.SetPositionAllocator (taPositionAlloc);
mobility.Install (nodes);
}