A Discrete-Event Network Simulator
API
mixed-wired-wireless.cc
Go to the documentation of this file.
1 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * This program is free software; you can redistribute it and/or modify
4  * it under the terms of the GNU General Public License version 2 as
5  * published by the Free Software Foundation;
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software
14  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
15  *
16  */
17 
18 //
19 // This ns-3 example demonstrates the use of helper functions to ease
20 // the construction of simulation scenarios.
21 //
22 // The simulation topology consists of a mixed wired and wireless
23 // scenario in which a hierarchical mobility model is used.
24 //
25 // The simulation layout consists of N backbone routers interconnected
26 // by an ad hoc wifi network.
27 // Each backbone router also has a local 802.11 network and is connected
28 // to a local LAN. An additional set of (K-1) nodes are connected to
29 // this backbone. Finally, a local LAN is connected to each router
30 // on the backbone, with L-1 additional hosts.
31 //
32 // The nodes are populated with TCP/IP stacks, and OLSR unicast routing
33 // on the backbone. An example UDP transfer is shown. The simulator
34 // be configured to output tcpdumps or traces from different nodes.
35 //
36 //
37 // +--------------------------------------------------------+
38 // | |
39 // | 802.11 ad hoc, ns-2 mobility |
40 // | |
41 // +--------------------------------------------------------+
42 // | o o o (N backbone routers) |
43 // +--------+ +--------+
44 // wired LAN | mobile | wired LAN | mobile |
45 // -----------| router | -----------| router |
46 // --------- ---------
47 // | |
48 // +----------------+ +----------------+
49 // | 802.11 | | 802.11 |
50 // | infra net | | infra net |
51 // | K-1 hosts | | K-1 hosts |
52 // +----------------+ +----------------+
53 //
54 // We'll send data from the first wired LAN node on the first wired LAN
55 // to the last wireless STA on the last infrastructure net, thereby
56 // causing packets to traverse CSMA to adhoc to infrastructure links
57 //
58 // Note that certain mobility patterns may cause packet forwarding
59 // to fail (if nodes become disconnected)
60 
61 #include "ns3/command-line.h"
62 #include "ns3/string.h"
63 #include "ns3/yans-wifi-helper.h"
64 #include "ns3/ssid.h"
65 #include "ns3/mobility-helper.h"
66 #include "ns3/internet-stack-helper.h"
67 #include "ns3/ipv4-address-helper.h"
68 #include "ns3/on-off-helper.h"
69 #include "ns3/yans-wifi-channel.h"
70 #include "ns3/qos-txop.h"
71 #include "ns3/packet-sink-helper.h"
72 #include "ns3/olsr-helper.h"
73 #include "ns3/csma-helper.h"
74 #include "ns3/animation-interface.h"
75 
76 using namespace ns3;
77 
78 //
79 // Define logging keyword for this file
80 //
81 NS_LOG_COMPONENT_DEFINE ("MixedWireless");
82 
83 //
84 // This function will be used below as a trace sink, if the command-line
85 // argument or default value "useCourseChangeCallback" is set to true
86 //
87 static void
89 {
90  Vector position = model->GetPosition ();
91  std::cout << "CourseChange " << path << " x=" << position.x << ", y=" << position.y << ", z=" << position.z << std::endl;
92 }
93 
94 int
95 main (int argc, char *argv[])
96 {
97  //
98  // First, we declare and initialize a few local variables that control some
99  // simulation parameters.
100  //
101  uint32_t backboneNodes = 10;
102  uint32_t infraNodes = 2;
103  uint32_t lanNodes = 2;
104  uint32_t stopTime = 20;
105  bool useCourseChangeCallback = false;
106 
107  //
108  // Simulation defaults are typically set next, before command line
109  // arguments are parsed.
110  //
111  Config::SetDefault ("ns3::OnOffApplication::PacketSize", StringValue ("1472"));
112  Config::SetDefault ("ns3::OnOffApplication::DataRate", StringValue ("100kb/s"));
113 
114  //
115  // For convenience, we add the local variables to the command line argument
116  // system so that they can be overridden with flags such as
117  // "--backboneNodes=20"
118  //
120  cmd.AddValue ("backboneNodes", "number of backbone nodes", backboneNodes);
121  cmd.AddValue ("infraNodes", "number of leaf nodes", infraNodes);
122  cmd.AddValue ("lanNodes", "number of LAN nodes", lanNodes);
123  cmd.AddValue ("stopTime", "simulation stop time (seconds)", stopTime);
124  cmd.AddValue ("useCourseChangeCallback", "whether to enable course change tracing", useCourseChangeCallback);
125 
126  //
127  // The system global variables and the local values added to the argument
128  // system can be overridden by command line arguments by using this call.
129  //
130  cmd.Parse (argc, argv);
131 
132  if (stopTime < 10)
133  {
134  std::cout << "Use a simulation stop time >= 10 seconds" << std::endl;
135  exit (1);
136  }
138  // //
139  // Construct the backbone //
140  // //
142 
143  //
144  // Create a container to manage the nodes of the adhoc (backbone) network.
145  // Later we'll create the rest of the nodes we'll need.
146  //
147  NodeContainer backbone;
148  backbone.Create (backboneNodes);
149  //
150  // Create the backbone wifi net devices and install them into the nodes in
151  // our container
152  //
155  mac.SetType ("ns3::AdhocWifiMac");
156  wifi.SetRemoteStationManager ("ns3::ConstantRateWifiManager",
157  "DataMode", StringValue ("OfdmRate54Mbps"));
160  wifiPhy.SetChannel (wifiChannel.Create ());
161  NetDeviceContainer backboneDevices = wifi.Install (wifiPhy, mac, backbone);
162 
163  // We enable OLSR (which will be consulted at a higher priority than
164  // the global routing) on the backbone ad hoc nodes
165  NS_LOG_INFO ("Enabling OLSR routing on all backbone nodes");
167  //
168  // Add the IPv4 protocol stack to the nodes in our container
169  //
170  InternetStackHelper internet;
171  internet.SetRoutingHelper (olsr); // has effect on the next Install ()
172  internet.Install (backbone);
173 
174  //
175  // Assign IPv4 addresses to the device drivers (actually to the associated
176  // IPv4 interfaces) we just created.
177  //
178  Ipv4AddressHelper ipAddrs;
179  ipAddrs.SetBase ("192.168.0.0", "255.255.255.0");
180  ipAddrs.Assign (backboneDevices);
181 
182  //
183  // The ad-hoc network nodes need a mobility model so we aggregate one to
184  // each of the nodes we just finished building.
185  //
187  mobility.SetPositionAllocator ("ns3::GridPositionAllocator",
188  "MinX", DoubleValue (20.0),
189  "MinY", DoubleValue (20.0),
190  "DeltaX", DoubleValue (20.0),
191  "DeltaY", DoubleValue (20.0),
192  "GridWidth", UintegerValue (5),
193  "LayoutType", StringValue ("RowFirst"));
194  mobility.SetMobilityModel ("ns3::RandomDirection2dMobilityModel",
195  "Bounds", RectangleValue (Rectangle (-500, 500, -500, 500)),
196  "Speed", StringValue ("ns3::ConstantRandomVariable[Constant=2]"),
197  "Pause", StringValue ("ns3::ConstantRandomVariable[Constant=0.2]"));
198  mobility.Install (backbone);
199 
201  // //
202  // Construct the LANs //
203  // //
205 
206  // Reset the address base-- all of the CSMA networks will be in
207  // the "172.16 address space
208  ipAddrs.SetBase ("172.16.0.0", "255.255.255.0");
209 
210 
211  for (uint32_t i = 0; i < backboneNodes; ++i)
212  {
213  NS_LOG_INFO ("Configuring local area network for backbone node " << i);
214  //
215  // Create a container to manage the nodes of the LAN. We need
216  // two containers here; one with all of the new nodes, and one
217  // with all of the nodes including new and existing nodes
218  //
219  NodeContainer newLanNodes;
220  newLanNodes.Create (lanNodes - 1);
221  // Now, create the container with all nodes on this link
222  NodeContainer lan (backbone.Get (i), newLanNodes);
223  //
224  // Create the CSMA net devices and install them into the nodes in our
225  // collection.
226  //
228  csma.SetChannelAttribute ("DataRate",
229  DataRateValue (DataRate (5000000)));
230  csma.SetChannelAttribute ("Delay", TimeValue (MilliSeconds (2)));
231  NetDeviceContainer lanDevices = csma.Install (lan);
232  //
233  // Add the IPv4 protocol stack to the new LAN nodes
234  //
235  internet.Install (newLanNodes);
236  //
237  // Assign IPv4 addresses to the device drivers (actually to the
238  // associated IPv4 interfaces) we just created.
239  //
240  ipAddrs.Assign (lanDevices);
241  //
242  // Assign a new network prefix for the next LAN, according to the
243  // network mask initialized above
244  //
245  ipAddrs.NewNetwork ();
246  //
247  // The new LAN nodes need a mobility model so we aggregate one
248  // to each of the nodes we just finished building.
249  //
250  MobilityHelper mobilityLan;
251  Ptr<ListPositionAllocator> subnetAlloc =
252  CreateObject<ListPositionAllocator> ();
253  for (uint32_t j = 0; j < newLanNodes.GetN (); ++j)
254  {
255  subnetAlloc->Add (Vector (0.0, j * 10 + 10, 0.0));
256  }
257  mobilityLan.PushReferenceMobilityModel (backbone.Get (i));
258  mobilityLan.SetPositionAllocator (subnetAlloc);
259  mobilityLan.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
260  mobilityLan.Install (newLanNodes);
261  }
262 
264  // //
265  // Construct the mobile networks //
266  // //
268 
269  // Reset the address base-- all of the 802.11 networks will be in
270  // the "10.0" address space
271  ipAddrs.SetBase ("10.0.0.0", "255.255.255.0");
272 
273  for (uint32_t i = 0; i < backboneNodes; ++i)
274  {
275  NS_LOG_INFO ("Configuring wireless network for backbone node " << i);
276  //
277  // Create a container to manage the nodes of the LAN. We need
278  // two containers here; one with all of the new nodes, and one
279  // with all of the nodes including new and existing nodes
280  //
281  NodeContainer stas;
282  stas.Create (infraNodes - 1);
283  // Now, create the container with all nodes on this link
284  NodeContainer infra (backbone.Get (i), stas);
285  //
286  // Create an infrastructure network
287  //
288  WifiHelper wifiInfra;
289  WifiMacHelper macInfra;
290  wifiPhy.SetChannel (wifiChannel.Create ());
291  // Create unique ssids for these networks
292  std::string ssidString ("wifi-infra");
293  std::stringstream ss;
294  ss << i;
295  ssidString += ss.str ();
296  Ssid ssid = Ssid (ssidString);
297  wifiInfra.SetRemoteStationManager ("ns3::ArfWifiManager");
298  // setup stas
299  macInfra.SetType ("ns3::StaWifiMac",
300  "Ssid", SsidValue (ssid));
301  NetDeviceContainer staDevices = wifiInfra.Install (wifiPhy, macInfra, stas);
302  // setup ap.
303  macInfra.SetType ("ns3::ApWifiMac",
304  "Ssid", SsidValue (ssid),
305  "BeaconInterval", TimeValue (Seconds (2.5)));
306  NetDeviceContainer apDevices = wifiInfra.Install (wifiPhy, macInfra, backbone.Get (i));
307  // Collect all of these new devices
308  NetDeviceContainer infraDevices (apDevices, staDevices);
309 
310  // Add the IPv4 protocol stack to the nodes in our container
311  //
312  internet.Install (stas);
313  //
314  // Assign IPv4 addresses to the device drivers (actually to the associated
315  // IPv4 interfaces) we just created.
316  //
317  ipAddrs.Assign (infraDevices);
318  //
319  // Assign a new network prefix for each mobile network, according to
320  // the network mask initialized above
321  //
322  ipAddrs.NewNetwork ();
323  //
324  // The new wireless nodes need a mobility model so we aggregate one
325  // to each of the nodes we just finished building.
326  //
327  Ptr<ListPositionAllocator> subnetAlloc =
328  CreateObject<ListPositionAllocator> ();
329  for (uint32_t j = 0; j < infra.GetN (); ++j)
330  {
331  subnetAlloc->Add (Vector (0.0, j, 0.0));
332  }
333  mobility.PushReferenceMobilityModel (backbone.Get (i));
334  mobility.SetPositionAllocator (subnetAlloc);
335  mobility.SetMobilityModel ("ns3::RandomDirection2dMobilityModel",
336  "Bounds", RectangleValue (Rectangle (-10, 10, -10, 10)),
337  "Speed", StringValue ("ns3::ConstantRandomVariable[Constant=3]"),
338  "Pause", StringValue ("ns3::ConstantRandomVariable[Constant=0.4]"));
339  mobility.Install (stas);
340  }
341 
343  // //
344  // Application configuration //
345  // //
347 
348  // Create the OnOff application to send UDP datagrams of size
349  // 210 bytes at a rate of 10 Kb/s, between two nodes
350  // We'll send data from the first wired LAN node on the first wired LAN
351  // to the last wireless STA on the last infrastructure net, thereby
352  // causing packets to traverse CSMA to adhoc to infrastructure links
353 
354  NS_LOG_INFO ("Create Applications.");
355  uint16_t port = 9; // Discard port (RFC 863)
356 
357  // Let's make sure that the user does not define too few nodes
358  // to make this example work. We need lanNodes > 1 and infraNodes > 1
359  NS_ASSERT (lanNodes > 1 && infraNodes > 1);
360  // We want the source to be the first node created outside of the backbone
361  // Conveniently, the variable "backboneNodes" holds this node index value
362  Ptr<Node> appSource = NodeList::GetNode (backboneNodes);
363  // We want the sink to be the last node created in the topology.
364  uint32_t lastNodeIndex = backboneNodes + backboneNodes * (lanNodes - 1) + backboneNodes * (infraNodes - 1) - 1;
365  Ptr<Node> appSink = NodeList::GetNode (lastNodeIndex);
366  // Let's fetch the IP address of the last node, which is on Ipv4Interface 1
367  Ipv4Address remoteAddr = appSink->GetObject<Ipv4> ()->GetAddress (1, 0).GetLocal ();
368 
369  OnOffHelper onoff ("ns3::UdpSocketFactory",
370  Address (InetSocketAddress (remoteAddr, port)));
371 
372  ApplicationContainer apps = onoff.Install (appSource);
373  apps.Start (Seconds (3));
374  apps.Stop (Seconds (stopTime - 1));
375 
376  // Create a packet sink to receive these packets
377  PacketSinkHelper sink ("ns3::UdpSocketFactory",
379  apps = sink.Install (appSink);
380  apps.Start (Seconds (3));
381 
383  // //
384  // Tracing configuration //
385  // //
387 
388  NS_LOG_INFO ("Configure Tracing.");
390 
391  //
392  // Let's set up some ns-2-like ascii traces, using another helper class
393  //
394  AsciiTraceHelper ascii;
395  Ptr<OutputStreamWrapper> stream = ascii.CreateFileStream ("mixed-wireless.tr");
396  wifiPhy.EnableAsciiAll (stream);
397  csma.EnableAsciiAll (stream);
398  internet.EnableAsciiIpv4All (stream);
399 
400  // Csma captures in non-promiscuous mode
401  csma.EnablePcapAll ("mixed-wireless", false);
402  // pcap captures on the backbone wifi devices
403  wifiPhy.EnablePcap ("mixed-wireless", backboneDevices, false);
404  // pcap trace on the application data sink
405  wifiPhy.EnablePcap ("mixed-wireless", appSink->GetId (), 0);
406 
407  if (useCourseChangeCallback == true)
408  {
409  Config::Connect ("/NodeList/*/$ns3::MobilityModel/CourseChange", MakeCallback (&CourseChangeCallback));
410  }
411 
412  AnimationInterface anim ("mixed-wireless.xml");
413 
415  // //
416  // Run simulation //
417  // //
419 
420  NS_LOG_INFO ("Run Simulation.");
422  Simulator::Run ();
424 }
Ptr< PacketSink > sink
Definition: wifi-tcp.cc:56
holds a vector of ns3::Application pointers.
Manage ASCII trace files for device models.
Definition: trace-helper.h:161
an Inet address class
static Ipv4Address GetAny(void)
Smart pointer class similar to boost::intrusive_ptr.
Definition: ptr.h:73
uint32_t GetId(void) const
Definition: node.cc:107
Hold variables of type string.
Definition: string.h:41
static Ptr< Node > GetNode(uint32_t n)
Definition: node-list.cc:241
Make it easy to create and manage PHY objects for the yans model.
static YansWifiChannelHelper Default(void)
Create a channel helper in a default working state.
#define NS_ASSERT(condition)
At runtime, in debugging builds, if this condition is not true, the program prints the source file...
Definition: assert.h:67
static void Run(void)
Run the simulation.
Definition: simulator.cc:226
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:202
Time MilliSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:1022
aggregate IP/TCP/UDP functionality to existing Nodes.
Helper class that adds OLSR routing to nodes.
Definition: olsr-helper.h:40
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Definition: log.h:278
staDevices
Definition: third.py:96
A helper to make it easier to instantiate an ns3::PacketSinkApplication on a set of nodes...
cmd
Definition: second.py:35
Ptr< OutputStreamWrapper > CreateFileStream(std::string filename, std::ios::openmode filemode=std::ios::out)
Create and initialize an output stream object we&#39;ll use to write the traced bits. ...
static YansWifiPhyHelper Default(void)
Create a phy helper in a default working state.
void PushReferenceMobilityModel(Ptr< Object > reference)
helps to create WifiNetDevice objects
Definition: wifi-helper.h:230
A helper to make it easier to instantiate an ns3::OnOffApplication on a set of nodes.
Definition: on-off-helper.h:42
double stopTime
uint16_t port
Definition: dsdv-manet.cc:45
a polymophic address class
Definition: address.h:90
Ptr< YansWifiChannel > Create(void) const
mobility
Definition: third.py:101
AttributeValue implementation for Rectangle.
Definition: rectangle.h:97
Class for representing data rates.
Definition: data-rate.h:88
void SetChannel(Ptr< YansWifiChannel > channel)
AttributeValue implementation for Time.
Definition: nstime.h:1076
Hold an unsigned integer type.
Definition: uinteger.h:44
ssid
Definition: third.py:93
holds a vector of ns3::NetDevice pointers
mac
Definition: third.py:92
Callback< R > MakeCallback(R(T::*memPtr)(void), OBJ objPtr)
Definition: callback.h:1489
void Start(Time start)
Arrange for all of the Applications in this container to Start() at the Time given as a parameter...
csma
Definition: second.py:63
Parse command-line arguments.
Definition: command-line.h:213
void Connect(std::string path, const CallbackBase &cb)
Definition: config.cc:843
void EnableAsciiIpv4All(std::string prefix)
Enable ascii trace output on all Ipv4 and interface pairs existing in the set of all nodes created in...
static void Destroy(void)
Execute the events scheduled with ScheduleDestroy().
Definition: simulator.cc:190
uint32_t GetN(void) const
Get the number of Ptr<Node> stored in this container.
Access to the IPv4 forwarding table, interfaces, and configuration.
Definition: ipv4.h:76
Ptr< T > GetObject(void) const
Get a pointer to the requested aggregated Object.
Definition: object.h:459
Every class exported by the ns3 library is enclosed in the ns3 namespace.
keep track of a set of node pointers.
void SetMobilityModel(std::string type, std::string n1="", const AttributeValue &v1=EmptyAttributeValue(), std::string n2="", const AttributeValue &v2=EmptyAttributeValue(), std::string n3="", const AttributeValue &v3=EmptyAttributeValue(), std::string n4="", const AttributeValue &v4=EmptyAttributeValue(), std::string n5="", const AttributeValue &v5=EmptyAttributeValue(), std::string n6="", const AttributeValue &v6=EmptyAttributeValue(), std::string n7="", const AttributeValue &v7=EmptyAttributeValue(), std::string n8="", const AttributeValue &v8=EmptyAttributeValue(), std::string n9="", const AttributeValue &v9=EmptyAttributeValue())
manage and create wifi channel objects for the yans model.
create MAC layers for a ns3::WifiNetDevice.
Definition: olsr.py:1
The IEEE 802.11 SSID Information Element.
Definition: ssid.h:35
build a set of CsmaNetDevice objects
Definition: csma-helper.h:46
virtual void SetType(std::string type, std::string n0="", const AttributeValue &v0=EmptyAttributeValue(), std::string n1="", const AttributeValue &v1=EmptyAttributeValue(), std::string n2="", const AttributeValue &v2=EmptyAttributeValue(), std::string n3="", const AttributeValue &v3=EmptyAttributeValue(), std::string n4="", const AttributeValue &v4=EmptyAttributeValue(), std::string n5="", const AttributeValue &v5=EmptyAttributeValue(), std::string n6="", const AttributeValue &v6=EmptyAttributeValue(), std::string n7="", const AttributeValue &v7=EmptyAttributeValue(), std::string n8="", const AttributeValue &v8=EmptyAttributeValue(), std::string n9="", const AttributeValue &v9=EmptyAttributeValue(), std::string n10="", const AttributeValue &v10=EmptyAttributeValue())
void Install(Ptr< Node > node) const
"Layout" a single node according to the current position allocator type.
void Install(std::string nodeName) const
Aggregate implementations of the ns3::Ipv4, ns3::Ipv6, ns3::Udp, and ns3::Tcp classes onto the provid...
Vector GetPosition(void) const
wifi
Definition: third.py:89
Helper class used to assign positions and mobility models to nodes.
Ipv4 addresses are stored in host order in this class.
Definition: ipv4-address.h:40
void Stop(Time stop)
Arrange for all of the Applications in this container to Stop() at the Time given as a parameter...
Ipv4InterfaceContainer Assign(const NetDeviceContainer &c)
Assign IP addresses to the net devices specified in the container based on the current network prefix...
AttributeValue implementation for DataRate.
Definition: data-rate.h:242
static void Stop(void)
Tell the Simulator the calling event should be the last one executed.
Definition: simulator.cc:234
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1014
AttributeValue implementation for Ssid.
Definition: ssid.h:110
void SetDefault(std::string name, const AttributeValue &value)
Definition: config.cc:782
void Add(Vector v)
Add a position to the list of positions.
Interface to network animator.
Ptr< Node > Get(uint32_t i) const
Get the Ptr<Node> stored in this container at a given index.
Ipv4Address NewNetwork(void)
Increment the network number and reset the IP address counter to the base value provided in the SetBa...
apDevices
Definition: third.py:99
A helper class to make life easier while doing simple IPv4 address assignment in scripts.
void EnableAsciiAll(std::string prefix)
Enable ascii trace output on each device (which is of the appropriate type) in the set of all nodes c...
void Create(uint32_t n)
Create n nodes and append pointers to them to the end of this NodeContainer.
void EnablePcap(std::string prefix, Ptr< NetDevice > nd, bool promiscuous=false, bool explicitFilename=false)
Enable pcap output the indicated net device.
void SetPositionAllocator(Ptr< PositionAllocator > allocator)
Set the position allocator which will be used to allocate the initial position of every node initiali...
This class can be used to hold variables of floating point type such as &#39;double&#39; or &#39;float&#39;...
Definition: double.h:41
a 2d rectangle
Definition: rectangle.h:34
void SetRoutingHelper(const Ipv4RoutingHelper &routing)
void SetBase(Ipv4Address network, Ipv4Mask mask, Ipv4Address base="0.0.0.1")
Set the base network number, network mask and base address.
static void CourseChangeCallback(std::string path, Ptr< const MobilityModel > model)