iMesh-handover.cc

/* Net topology
 *
 *
 *
 * With a 3x3 mesh grid (size can vary):
 *
 *               n2   n3   n4
 *
 *
 * n0----n1 )))  n5   n6   n7
 *
 *
 *               n8   n9   n10
 *
 *  n0: Internet node
 *  n1: access node (a static mesh node with a P2P link)
 *  n2-n10: mesh nodes
 *
 */



#include "ns3/core-module.h"
#include "ns3/internet-module.h"
#include "ns3/network-module.h"
#include "ns3/applications-module.h"
#include "ns3/wifi-module.h"
#include "ns3/mesh-module.h"
#include "ns3/mobility-module.h"
#include "ns3/mesh-helper.h"
#include "ns3/point-to-point-module.h"
#include "ns3/ipv4-global-routing-helper.h"
#include "ns3/netanim-module.h"
#include "ns3/olsr-helper.h"
#include "ns3/v4ping-helper.h"
#include "ns3/olsr-helper.h"
#include "ns3/aodv-helper.h"
#include "ns3/ipv4-global-routing-helper.h"
#include "src/core/model/string.h"
#include "myapp.h"

#include <iostream>
#include <sstream>
#include <fstream>
// Needed for ping and test
#include "ns3/test.h"
#include "ns3/abort.h"
#include "ns3/v4ping.h"
#include "ns3/config.h"
#include "ns3/names.h"
#include "src/core/model/log.h"

using namespace ns3;

NS_LOG_COMPONENT_DEFINE ("iMesh-handover");


static void
SetPosition (Ptr<Node> node, double x, double y)
{
  Ptr<MobilityModel> mobility = node->GetObject<MobilityModel> ();
  Vector pos = mobility->GetPosition();
  pos.x = x;
  pos.y = y;
  mobility->SetPosition(pos);
}


class MeshTest
{
public:

  /// Init test
  MeshTest ();
  /// Configure test from command line arguments
  void Configure (int argc, char ** argv);
  /// Run test
  int Run ();
private:
  int m_xSize;
  int m_ySize;
  double m_step;
  double m_randomStart;
  double m_totalTime;
  double m_packetInterval;
  uint16_t m_packetSize;
  uint32_t m_nIfaces;
  bool m_chan;
  bool m_pcap;
  std::string m_stack;
  std::string m_root;

  NodeContainer nc_all; // Contains every node (starting with internet node, access nodes and then mesh nodes
  NodeContainer nc_mesh; // Contains mesh nodes
  NodeContainer nc_wireless; // Contains access and mesh nodes
  NodeContainer nc_internet; // Contains internet nodes
  NodeContainer nc_destination; // Contains nodes with sink for apps (internet and mesh nodes)

  /// List of all mesh point devices
  NetDeviceContainer meshDevices;
  NetDeviceContainer internetDevices;

  //Addresses of meshInterfaces:
  Ipv4InterfaceContainer meshInterfaces;
  Ipv4InterfaceContainer p2pInterfaces; /// Needed for n0-----n1

  // MeshHelper. Report is not static methods
  MeshHelper meshHelper;
  PointToPointHelper p2pHelper;

  MobilityHelper mobility;
  
private:
  /// Create nodes and setup their mobility
  void CreateNodes ();
  /// Install internet m_stack on nodes
  void InstallInternetStack ();
  /// Install applications
  void InstallApplication ();
  /// Print mesh devices diagnostics
  void Report ();
  

};

MeshTest::MeshTest () :
m_xSize (3),
m_ySize (3),
m_step (100.0),
m_randomStart (0.1),
m_totalTime (30.0),
m_packetInterval (1.0),
m_packetSize (1024),
m_nIfaces (1),
m_chan (true),
m_pcap (true), 
m_stack ("ns3::Dot11sStack"),
m_root ("ff:ff:ff:ff:ff:ff") { }

