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
76using namespace ns3;
77
78//
79// Define logging keyword for this file
80//
81NS_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//
87static 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
94int
95main (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;
159 wifiPhy.SetPcapDataLinkType (WifiPhyHelper::DLT_IEEE802_11_RADIO);
160 YansWifiChannelHelper wifiChannel = YansWifiChannelHelper::Default ();
161 wifiPhy.SetChannel (wifiChannel.Create ());
162 NetDeviceContainer backboneDevices = wifi.Install (wifiPhy, mac, backbone);
163
164 // We enable OLSR (which will be consulted at a higher priority than
165 // the global routing) on the backbone ad hoc nodes
166 NS_LOG_INFO ("Enabling OLSR routing on all backbone nodes");
168 //
169 // Add the IPv4 protocol stack to the nodes in our container
170 //
171 InternetStackHelper internet;
172 internet.SetRoutingHelper (olsr); // has effect on the next Install ()
173 internet.Install (backbone);
174
175 //
176 // Assign IPv4 addresses to the device drivers (actually to the associated
177 // IPv4 interfaces) we just created.
178 //
179 Ipv4AddressHelper ipAddrs;
180 ipAddrs.SetBase ("192.168.0.0", "255.255.255.0");
181 ipAddrs.Assign (backboneDevices);
182
183 //
184 // The ad-hoc network nodes need a mobility model so we aggregate one to
185 // each of the nodes we just finished building.
186 //
188 mobility.SetPositionAllocator ("ns3::GridPositionAllocator",
189 "MinX", DoubleValue (20.0),
190 "MinY", DoubleValue (20.0),
191 "DeltaX", DoubleValue (20.0),
192 "DeltaY", DoubleValue (20.0),
193 "GridWidth", UintegerValue (5),
194 "LayoutType", StringValue ("RowFirst"));
195 mobility.SetMobilityModel ("ns3::RandomDirection2dMobilityModel",
196 "Bounds", RectangleValue (Rectangle (-500, 500, -500, 500)),
197 "Speed", StringValue ("ns3::ConstantRandomVariable[Constant=2]"),
198 "Pause", StringValue ("ns3::ConstantRandomVariable[Constant=0.2]"));
199 mobility.Install (backbone);
200
202 // //
203 // Construct the LANs //
204 // //
206
207 // Reset the address base-- all of the CSMA networks will be in
208 // the "172.16 address space
209 ipAddrs.SetBase ("172.16.0.0", "255.255.255.0");
210
211
212 for (uint32_t i = 0; i < backboneNodes; ++i)
213 {
214 NS_LOG_INFO ("Configuring local area network for backbone node " << i);
215 //
216 // Create a container to manage the nodes of the LAN. We need
217 // two containers here; one with all of the new nodes, and one
218 // with all of the nodes including new and existing nodes
219 //
220 NodeContainer newLanNodes;
221 newLanNodes.Create (lanNodes - 1);
222 // Now, create the container with all nodes on this link
223 NodeContainer lan (backbone.Get (i), newLanNodes);
224 //
225 // Create the CSMA net devices and install them into the nodes in our
226 // collection.
227 //
229 csma.SetChannelAttribute ("DataRate",
230 DataRateValue (DataRate (5000000)));
231 csma.SetChannelAttribute ("Delay", TimeValue (MilliSeconds (2)));
232 NetDeviceContainer lanDevices = csma.Install (lan);
233 //
234 // Add the IPv4 protocol stack to the new LAN nodes
235 //
236 internet.Install (newLanNodes);
237 //
238 // Assign IPv4 addresses to the device drivers (actually to the
239 // associated IPv4 interfaces) we just created.
240 //
241 ipAddrs.Assign (lanDevices);
242 //
243 // Assign a new network prefix for the next LAN, according to the
244 // network mask initialized above
245 //
246 ipAddrs.NewNetwork ();
247 //
248 // The new LAN nodes need a mobility model so we aggregate one
249 // to each of the nodes we just finished building.
250 //
251 MobilityHelper mobilityLan;
252 Ptr<ListPositionAllocator> subnetAlloc =
253 CreateObject<ListPositionAllocator> ();
254 for (uint32_t j = 0; j < newLanNodes.GetN (); ++j)
255 {
256 subnetAlloc->Add (Vector (0.0, j * 10 + 10, 0.0));
257 }
258 mobilityLan.PushReferenceMobilityModel (backbone.Get (i));
259 mobilityLan.SetPositionAllocator (subnetAlloc);
260 mobilityLan.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
261 mobilityLan.Install (newLanNodes);
262 }
263
265 // //
266 // Construct the mobile networks //
267 // //
269
270 // Reset the address base-- all of the 802.11 networks will be in
271 // the "10.0" address space
272 ipAddrs.SetBase ("10.0.0.0", "255.255.255.0");
273
274 for (uint32_t i = 0; i < backboneNodes; ++i)
275 {
276 NS_LOG_INFO ("Configuring wireless network for backbone node " << i);
277 //
278 // Create a container to manage the nodes of the LAN. We need
279 // two containers here; one with all of the new nodes, and one
280 // with all of the nodes including new and existing nodes
281 //
282 NodeContainer stas;
283 stas.Create (infraNodes - 1);
284 // Now, create the container with all nodes on this link
285 NodeContainer infra (backbone.Get (i), stas);
286 //
287 // Create an infrastructure network
288 //
289 WifiHelper wifiInfra;
290 WifiMacHelper macInfra;
291 wifiPhy.SetChannel (wifiChannel.Create ());
292 // Create unique ssids for these networks
293 std::string ssidString ("wifi-infra");
294 std::stringstream ss;
295 ss << i;
296 ssidString += ss.str ();
297 Ssid ssid = Ssid (ssidString);
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
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",
377 InetSocketAddress (Ipv4Address::GetAny (), port));
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.");
420 Simulator::Stop (Seconds (stopTime));
421 Simulator::Run ();
422 Simulator::Destroy ();
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.
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
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
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.
The IEEE 802.11 SSID Information Element.
Definition: ssid.h:36
AttributeValue implementation for Ssid.
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
Vector3D Vector
Vector alias typedef for compatibility with mobility models.
Definition: vector.h:324
helps to create WifiNetDevice objects
Definition: wifi-helper.h:323
virtual NetDeviceContainer Install(const WifiPhyHelper &phy, const WifiMacHelper &mac, NodeContainer::Iterator first, NodeContainer::Iterator last) const
Definition: wifi-helper.cc:787
create MAC layers for a ns3::WifiNetDevice.
void SetType(std::string type, Args &&... args)
void SetPcapDataLinkType(SupportedPcapDataLinkTypes dlt)
Set the data link type of PCAP traces to be used.
Definition: wifi-helper.cc:574
manage and create wifi channel objects for the YANS model.
Ptr< YansWifiChannel > Create(void) const
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:102
ssid
Definition: third.py:97
mac
Definition: third.py:96
wifi
Definition: third.py:99
apDevices
Definition: third.py:105
mobility
Definition: third.py:107
Ptr< PacketSink > sink
Definition: wifi-tcp.cc:56