mixed.cc~

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2008,2009 IITP RAS
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Author: Kirill Andreev <andreev@iitp.ru>

 * 
                
 *               n1                
 *                       
 *
 *
 *   n0         n3                n4          n5
 *
 *
 *
 *              
 *              n2
 *
 *  See also MeshTest::Configure to read more about configurable
 *  parameters.
 */
#include "ns3/core-module.h"
#include "ns3/mobility-module.h" 
#include "ns3/flow-monitor-module.h" 
#include "ns3/wifi-module.h" 
#include "ns3/mesh-module.h" 
#include "ns3/mesh-helper.h" 
#include "ns3/wifi-phy.h"
#include "ns3/random-variable-stream.h"
#include "ns3/netanim-module.h"
#include "ns3/core-module.h"
#include "ns3/internet-module.h"
#include "ns3/network-module.h"
#include "ns3/applications-module.h"
#include "ns3/v4ping-helper.h"
#include "ns3/flow-monitor-helper.h"
#include <iostream>
#include <sstream>
#include <fstream>

using namespace ns3;

NS_LOG_COMPONENT_DEFINE ("TestMeshScript");

class MeshTest
{
public:
  MeshTest ();
  void Configure (int argc, char ** argv);
  /// Run test
  int Run ();
private:
  double    m_randomStart;
  double    m_totalTime;
  double    m_packetInterval;
  uint16_t  m_packetSize;
  uint32_t  m_nIfaces;
  bool      m_chan;
  std::string m_stack;
  std::string m_root;

/////////////for mesh nodes///////////////////////
  NodeContainer nodes;
  NetDeviceContainer meshDevices;
  Ipv4InterfaceContainer interfaces;
  MeshHelper mesh;

///for local 802.11 wifi nodes /////////////////


  NodeContainer wifiStaNode;
  NodeContainer wifiApNode;
  NetDeviceContainer staDevice;
  NetDeviceContainer apDevice;
  Ipv4InterfaceContainer staNodeInterface;
  Ipv4InterfaceContainer apNodeInterface;
 
private:

  void CreateNodes ();
  void InstallInternetStack ();
  void InstallApplication ();
  void Report ();
};
MeshTest::MeshTest () :
  m_randomStart (0.1),
  m_totalTime (100.0),
  m_packetInterval (0.1),
  m_packetSize (1024),
  m_nIfaces (1),
  m_chan (true),
  m_stack ("ns3::Dot11sStack"),
  m_root ("ff:ff:ff:ff:ff:ff")
{
}
void
MeshTest::Configure (int argc, char *argv[])
{
  CommandLine cmd;
  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 ("interfaces", "Number of radio interfaces used by each mesh point. [1]", m_nIfaces);
  cmd.AddValue ("channels",   "Use different frequency channels for different interfaces. [0]", m_chan);
  cmd.AddValue ("stack",  "Type of protocol stack. ns3::Dot11sStack by default", m_stack);
  cmd.AddValue ("root", "Mac address of root mesh point in HWMP", m_root);
  cmd.Parse (argc, argv);
  NS_LOG_DEBUG ("Simulation time: " << m_totalTime << " s");
}