void
MeshTest::Configure (int argc, char *argv[])
{
  CommandLine cmd;
  cmd.AddValue ("x-size", "Number of nodes in a row grid. [6]", m_xSize);
  cmd.AddValue ("y-size", "Number of rows in a grid. [6]", m_ySize);
  cmd.AddValue ("step", "Size of edge in our grid, meters. [100 m]", m_step);
  /*
   * As soon as starting node means that it sends a beacon,
   * simultaneous start is not good.
   */
  cmd.AddValue ("start", "Maximum random start delay, seconds. [0.1 s]", m_randomStart);
  cmd.AddValue ("time", "Simulation time, seconds [100 s]", m_totalTime);
  cmd.AddValue ("packet-interval", "Interval between packets in UDP ping, seconds [0.001 s]", m_packetInterval);
  cmd.AddValue ("packet-size", "Size of packets in UDP ping", m_packetSize);
  cmd.AddValue ("meshInterfaces", "Number of radio interfaces used by each meshHelper point. [1]", m_nIfaces);
  cmd.AddValue ("channels", "Use different frequency channels for different meshInterfaces. [0]", m_chan);
  cmd.AddValue ("pcap", "Enable PCAP traces on meshInterfaces. [0]", m_pcap);
  cmd.AddValue ("stack", "Type of protocol stack. ns3::Dot11sStack by default", m_stack);
  cmd.AddValue ("root", "Mac address of root meshHelper point in HWMP", m_root);

  cmd.Parse (argc, argv);
  NS_LOG_DEBUG ("Grid:" << m_xSize << "*" << m_ySize);
  NS_LOG_DEBUG ("Simulation time: " << m_totalTime << " s");
  
  LogComponentEnable ("UdpEchoClientApplication", LOG_LEVEL_INFO);
  LogComponentEnable ("UdpEchoServerApplication", LOG_LEVEL_INFO);
}

void
MeshTest::CreateNodes ()
{

  // Node container creation (all node containers starts with "nc_")

  /*
   * Create m_ySize*m_xSize stations to form a grid topology
   */
  nc_all.Create (2);

  nc_mesh.Create (m_ySize * m_xSize);

  /// Needed to add mesh nodes and wireless nodes to the internet nodes
  nc_all.Add (nc_mesh);
  nc_mesh.Add (nc_all.Get (1)); /// n1---{meshHelper nodes}
  nc_wireless.Add (nc_all.Get (1));
  nc_wireless.Add (nc_mesh);
  nc_internet.Add (nc_all.Get (0));
  nc_internet.Add (nc_all.Get (1));
  nc_destination.Add (nc_all.Get (0));
  nc_destination.Add (nc_mesh);

  //Create P2P links between n0 <-> n1 (all devices starts with "de_")

  p2pHelper.SetDeviceAttribute ("DataRate", StringValue ("1Mbps"));
  p2pHelper.SetChannelAttribute ("Delay", StringValue ("10ms"));
  internetDevices = p2pHelper.Install (nc_internet);

  // Configure YansWifiChannel
  YansWifiPhyHelper wifiPhy = YansWifiPhyHelper::Default ();
  YansWifiChannelHelper wifiChannel = YansWifiChannelHelper::Default ();
  wifiPhy.SetChannel (wifiChannel.Create ());
  /*
   * Create mesh helper and set stack installer to it
   * Stack installer creates all needed protocols and install them to
   * meshHelper point device
   */
  meshHelper = MeshHelper::Default ();
  if (!Mac48Address (m_root.c_str ()).IsBroadcast ())
    {
      meshHelper.SetStackInstaller (m_stack, "Root", Mac48AddressValue (Mac48Address (m_root.c_str ())));
    }
  else
    {
      //If root is not set, we do not use "Root" attribute, because it
      //is specified only for 11s
      meshHelper.SetStackInstaller (m_stack);
    }
  if (m_chan)
    {
      meshHelper.SetSpreadInterfaceChannels (MeshHelper::SPREAD_CHANNELS);
    }
  else
    {
      meshHelper.SetSpreadInterfaceChannels (MeshHelper::ZERO_CHANNEL);
    }
  meshHelper.SetMacType ("RandomStart", TimeValue (Seconds (m_randomStart)));
  // Set number of interfaces - default is single-interface meshHelper point
  meshHelper.SetNumberOfInterfaces (m_nIfaces);
  // Install protocols and return container if MeshPointDevices
  meshDevices = meshHelper.Install (wifiPhy, nc_mesh);
  // Setup mobility - static grid topology
 
#if 0
  MobilityHelper mobilityHelper;
  mobilityHelper.SetPositionAllocator ("ns3::GridPositionAllocator",
                                       "MinX", DoubleValue (0.0),
                                       "MinY", DoubleValue (0.0),
                                       "DeltaX", DoubleValue (m_step),
                                       "DeltaY", DoubleValue (m_step),
                                       "GridWidth", UintegerValue (m_xSize),
                                       "LayoutType", StringValue ("RowFirst"));
  mobilityHelper.SetMobilityModel ("ns3::RandomWalk2dMobilityModel", "Bounds", RectangleValue(Rectangle(-1000, 1000, -1000, 1000)));
  mobilityHelper.Install (nc_mesh);
#endif
 
#if 0
  MobilityHelper mobility;
  Ptr<ListPositionAllocator> positionAlloc = CreateObject <ListPositionAllocator>();
  
  
  positionAlloc ->Add(Vector(0, 0, 0)); // node1
  positionAlloc ->Add(Vector(37, 0, 0)); // node2
  positionAlloc ->Add(Vector(75, 75, 0)); // node3
  positionAlloc ->Add(Vector(150, 75, 0)); // node0
  positionAlloc ->Add(Vector(225, 75, 0)); // node1
  positionAlloc ->Add(Vector(75, 150, 0)); // node2
  positionAlloc ->Add(Vector(150, 150, 0)); // node3
  positionAlloc ->Add(Vector(225, 150, 0)); // node0
  positionAlloc ->Add(Vector(75, 0, 0)); // node1
  positionAlloc ->Add(Vector(150, 0, 0)); // node2
  positionAlloc ->Add(Vector(225, 0, 0)); // node3
  
  mobility.SetPositionAllocator(positionAlloc);
  mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
  mobility.Install(nc_all);
  
  Simulator::Schedule (Seconds (15.0), &SetPosition, nc_all.Get (3), 37.0, 75.0);
  
  
  AnimationInterface animation ("iMesh-handover.xml");
#endif 
  
  
  
  if (m_pcap)
    wifiPhy.EnablePcapAll (std::string ("mp-"));

  /*AnimationInterface animation("iMesh.xml");

  animation.SetConstantPosition(nc_internet.Get(0), -200.0, 100.0);
  animation.SetConstantPosition(nc_internet.Get(1), -100.0, 100.0);*/
}

