A Discrete-Event Network Simulator
API
wifi-multi-tos.cc
Go to the documentation of this file.
1/*
2 * Copyright (c) 2016
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 as
6 * published by the Free Software Foundation;
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License
14 * along with this program; if not, write to the Free Software
15 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16 *
17 * Author: Sebastien Deronne <sebastien.deronne@gmail.com>
18 */
19
20#include "ns3/boolean.h"
21#include "ns3/command-line.h"
22#include "ns3/config.h"
23#include "ns3/internet-stack-helper.h"
24#include "ns3/ipv4-address-helper.h"
25#include "ns3/ipv4-global-routing-helper.h"
26#include "ns3/log.h"
27#include "ns3/mobility-helper.h"
28#include "ns3/on-off-helper.h"
29#include "ns3/packet-sink-helper.h"
30#include "ns3/packet-sink.h"
31#include "ns3/ssid.h"
32#include "ns3/string.h"
33#include "ns3/uinteger.h"
34#include "ns3/yans-wifi-channel.h"
35#include "ns3/yans-wifi-helper.h"
36
37// This is a simple example in order to show how to configure an IEEE 802.11n Wi-Fi network
38// with multiple TOS. It outputs the aggregated UDP throughput, which depends on the number of
39// stations, the HT MCS value (0 to 7), the channel width (20 or 40 MHz) and the guard interval
40// (long or short). The user can also specify the distance between the access point and the
41// stations (in meters), and can specify whether RTS/CTS is used or not.
42
43using namespace ns3;
44
45NS_LOG_COMPONENT_DEFINE("WifiMultiTos");
46
47int
48main(int argc, char* argv[])
49{
50 uint32_t nWifi = 4;
51 double simulationTime = 10; // seconds
52 double distance = 1.0; // meters
53 uint16_t mcs = 7;
54 uint8_t channelWidth = 20; // MHz
55 bool useShortGuardInterval = false;
56 bool useRts = false;
57
58 CommandLine cmd(__FILE__);
59 cmd.AddValue("nWifi", "Number of stations", nWifi);
60 cmd.AddValue("distance",
61 "Distance in meters between the stations and the access point",
62 distance);
63 cmd.AddValue("simulationTime", "Simulation time in seconds", simulationTime);
64 cmd.AddValue("useRts", "Enable/disable RTS/CTS", useRts);
65 cmd.AddValue("mcs", "MCS value (0 - 7)", mcs);
66 cmd.AddValue("channelWidth", "Channel width in MHz", channelWidth);
67 cmd.AddValue("useShortGuardInterval",
68 "Enable/disable short guard interval",
69 useShortGuardInterval);
70 cmd.Parse(argc, argv);
71
73 wifiStaNodes.Create(nWifi);
75 wifiApNode.Create(1);
76
77 YansWifiChannelHelper channel = YansWifiChannelHelper::Default();
79 phy.SetChannel(channel.Create());
80
83 wifi.SetStandard(WIFI_STANDARD_80211n);
84
85 std::ostringstream oss;
86 oss << "HtMcs" << mcs;
87 wifi.SetRemoteStationManager("ns3::ConstantRateWifiManager",
88 "DataMode",
89 StringValue(oss.str()),
90 "ControlMode",
91 StringValue(oss.str()),
92 "RtsCtsThreshold",
93 UintegerValue(useRts ? 0 : 999999));
94
95 Ssid ssid = Ssid("ns3-80211n");
96
97 mac.SetType("ns3::StaWifiMac", "Ssid", SsidValue(ssid));
98
100 staDevices = wifi.Install(phy, mac, wifiStaNodes);
101
102 mac.SetType("ns3::ApWifiMac", "Ssid", SsidValue(ssid));
103
104 NetDeviceContainer apDevice;
105 apDevice = wifi.Install(phy, mac, wifiApNode);
106
107 // Set channel width
108 Config::Set("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/ChannelSettings",
109 StringValue("{0, " + std::to_string(channelWidth) + ", BAND_2_4GHZ, 0}"));
110
111 // Set guard interval
113 "/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/HtConfiguration/ShortGuardIntervalSupported",
114 BooleanValue(useShortGuardInterval));
115
116 // mobility
118 Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator>();
119 positionAlloc->Add(Vector(0.0, 0.0, 0.0));
120 for (uint32_t i = 0; i < nWifi; i++)
121 {
122 positionAlloc->Add(Vector(distance, 0.0, 0.0));
123 }
124 mobility.SetPositionAllocator(positionAlloc);
125 mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
126 mobility.Install(wifiApNode);
127 mobility.Install(wifiStaNodes);
128
129 // Internet stack
131 stack.Install(wifiApNode);
132 stack.Install(wifiStaNodes);
134
135 address.SetBase("192.168.1.0", "255.255.255.0");
136 Ipv4InterfaceContainer staNodeInterfaces;
137 Ipv4InterfaceContainer apNodeInterface;
138
139 staNodeInterfaces = address.Assign(staDevices);
140 apNodeInterface = address.Assign(apDevice);
141
142 // Setting applications
143 ApplicationContainer sourceApplications;
144 ApplicationContainer sinkApplications;
145 std::vector<uint8_t> tosValues = {0x70, 0x28, 0xb8, 0xc0}; // AC_BE, AC_BK, AC_VI, AC_VO
146 uint32_t portNumber = 9;
147 for (uint32_t index = 0; index < nWifi; ++index)
148 {
149 for (uint8_t tosValue : tosValues)
150 {
151 auto ipv4 = wifiApNode.Get(0)->GetObject<Ipv4>();
152 const auto address = ipv4->GetAddress(1, 0).GetLocal();
153 InetSocketAddress sinkSocket(address, portNumber++);
154 sinkSocket.SetTos(tosValue);
155 OnOffHelper onOffHelper("ns3::UdpSocketFactory", sinkSocket);
156 onOffHelper.SetAttribute("OnTime",
157 StringValue("ns3::ConstantRandomVariable[Constant=1]"));
158 onOffHelper.SetAttribute("OffTime",
159 StringValue("ns3::ConstantRandomVariable[Constant=0]"));
160 onOffHelper.SetAttribute("DataRate", DataRateValue(50000000 / nWifi));
161 onOffHelper.SetAttribute("PacketSize", UintegerValue(1472)); // bytes
162 sourceApplications.Add(onOffHelper.Install(wifiStaNodes.Get(index)));
163 PacketSinkHelper packetSinkHelper("ns3::UdpSocketFactory", sinkSocket);
164 sinkApplications.Add(packetSinkHelper.Install(wifiApNode.Get(0)));
165 }
166 }
167
168 sinkApplications.Start(Seconds(0.0));
169 sinkApplications.Stop(Seconds(simulationTime + 1));
170 sourceApplications.Start(Seconds(1.0));
171 sourceApplications.Stop(Seconds(simulationTime + 1));
172
173 Ipv4GlobalRoutingHelper::PopulateRoutingTables();
174
175 Simulator::Stop(Seconds(simulationTime + 1));
176 Simulator::Run();
177
178 double throughput = 0;
179 for (uint32_t index = 0; index < sinkApplications.GetN(); ++index)
180 {
181 uint64_t totalPacketsThrough =
182 DynamicCast<PacketSink>(sinkApplications.Get(index))->GetTotalRx();
183 throughput += ((totalPacketsThrough * 8) / (simulationTime * 1000000.0)); // Mbit/s
184 }
185
186 Simulator::Destroy();
187
188 if (throughput > 0)
189 {
190 std::cout << "Aggregated throughput: " << throughput << " Mbit/s" << std::endl;
191 }
192 else
193 {
194 NS_LOG_ERROR("Obtained throughput is 0!");
195 exit(1);
196 }
197
198 return 0;
199}
holds a vector of ns3::Application pointers.
Ptr< Application > Get(uint32_t i) const
Get the Ptr<Application> stored in this container at a given index.
void Start(Time start)
Arrange for all of the Applications in this container to Start() at the Time given as a parameter.
uint32_t GetN() const
Get the number of Ptr<Application> stored in this container.
void Add(ApplicationContainer other)
Append the contents of another ApplicationContainer to the end of this container.
void Stop(Time stop)
Arrange for all of the Applications in this container to Stop() at the Time given as a parameter.
AttributeValue implementation for Boolean.
Definition: boolean.h:37
Parse command-line arguments.
Definition: command-line.h:232
AttributeValue implementation for DataRate.
an Inet address class
aggregate IP/TCP/UDP functionality to existing Nodes.
A helper class to make life easier while doing simple IPv4 address assignment in scripts.
Access to the IPv4 forwarding table, interfaces, and configuration.
Definition: ipv4.h:79
holds a vector of std::pair of Ptr<Ipv4> and interface index.
Helper class used to assign positions and mobility models to nodes.
holds a vector of ns3::NetDevice pointers
keep track of a set of node pointers.
A helper to make it easier to instantiate an ns3::OnOffApplication on a set of nodes.
Definition: on-off-helper.h:44
A helper to make it easier to instantiate an ns3::PacketSinkApplication on a set of nodes.
Smart pointer class similar to boost::intrusive_ptr.
Definition: ptr.h:78
The IEEE 802.11 SSID Information Element.
Definition: ssid.h:36
AttributeValue implementation for Ssid.
Hold variables of type string.
Definition: string.h:42
Hold an unsigned integer type.
Definition: uinteger.h:45
Vector3D Vector
Vector alias typedef for compatibility with mobility models.
Definition: vector.h:324
helps to create WifiNetDevice objects
Definition: wifi-helper.h:325
create MAC layers for a ns3::WifiNetDevice.
manage and create wifi channel objects for the YANS model.
Make it easy to create and manage PHY objects for the YANS model.
void Set(std::string path, const AttributeValue &value)
Definition: config.cc:877
#define NS_LOG_ERROR(msg)
Use NS_LOG to output a message of level LOG_ERROR.
Definition: log.h:254
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:202
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1338
@ WIFI_STANDARD_80211n
address
Definition: first.py:40
stack
Definition: first.py:37
Every class exported by the ns3 library is enclosed in the ns3 namespace.
cmd
Definition: second.py:33
staDevices
Definition: third.py:91
ssid
Definition: third.py:86
channel
Definition: third.py:81
nWifi
Definition: third.py:36
mac
Definition: third.py:85
wifi
Definition: third.py:88
wifiApNode
Definition: third.py:79
mobility
Definition: third.py:96
wifiStaNodes
Definition: third.py:77
phy
Definition: third.py:82