void
MeshTest::CreateNodes ()
{ 
  

/////////for mesh node /////////////////

  nodes.Create (5);   //created 5 mesh node

  YansWifiPhyHelper wifiPhy = YansWifiPhyHelper::Default ();
  YansWifiChannelHelper wifiChannel = YansWifiChannelHelper::Default ();
  wifiPhy.SetChannel (wifiChannel.Create ());
  mesh = MeshHelper::Default ();
  if (!Mac48Address (m_root.c_str ()).IsBroadcast ())
    {
      mesh.SetStackInstaller (m_stack, "Root", Mac48AddressValue (Mac48Address (m_root.c_str ())));
    }
  else
    {
      mesh.SetStackInstaller (m_stack);
    }
  if (m_chan)
    {
      mesh.SetSpreadInterfaceChannels (MeshHelper::SPREAD_CHANNELS);
    }
  else
    {
      mesh.SetSpreadInterfaceChannels (MeshHelper::ZERO_CHANNEL);
    }
  mesh.SetMacType ("RandomStart", TimeValue (Seconds (m_randomStart)));
  mesh.SetNumberOfInterfaces (m_nIfaces);
  // Install protocols and return container if MeshPointDevices
  meshDevices = mesh.Install (wifiPhy, nodes);
  // Setup mobility - static grid topology

  MobilityHelper mobility; 
  Ptr<ListPositionAllocator> positionAlloc = 
  CreateObject<ListPositionAllocator> (); 
  positionAlloc->Add (Vector (0.0, 95.0, 0.0)); 
  positionAlloc->Add (Vector (95.0, 0.0, 0.0)); 
  positionAlloc->Add (Vector (95.0, 190.0, 0.0)); 
  positionAlloc->Add (Vector (95.0, 95.0, 0.0)); 
  //positionAlloc->Add (Vector (200.0, 95.0, 0.0)); 
  mobility.SetPositionAllocator (positionAlloc); 
  mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel"); 
  mobility.Install (nodes); 

///////////////////////////////////////////////////////////////////////
  wifiPhy.EnablePcapAll("pcap/mixed");





 ///////////////////for local 802.11 wifi network/////////////////
  wifiStaNode.Create (1);
      //NodeContainer wifiApNode;
  wifiApNode=nodes.Get(4);
  YansWifiChannelHelper channel = YansWifiChannelHelper::Default ();
  YansWifiPhyHelper phy = YansWifiPhyHelper::Default ();
  phy.SetChannel (channel.Create ());
  phy.Set ("ShortGuardEnabled", BooleanValue (false));
  WifiHelper wifi; 
  wifi.SetStandard (WIFI_PHY_STANDARD_80211n_5GHZ);
  HtWifiMacHelper mac = HtWifiMacHelper::Default ();
  Ssid ssid = Ssid ("ns380211n");
   //double datarate = 0;
  StringValue DataRate;
  DataRate = StringValue ("OfdmRate27MbpsBW10MHz");
  //datarate = 26;
  wifi.SetRemoteStationManager ("ns3::ConstantRateWifiManager","DataMode", DataRate, "ControlMode", DataRate);
  mac.SetType ("ns3::StaWifiMac","Ssid", SsidValue (ssid),"ActiveProbing", BooleanValue (false));
  staDevice = wifi.Install (phy, mac, wifiStaNode);
  mac.SetType ("ns3::ApWifiMac","Ssid", SsidValue (ssid));
  apDevice = wifi.Install (phy, mac, wifiApNode);

      // mobility.
  MobilityHelper mobility_wifi;
  Ptr<ListPositionAllocator> positionAlloc_wifi = CreateObject<ListPositionAllocator> ();
  positionAlloc_wifi->Add (Vector (110.0, 95.0, 0.0));
  positionAlloc_wifi->Add (Vector (120, 95.0, 0.0));
  mobility_wifi.SetPositionAllocator (positionAlloc_wifi);
  mobility_wifi.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
  mobility_wifi.Install (wifiApNode);
  mobility_wifi.Install (wifiStaNode);
///////////////////////////////////////////////////////////////////////////
  phy.EnablePcapAll("pcap/mixed");
      
}

void
MeshTest::InstallInternetStack ()
{

//////////for mesh node ///////////////////////////////
  InternetStackHelper internetStack;
  internetStack.Install (nodes);
  Ipv4AddressHelper address;
  address.SetBase ("10.1.1.0", "255.255.255.0");
  interfaces = address.Assign (meshDevices);
//////////////////////////////////////////////////////




///////////////////for local 802.11 wifi network/////////////////
  InternetStackHelper stack;
  stack.Install (wifiStaNode);
  Ipv4AddressHelper address_wifi;
  address_wifi.SetBase ("192.168.1.0", "255.255.255.0");
  staNodeInterface = address_wifi.Assign (staDevice);
  apNodeInterface = address_wifi.Assign (apDevice);
////////////////////////////////////////////////////////////////

}
void
MeshTest::InstallApplication ()
{
 
   //V4PingHelper ping2 (interfaces.GetAddress(0));
   V4PingHelper ping2 (staNodeInterface.GetAddress(0));
  ping2.SetAttribute ("Verbose", BooleanValue (true));
  ping2.SetAttribute ("Interval", TimeValue (Seconds (1.0)));
  ApplicationContainer appPingInternet2 = ping2.Install (nodes.Get(2));
  appPingInternet2.Start (Seconds (0));
  appPingInternet2.Stop (Seconds (98 - 1));

}
int
MeshTest::Run ()
{
  CreateNodes ();
  InstallInternetStack ();
  InstallApplication ();
  Simulator::Schedule (Seconds (m_totalTime), &MeshTest::Report, this);

  Ipv4GlobalRoutingHelper::PopulateRoutingTables ();
  AnimationInterface anim("xml/mixed.xml");

/////flow monitor 
  FlowMonitorHelper flowmon; 
  Ptr<FlowMonitor> monitor = flowmon.InstallAll();
  Simulator::Stop (Seconds (m_totalTime)); 

  
  Simulator::Run (); 
  monitor->SerializeToXmlFile("topology.xml",true,true); 
 // 10. 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 i =stats.begin (); i != stats.end (); ++i) 
  { 
       
       Ipv4FlowClassifier::FiveTuple t = classifier->FindFlow (i->first); 
       std::cout << "Flow " << i->first << " (" << t.sourceAddress<< " -> " << t.destinationAddress << ")\n"; 
       std::cout << " Tx Bytes:   " << i->second.txBytes << "\n"; 
       std::cout << "  Rx Bytes:   " << i->second.rxBytes << "\n"; 
       std::cout << "  Throughput: " << i->second.rxBytes * 8.0 / 1024 / 1024  << " Mbps\n"; 
                
   } 
  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-" << n << ".xml";
      //std::cerr << "Printing mesh 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;
        }
      mesh.Report (*i, of);
      of.close ();
    }
}
int
main (int argc, char *argv[])
{
  ns3::PacketMetadata::Enable ();
  MeshTest t; 
  t.Configure (argc, argv);
  return t.Run ();
}