void
MeshTest::InstallInternetStack ()
{

  InternetStackHelper internetStackHelper;

  OlsrHelper routingProtocol;
  internetStackHelper.SetRoutingHelper (routingProtocol);

  internetStackHelper.Install (nc_mesh);
  internetStackHelper.Install (nc_all.Get (0)); /// Setting up protocol stack on node 0

  Ipv4AddressHelper meshAddress;
  meshAddress.SetBase ("10.1.1.0", "255.255.255.0");
  meshInterfaces = meshAddress.Assign (meshDevices);

  Ipv4AddressHelper p2pAddress;
  p2pAddress.SetBase ("1.1.1.0", "255.255.255.0");
  p2pInterfaces = p2pAddress.Assign (internetDevices);

}

void
MeshTest::InstallApplication ()
{

  UdpEchoServerHelper echoServer (9);
  ApplicationContainer serverApps = echoServer.Install (nc_all.Get (0));
  serverApps.Start (Seconds (0.0));
  serverApps.Stop (Seconds (m_totalTime));

  UdpEchoClientHelper echoClient (p2pInterfaces.GetAddress (0), 9);
  //echoClient.SetAttribute ("MaxPackets", UintegerValue ((uint32_t) (m_totalTime * (1 / m_packetInterval))));
  echoClient.SetAttribute ("MaxPackets", UintegerValue (20));
  echoClient.SetAttribute ("Interval", TimeValue (Seconds (m_packetInterval)));
  echoClient.SetAttribute ("PacketSize", UintegerValue (m_packetSize));

  ApplicationContainer clientApps1 = echoClient.Install (nc_mesh.Get (m_xSize * m_ySize - 1));
  //ApplicationContainer clientApps2 = echoClient.Install (nc_mesh.Get (m_xSize * m_ySize - 2));



  clientApps1.Start (Seconds (0.0));
  clientApps1.Stop (Seconds (m_totalTime));

  //  clientApps2.Start (Seconds (12));
  //  clientApps2.Stop (Seconds (m_totalTime));

  /*for (tmp_x = 2; tmp_x < m_xSize * m_ySize + 2; tmp_x++)
  {
    sprintf (tmp_char, "%d-STA", tmp_x);
    AnimationInterface::SetNodeDescription (nc_all.Get (tmp_x), tmp_char);
  }
  AnimationInterface::SetNodeDescription (nc_all.Get (0), "0-Internet");
  AnimationInterface::SetNodeDescription (nc_all.Get (1), "1-AP");
  AnimationInterface::SetNodeColor (nc_mesh, 0, 255, 0);
  AnimationInterface::SetNodeColor (nc_internet.Get (0), 255, 0, 0);
  AnimationInterface::SetNodeColor (nc_internet.Get (1), 0, 0, 255);

   */



}

