Program 19:: Program to simulator Mesh Topology

/* -*- 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>

*

*

* By default this script creates m_xSize * m_ySize square grid topology with

* IEEE802.11s stack installed at each node with peering management

* and HWMP protocol.

* The side of the square cell is defined by m_step parameter.

* When topology is created, UDP ping is installed to opposite corners

* by diagonals. packet size of the UDP ping and interval between two

* successive packets is configurable.

*

* m_xSize * step

* |< >|

* step

* |<--->|

* * --- * --- * <---Ping sink _

* | \ | / |  ^

* | \ | / |  |

* * --- * --- * m_ySize * step |

* | / | \ |  |

* | / | \ |  |

* * --- * --- * _

* ^ Ping source

*

* See also MeshTest::Configure to read more about configurable

* parameters.

*/

#include <iostream> 
#include <sstream> 
#include <fstream>

#include “ns3/core-module.h” 
#include “ns3/internet-module.h” 
#include “ns3/network-module.h” 
#include “ns3/applications-module.h” 
#include “ns3/mesh-module.h” 
#include “ns3/mobility-module.h” 
#include “ns3/mesh-helper.h” 
#include “ns3/yans-wifi-helper.h” 
#include “ns3/netanim-module.h”

using namespace ns3;

NS_LOG_COMPONENT_DEFINE (“TestMeshScript”);

/**

* \ingroup mesh

* \brief MeshTest class

*/

class MeshTest

{

public:

/// Init test MeshTest ();

/**

* Configure test from command line arguments

*

* \param argc command line argument count

* \param argv command line arguments

*/

void Configure (int argc, char ** argv);

/**

* Run test

* \returns the test status

*/

int Run ();

private:

int m_xSize; ///< X size 
int m_ySize; ///< Y size double 
m_step; ///< step

double m_randomStart; ///< random start 
double m_totalTime; ///< total time

double m_packetInterval; ///< packet interval 
uint16_t m_packetSize; ///< packet size 
uint32_t m_nIfaces; ///< number interfaces 
bool m_chan; ///< channel

bool m_pcap; ///< PCAP 
bool m_ascii; ///< ASCII 
std::string m_stack; ///< stack 
std::string m_root; ///< root

/// List of network nodes NodeContainer nodes;

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

/// Addresses of interfaces: Ipv4InterfaceContainer interfaces;

/// MeshHelper. Report is not static methods MeshHelper mesh;

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 (100.0),

m_packetInterval (0.1),

m_packetSize (1024),

m_nIfaces (1), m_chan (true), 
m_pcap (false), m_ascii (false),

m_stack (“ns3::Dot11sStack”), 
m_root (“ff:ff:ff:ff:ff:ff”)

{

}

void

MeshTest::Configure (int argc, char *argv[])

{

CommandLine cmd ( FILE );

cmd.AddValue (“x-size”, “Number of nodes in a row grid”, m_xSize); 
cmd.AddValue (“y-size”, “Number of rows in a grid”, m_ySize); 
cmd.AddValue (“step”, “Size of edge in our grid (meters)”, m_step);

// Avoid starting all mesh nodes at the same time (beacons may collide) cmd.AddValue (“start”, “Maximum random start delay for beacon jitter (sec)”, m_randomStart);

cmd.AddValue (“time”, “Simulation time (sec)”, m_totalTime);

cmd.AddValue (“packet-interval”, “Interval between packets in UDP ping (sec)”, m_packetInterval);

cmd.AddValue (“packet-size”, “Size of packets in UDP ping (bytes)”, m_packetSize);

cmd.AddValue (“interfaces”, “Number of radio interfaces used by each mesh point”, m_nIfaces);

cmd.AddValue (“channels”, “Use different frequency channels for different interfaces”, m_chan);

cmd.AddValue (“pcap”, “Enable PCAP traces on interfaces”, m_pcap); cmd.AddValue (“ascii”, “Enable Ascii traces on interfaces”, m_ascii); 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 (“Grid:” << m_xSize << “*” << m_ySize); 
NS_LOG_DEBUG (“Simulation time: “ << m_totalTime << “ s”); if (m_ascii)

{

PacketMetadata::Enable ();

}

}

void MeshTest::CreateNodes ()

{

/*

* Create m_ySize*m_xSize stations to form a grid topology

*/

nodes.Create (m_ySize*m_xSize);

// 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

* mesh point device

*/

mesh = MeshHelper::Default ();

if (!Mac48Address (m_root.c_str ()).IsBroadcast ())

{

mesh.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 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)));

// Set number of interfaces - default is single-interface mesh point mesh.SetNumberOfInterfaces (m_nIfaces);

// Install protocols and return container if MeshPointDevices meshDevices = mesh.Install (wifiPhy, nodes);

// Setup mobility - static grid topology MobilityHelper mobility;

mobility.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”));

mobility.SetMobilityModel (“ns3::ConstantPositionMobilityModel”); 
mobility.Install (nodes);

if (m_pcap)

wifiPhy.EnablePcapAll (std::string (“mp-”)); if (m_ascii)

{

AsciiTraceHelper ascii;

wifiPhy.EnableAsciiAll (ascii.CreateFileStream (“mesh.tr”));

}

}

void MeshTest::InstallInternetStack ()

{

InternetStackHelper internetStack; 
internetStack.Install (nodes); 
Ipv4AddressHelper address;

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

interfaces = address.Assign (meshDevices);

}

void MeshTest::InstallApplication ()

{

UdpEchoServerHelper echoServer (9);

ApplicationContainer serverApps = echoServer.Install (nodes.Get (0)); 
serverApps.Start (Seconds (0.0));

serverApps.Stop (Seconds (m_totalTime)); 
UdpEchoClientHelper echoClient (interfaces.GetAddress (0), 9); 
echoClient.SetAttribute (“MaxPackets”, UintegerValue ((uint32_t)(m_totalTime*(1/m_packetInterval))));

echoClient.SetAttribute (“Interval”, TimeValue (Seconds (m_packetInterval))); 
echoClient.SetAttribute (“PacketSize”, UintegerValue (m_packetSize)); 
ApplicationContainer clientApps = echoClient.Install (nodes.Get (m_xSize*m_ySize-1));

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

}

int MeshTest::Run ()

{

CreateNodes (); 
InstallInternetStack (); 
InstallApplication ();

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

AnimationInterface anim(“meshdemo.xml”); 
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-” << 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[])

{

MeshTest t;

t.Configure (argc, argv); 
return t.Run ();

}

Output: