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  //
119  CommandLine cmd (__FILE__);
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"));
158  YansWifiPhyHelper wifiPhy;
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  NetDeviceContainer apDevices = wifiInfra.Install (wifiPhy, macInfra, backbone.Get (i));
306  // Collect all of these new devices
307  NetDeviceContainer infraDevices (apDevices, staDevices);
308 
309  // Add the IPv4 protocol stack to the nodes in our container
310  //
311  internet.Install (stas);
312  //
313  // Assign IPv4 addresses to the device drivers (actually to the associated
314  // IPv4 interfaces) we just created.
315  //
316  ipAddrs.Assign (infraDevices);
317  //
318  // Assign a new network prefix for each mobile network, according to
319  // the network mask initialized above
320  //
321  ipAddrs.NewNetwork ();
322  //
323  // The new wireless nodes need a mobility model so we aggregate one
324  // to each of the nodes we just finished building.
325  //
326  Ptr<ListPositionAllocator> subnetAlloc =
327  CreateObject<ListPositionAllocator> ();
328  for (uint32_t j = 0; j < infra.GetN (); ++j)
329  {
330  subnetAlloc->Add (Vector (0.0, j, 0.0));
331  }
332  mobility.PushReferenceMobilityModel (backbone.Get (i));
333  mobility.SetPositionAllocator (subnetAlloc);
334  mobility.SetMobilityModel ("ns3::RandomDirection2dMobilityModel",
335  "Bounds", RectangleValue (Rectangle (-10, 10, -10, 10)),
336  "Speed", StringValue ("ns3::ConstantRandomVariable[Constant=3]"),
337  "Pause", StringValue ("ns3::ConstantRandomVariable[Constant=0.4]"));
338  mobility.Install (stas);
339  }
340 
342  // //
343  // Application configuration //
344  // //
346 
347  // Create the OnOff application to send UDP datagrams of size
348  // 210 bytes at a rate of 10 Kb/s, between two nodes
349  // We'll send data from the first wired LAN node on the first wired LAN
350  // to the last wireless STA on the last infrastructure net, thereby
351  // causing packets to traverse CSMA to adhoc to infrastructure links
352 
353  NS_LOG_INFO ("Create Applications.");
354  uint16_t port = 9; // Discard port (RFC 863)
355 
356  // Let's make sure that the user does not define too few nodes
357  // to make this example work. We need lanNodes > 1 and infraNodes > 1
358  NS_ASSERT (lanNodes > 1 && infraNodes > 1);
359  // We want the source to be the first node created outside of the backbone
360  // Conveniently, the variable "backboneNodes" holds this node index value
361  Ptr<Node> appSource = NodeList::GetNode (backboneNodes);
362  // We want the sink to be the last node created in the topology.
363  uint32_t lastNodeIndex = backboneNodes + backboneNodes * (lanNodes - 1) + backboneNodes * (infraNodes - 1) - 1;
364  Ptr<Node> appSink = NodeList::GetNode (lastNodeIndex);
365  // Let's fetch the IP address of the last node, which is on Ipv4Interface 1
366  Ipv4Address remoteAddr = appSink->GetObject<Ipv4> ()->GetAddress (1, 0).GetLocal ();
367 
368  OnOffHelper onoff ("ns3::UdpSocketFactory",
369  Address (InetSocketAddress (remoteAddr, port)));
370 
371  ApplicationContainer apps = onoff.Install (appSource);
372  apps.Start (Seconds (3));
373  apps.Stop (Seconds (stopTime - 1));
374 
375  // Create a packet sink to receive these packets
376  PacketSinkHelper sink ("ns3::UdpSocketFactory",
378  apps = sink.Install (appSink);
379  apps.Start (Seconds (3));
380 
382  // //
383  // Tracing configuration //
384  // //
386 
387  NS_LOG_INFO ("Configure Tracing.");
389 
390  //
391  // Let's set up some ns-2-like ascii traces, using another helper class
392  //
393  AsciiTraceHelper ascii;
394  Ptr<OutputStreamWrapper> stream = ascii.CreateFileStream ("mixed-wireless.tr");
395  wifiPhy.EnableAsciiAll (stream);
396  csma.EnableAsciiAll (stream);
397  internet.EnableAsciiIpv4All (stream);
398 
399  // Csma captures in non-promiscuous mode
400  csma.EnablePcapAll ("mixed-wireless", false);
401  // pcap captures on the backbone wifi devices
402  wifiPhy.EnablePcap ("mixed-wireless", backboneDevices, false);
403  // pcap trace on the application data sink
404  wifiPhy.EnablePcap ("mixed-wireless", appSink->GetId (), 0);
405 
406  if (useCourseChangeCallback == true)
407  {
408  Config::Connect ("/NodeList/*/$ns3::MobilityModel/CourseChange", MakeCallback (&CourseChangeCallback));
409  }
410 
411  AnimationInterface anim ("mixed-wireless.xml");
412 
414  // //
415  // Run simulation //
416  // //
418 
419  NS_LOG_INFO ("Run Simulation.");
421  Simulator::Run ();
423 }
a polymophic address class
Definition: address.h:91
Interface to network animator.
holds a vector of ns3::Application pointers.
void Start(Time start)
Arrange for all of the Applications in this container to Start() at the Time given as a parameter.
void Stop(Time stop)
Arrange for all of the Applications in this container to Stop() at the Time given as a parameter.
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 EnableAsciiIpv4All(std::string prefix)
Enable ascii trace output on all Ipv4 and interface pairs existing in the set of all nodes created in...
Manage ASCII trace files for device models.
Definition: trace-helper.h:163
Ptr< OutputStreamWrapper > CreateFileStream(std::string filename, std::ios::openmode filemode=std::ios::out)
Create and initialize an output stream object we'll use to write the traced bits.
Parse command-line arguments.
Definition: command-line.h:229
build a set of CsmaNetDevice objects
Definition: csma-helper.h:47
Class for representing data rates.
Definition: data-rate.h:89
AttributeValue implementation for DataRate.
Definition: data-rate.h:298
This class can be used to hold variables of floating point type such as 'double' or 'float'.
Definition: double.h:41
an Inet address class
aggregate IP/TCP/UDP functionality to existing Nodes.
void Install(std::string nodeName) const
Aggregate implementations of the ns3::Ipv4, ns3::Ipv6, ns3::Udp, and ns3::Tcp classes onto the provid...
void SetRoutingHelper(const Ipv4RoutingHelper &routing)
A helper class to make life easier while doing simple IPv4 address assignment in scripts.
Ipv4Address NewNetwork(void)
Increment the network number and reset the IP address counter to the base value provided in the SetBa...
void SetBase(Ipv4Address network, Ipv4Mask mask, Ipv4Address base="0.0.0.1")
Set the base network number, network mask and base address.
Ipv4InterfaceContainer Assign(const NetDeviceContainer &c)
Assign IP addresses to the net devices specified in the container based on the current network prefix...
Ipv4 addresses are stored in host order in this class.
Definition: ipv4-address.h:41
static Ipv4Address GetAny(void)
Access to the IPv4 forwarding table, interfaces, and configuration.
Definition: ipv4.h:77
Helper class used to assign positions and mobility models to nodes.
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())
void Install(Ptr< Node > node) const
"Layout" a single node according to the current position allocator type.
void PushReferenceMobilityModel(Ptr< Object > reference)
void SetPositionAllocator(Ptr< PositionAllocator > allocator)
Set the position allocator which will be used to allocate the initial position of every node initiali...
holds a vector of ns3::NetDevice pointers
keep track of a set of node pointers.
uint32_t GetN(void) const
Get the number of Ptr<Node> stored in this container.
void Create(uint32_t n)
Create n nodes and append pointers to them to the end of this NodeContainer.
Ptr< Node > Get(uint32_t i) const
Get the Ptr<Node> stored in this container at a given index.
uint32_t GetId(void) const
Definition: node.cc:109
static Ptr< Node > GetNode(uint32_t n)
Definition: node-list.cc:241
Ptr< T > GetObject(void) const
Get a pointer to the requested aggregated Object.
Definition: object.h:470
Helper class that adds OLSR routing to nodes.
Definition: olsr-helper.h:41
A helper to make it easier to instantiate an ns3::OnOffApplication on a set of nodes.
Definition: on-off-helper.h:43
A helper to make it easier to instantiate an ns3::PacketSinkApplication on a set of nodes.
void EnablePcap(std::string prefix, Ptr< NetDevice > nd, bool promiscuous=false, bool explicitFilename=false)
Enable pcap output the indicated net device.
Smart pointer class similar to boost::intrusive_ptr.
Definition: ptr.h:74
a 2d rectangle
Definition: rectangle.h:35
AttributeValue implementation for Rectangle.
Definition: rectangle.h:97
static void Stop(void)
Tell the Simulator the calling event should be the last one executed.
Definition: simulator.cc:180
static void Destroy(void)
Execute the events scheduled with ScheduleDestroy().
Definition: simulator.cc:136
static void Run(void)
Run the simulation.
Definition: simulator.cc:172
The IEEE 802.11 SSID Information Element.
Definition: ssid.h:36
AttributeValue implementation for Ssid.
Definition: ssid.h:105
Hold variables of type string.
Definition: string.h:41
AttributeValue implementation for Time.
Definition: nstime.h:1308
Hold an unsigned integer type.
Definition: uinteger.h:44
helps to create WifiNetDevice objects
Definition: wifi-helper.h:274
void SetRemoteStationManager(std::string type, Args &&... args)
Helper function used to set the station manager.
Definition: wifi-helper.h:464
virtual NetDeviceContainer Install(const WifiPhyHelper &phy, const WifiMacHelper &mac, NodeContainer::Iterator first, NodeContainer::Iterator last) const
Definition: wifi-helper.cc:685
create MAC layers for a ns3::WifiNetDevice.
void SetType(std::string type, Args &&... args)
manage and create wifi channel objects for the YANS model.
Ptr< YansWifiChannel > Create(void) const
static YansWifiChannelHelper Default(void)
Create a channel helper in a default working state.
Make it easy to create and manage PHY objects for the YANS model.
void SetChannel(Ptr< YansWifiChannel > channel)
uint16_t port
Definition: dsdv-manet.cc:45
Time stopTime
#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
void SetDefault(std::string name, const AttributeValue &value)
Definition: config.cc:849
void Connect(std::string path, const CallbackBase &cb)
Definition: config.cc:920
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:205
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Definition: log.h:281
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1244
Time MilliSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:1252
static void CourseChangeCallback(std::string path, Ptr< const MobilityModel > model)
Every class exported by the ns3 library is enclosed in the ns3 namespace.
Callback< R, Ts... > MakeCallback(R(T::*memPtr)(Ts...), OBJ objPtr)
Build Callbacks for class method members which take varying numbers of arguments and potentially retu...
Definition: callback.h:1648
Definition: olsr.py:1
csma
Definition: second.py:63
cmd
Definition: second.py:35
staDevices
Definition: third.py:103
ssid
Definition: third.py:100
mac
Definition: third.py:99
wifi
Definition: third.py:96
apDevices
Definition: third.py:106
mobility
Definition: third.py:108
Ptr< PacketSink > sink
Definition: wifi-tcp.cc:56