int
MeshTest::Run ()
{
  CreateNodes ();
  InstallInternetStack ();
  InstallApplication ();


  Ptr<ListPositionAllocator> positionAlloc = CreateObject <ListPositionAllocator>();
  
  
  positionAlloc ->Add(Vector(0, 0, 0)); // node1
  positionAlloc ->Add(Vector(37, 0, 0)); // node2
  positionAlloc ->Add(Vector(75, 75, 0)); // node3
  positionAlloc ->Add(Vector(150, 75, 0)); // node0
  positionAlloc ->Add(Vector(225, 75, 0)); // node1
  positionAlloc ->Add(Vector(75, 150, 0)); // node2
  positionAlloc ->Add(Vector(150, 150, 0)); // node3
  positionAlloc ->Add(Vector(225, 150, 0)); // node0
  positionAlloc ->Add(Vector(75, 0, 0)); // node1
  positionAlloc ->Add(Vector(150, 0, 0)); // node2
  positionAlloc ->Add(Vector(225, 0, 0)); // node3
  
  mobility.SetPositionAllocator(positionAlloc);
  mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
  mobility.Install(nc_all);
  
  Simulator::Schedule (Seconds (12.0), &SetPosition, nc_mesh.Get (m_xSize * m_ySize - 1), 37.0, 75.0);
  
  Simulator::Stop (Seconds (m_totalTime));
  AnimationInterface animation ("iMesh-handover.xml");
  
  animation.EnablePacketMetadata (false);
  animation.EnableIpv4RouteTracking ("mesh-handover-route.xml", Seconds (0), Seconds (50), Seconds (100));


//  animation.SetConstantPosition (nc_all.Get (0), 0.0, 0.0);
//  animation.SetConstantPosition (nc_internet.Get (1), 37.0, 0.0);
//  animation.SetConstantPosition (nc_mesh.Get (0), 75.0, 75.0);
//  animation.SetConstantPosition (nc_mesh.Get (1), 150.0, 75.0);
//  animation.SetConstantPosition (nc_mesh.Get (2), 225.0, 75.0);
//  animation.SetConstantPosition (nc_mesh.Get (3), 75.0, 150.0);
//  animation.SetConstantPosition (nc_mesh.Get (4), 150.0, 150.0);
//  animation.SetConstantPosition (nc_mesh.Get (5), 225.0, 150.0);
//  animation.SetConstantPosition (nc_mesh.Get (6), 75.0, 0.0);
//  animation.SetConstantPosition (nc_mesh.Get (7), 150.0, 0.0);
//  animation.SetConstantPosition (nc_mesh.Get (8), 225.0, 0.0);

  //animation.EnablePacketMetadata(false);
  //animation.EnableIpv4RouteTracking ("iMesh-handover.xml", Seconds (0), Seconds (m_totalTime), Seconds (0.25));





  //Simulator::Schedule (Seconds (m_totalTime), &MeshTest::Report, this);
  //Simulator::Stop (Seconds (m_totalTime));
  Simulator::Run ();
  Simulator::Destroy ();

  return 0;
}

void
MeshTest::Report () {
    unsigned n (0);
    for (NetDeviceContainer::Iterator i = meshDevices.Begin (); i != meshDevices.End (); ++i, ++n)
      {
        std::ostringstream os;
        os << "mp-report-handover-true-" << n << ".xml";
        std::cerr << "Printing meshHelper point device #" << n << " diagnostics to " << os.str () << "\n";
        std::ofstream of;
        of.open (os.str ().c_str ());
        if (!of.is_open ())
          {
            std::cerr << "Error: Can't open file " << os.str () << "\n";
            return;
          }
        meshHelper.Report (*i, of);
        of.close ();
      }
}

int
main (int argc, char *argv[])
{
  ns3::PacketMetadata::Enable ();
  MeshTest t;
  t.Configure (argc, argv);
  return t.Run ();
}