A Discrete-Event Network Simulator
API
wifi-80211e-txop.cc
Go to the documentation of this file.
1/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
2/*
3 * Copyright (c) 2016 Sébastien Deronne
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation;
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 *
18 * Author: Sébastien Deronne <sebastien.deronne@gmail.com>
19 */
20
21#include "ns3/command-line.h"
22#include "ns3/string.h"
23#include "ns3/pointer.h"
24#include "ns3/log.h"
25#include "ns3/yans-wifi-helper.h"
26#include "ns3/ssid.h"
27#include "ns3/mobility-helper.h"
28#include "ns3/internet-stack-helper.h"
29#include "ns3/ipv4-address-helper.h"
30#include "ns3/udp-client-server-helper.h"
31#include "ns3/on-off-helper.h"
32#include "ns3/yans-wifi-channel.h"
33#include "ns3/wifi-net-device.h"
34#include "ns3/qos-txop.h"
35#include "ns3/wifi-mac.h"
36
37// This is an example that illustrates 802.11 QoS for different Access Categories.
38// It defines 4 independent Wi-Fi networks (working on different logical channels
39// on the same "ns3::YansWifiPhy" channel object).
40// Each network contains one access point and one station. Each station continuously
41// transmits data packets to its respective AP.
42//
43// Network topology (numbers in parentheses are channel numbers):
44//
45// BSS A (36) BSS B (40) BSS C (44) BSS D (48)
46// * * * * * * * *
47// | | | | | | | |
48// AP A STA A AP B STA B AP C STA C AP D STA D
49//
50// The configuration is the following on the 4 networks:
51// - STA A sends AC_BE traffic to AP A with default AC_BE TXOP value of 0 (1 MSDU);
52// - STA B sends AC_BE traffic to AP B with non-default AC_BE TXOP of 3.008 ms;
53// - STA C sends AC_VI traffic to AP C with default AC_VI TXOP of 3.008 ms;
54// - STA D sends AC_VI traffic to AP D with non-default AC_VI TXOP value of 0 (1 MSDU);
55//
56// The user can select the distance between the stations and the APs, can enable/disable the RTS/CTS mechanism
57// and can choose the payload size and the simulation duration.
58// Example: ./ns3 run "wifi-80211e-txop --distance=10 --simulationTime=20 --payloadSize=1000"
59//
60// The output prints the throughput measured for the 4 cases/networks described above. When TXOP is enabled, results show
61// increased throughput since the channel is granted for a longer duration. TXOP is enabled by default for AC_VI and AC_VO,
62// so that they can use the channel for a longer duration than AC_BE and AC_BK.
63
64using namespace ns3;
65
66NS_LOG_COMPONENT_DEFINE ("80211eTxop");
67
72{
79 void Trace (Time startTime, Time duration);
81};
82
83void
84TxopDurationTracer::Trace (Time startTime, Time duration)
85{
86 if (duration > m_max)
87 {
88 m_max = duration;
89 }
90}
91
92int main (int argc, char *argv[])
93{
94 uint32_t payloadSize = 1472; //bytes
95 double simulationTime = 10; //seconds
96 double distance = 5; //meters
97 bool enablePcap = 0;
98 bool verifyResults = 0; //used for regression
99
100 CommandLine cmd (__FILE__);
101 cmd.AddValue ("payloadSize", "Payload size in bytes", payloadSize);
102 cmd.AddValue ("simulationTime", "Simulation time in seconds", simulationTime);
103 cmd.AddValue ("distance", "Distance in meters between the station and the access point", distance);
104 cmd.AddValue ("enablePcap", "Enable/disable pcap file generation", enablePcap);
105 cmd.AddValue ("verifyResults", "Enable/disable results verification at the end of the simulation", verifyResults);
106 cmd.Parse (argc, argv);
107
109 wifiStaNodes.Create (4);
110 NodeContainer wifiApNodes;
111 wifiApNodes.Create (4);
112
113 YansWifiChannelHelper channel = YansWifiChannelHelper::Default ();
115 phy.SetPcapDataLinkType (WifiPhyHelper::DLT_IEEE802_11_RADIO);
116 phy.SetChannel (channel.Create ());
117
119 wifi.SetStandard (WIFI_STANDARD_80211a);
120 wifi.SetRemoteStationManager ("ns3::IdealWifiManager");
122
123 NetDeviceContainer staDeviceA, staDeviceB, staDeviceC, staDeviceD, apDeviceA, apDeviceB, apDeviceC, apDeviceD;
124 Ssid ssid;
125
126 //Network A
127 ssid = Ssid ("network-A");
128 phy.Set ("ChannelSettings", StringValue ("{36, 20, BAND_5GHZ, 0}"));
129 mac.SetType ("ns3::StaWifiMac",
130 "QosSupported", BooleanValue (true),
131 "Ssid", SsidValue (ssid));
132 staDeviceA = wifi.Install (phy, mac, wifiStaNodes.Get (0));
133
134 mac.SetType ("ns3::ApWifiMac",
135 "QosSupported", BooleanValue (true),
136 "Ssid", SsidValue (ssid),
137 "EnableBeaconJitter", BooleanValue (false));
138 apDeviceA = wifi.Install (phy, mac, wifiApNodes.Get (0));
139
140 //Network B
141 ssid = Ssid ("network-B");
142 phy.Set ("ChannelSettings", StringValue ("{40, 20, BAND_5GHZ, 0}"));
143 mac.SetType ("ns3::StaWifiMac",
144 "QosSupported", BooleanValue (true),
145 "Ssid", SsidValue (ssid));
146
147 staDeviceB = wifi.Install (phy, mac, wifiStaNodes.Get (1));
148
149 mac.SetType ("ns3::ApWifiMac",
150 "QosSupported", BooleanValue (true),
151 "Ssid", SsidValue (ssid),
152 "EnableBeaconJitter", BooleanValue (false));
153 apDeviceB = wifi.Install (phy, mac, wifiApNodes.Get (1));
154
155 //Modify EDCA configuration (TXOP limit) for AC_BE
156 Ptr<NetDevice> dev = wifiApNodes.Get (1)->GetDevice (0);
157 Ptr<WifiNetDevice> wifi_dev = DynamicCast<WifiNetDevice> (dev);
158 Ptr<WifiMac> wifi_mac = wifi_dev->GetMac ();
159 PointerValue ptr;
160 Ptr<QosTxop> edca;
161 wifi_mac->GetAttribute ("BE_Txop", ptr);
162 edca = ptr.Get<QosTxop> ();
163 edca->SetTxopLimit (MicroSeconds (3008));
164
165 // Trace TXOP duration for BE on STA1
166 dev = wifiStaNodes.Get (1)->GetDevice (0);
167 wifi_dev = DynamicCast<WifiNetDevice> (dev);
168 wifi_mac = wifi_dev->GetMac ();
169 wifi_mac->GetAttribute ("BE_Txop", ptr);
170 edca = ptr.Get<QosTxop> ();
171 TxopDurationTracer beTxopTracer;
172 edca->TraceConnectWithoutContext ("TxopTrace", MakeCallback (&TxopDurationTracer::Trace, &beTxopTracer));
173
174 //Network C
175 ssid = Ssid ("network-C");
176 phy.Set ("ChannelSettings", StringValue ("{44, 20, BAND_5GHZ, 0}"));
177 mac.SetType ("ns3::StaWifiMac",
178 "QosSupported", BooleanValue (true),
179 "Ssid", SsidValue (ssid));
180
181 staDeviceC = wifi.Install (phy, mac, wifiStaNodes.Get (2));
182
183 mac.SetType ("ns3::ApWifiMac",
184 "QosSupported", BooleanValue (true),
185 "Ssid", SsidValue (ssid),
186 "EnableBeaconJitter", BooleanValue (false));
187 apDeviceC = wifi.Install (phy, mac, wifiApNodes.Get (2));
188
189 // Trace TXOP duration for VI on STA2
190 dev = wifiStaNodes.Get (2)->GetDevice (0);
191 wifi_dev = DynamicCast<WifiNetDevice> (dev);
192 wifi_mac = wifi_dev->GetMac ();
193 wifi_mac->GetAttribute ("VI_Txop", ptr);
194 edca = ptr.Get<QosTxop> ();
195 TxopDurationTracer viTxopTracer;
196 edca->TraceConnectWithoutContext ("TxopTrace", MakeCallback (&TxopDurationTracer::Trace, &viTxopTracer));
197
198 //Network D
199 ssid = Ssid ("network-D");
200 phy.Set ("ChannelSettings", StringValue ("{48, 20, BAND_5GHZ, 0}"));
201 mac.SetType ("ns3::StaWifiMac",
202 "QosSupported", BooleanValue (true),
203 "Ssid", SsidValue (ssid));
204
205 staDeviceD = wifi.Install (phy, mac, wifiStaNodes.Get (3));
206
207 mac.SetType ("ns3::ApWifiMac",
208 "QosSupported", BooleanValue (true),
209 "Ssid", SsidValue (ssid),
210 "EnableBeaconJitter", BooleanValue (false));
211 apDeviceD = wifi.Install (phy, mac, wifiApNodes.Get (3));
212
213 //Modify EDCA configuration (TXOP limit) for AC_VO
214 dev = wifiApNodes.Get (3)->GetDevice (0);
215 wifi_dev = DynamicCast<WifiNetDevice> (dev);
216 wifi_mac = wifi_dev->GetMac ();
217 wifi_mac->GetAttribute ("VI_Txop", ptr);
218 edca = ptr.Get<QosTxop> ();
219 edca->SetTxopLimit (MicroSeconds (0));
220
221 /* Setting mobility model */
223 Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator> ();
224 mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
225
226 //Set position for APs
227 positionAlloc->Add (Vector (0.0, 0.0, 0.0));
228 positionAlloc->Add (Vector (10.0, 0.0, 0.0));
229 positionAlloc->Add (Vector (20.0, 0.0, 0.0));
230 positionAlloc->Add (Vector (30.0, 0.0, 0.0));
231 //Set position for STAs
232 positionAlloc->Add (Vector (distance, 0.0, 0.0));
233 positionAlloc->Add (Vector (10 + distance, 0.0, 0.0));
234 positionAlloc->Add (Vector (20 + distance, 0.0, 0.0));
235 positionAlloc->Add (Vector (30 + distance, 0.0, 0.0));
236 //Remark: while we set these positions 10 meters apart, the networks do not interact
237 //and the only variable that affects transmission performance is the distance.
238
239 mobility.SetPositionAllocator (positionAlloc);
240 mobility.Install (wifiApNodes);
241 mobility.Install (wifiStaNodes);
242
243 /* Internet stack */
245 stack.Install (wifiApNodes);
246 stack.Install (wifiStaNodes);
247
249 address.SetBase ("192.168.1.0", "255.255.255.0");
250 Ipv4InterfaceContainer StaInterfaceA;
251 StaInterfaceA = address.Assign (staDeviceA);
252 Ipv4InterfaceContainer ApInterfaceA;
253 ApInterfaceA = address.Assign (apDeviceA);
254
255 address.SetBase ("192.168.2.0", "255.255.255.0");
256 Ipv4InterfaceContainer StaInterfaceB;
257 StaInterfaceB = address.Assign (staDeviceB);
258 Ipv4InterfaceContainer ApInterfaceB;
259 ApInterfaceB = address.Assign (apDeviceB);
260
261 address.SetBase ("192.168.3.0", "255.255.255.0");
262 Ipv4InterfaceContainer StaInterfaceC;
263 StaInterfaceC = address.Assign (staDeviceC);
264 Ipv4InterfaceContainer ApInterfaceC;
265 ApInterfaceC = address.Assign (apDeviceC);
266
267 address.SetBase ("192.168.4.0", "255.255.255.0");
268 Ipv4InterfaceContainer StaInterfaceD;
269 StaInterfaceD = address.Assign (staDeviceD);
270 Ipv4InterfaceContainer ApInterfaceD;
271 ApInterfaceD = address.Assign (apDeviceD);
272
273 /* Setting applications */
274 uint16_t port = 5001;
275 UdpServerHelper serverA (port);
276 ApplicationContainer serverAppA = serverA.Install (wifiApNodes.Get (0));
277 serverAppA.Start (Seconds (0.0));
278 serverAppA.Stop (Seconds (simulationTime + 1));
279
280 InetSocketAddress destA (ApInterfaceA.GetAddress (0), port);
281 destA.SetTos (0x70); //AC_BE
282
283 OnOffHelper clientA ("ns3::UdpSocketFactory", destA);
284 clientA.SetAttribute ("OnTime", StringValue ("ns3::ConstantRandomVariable[Constant=1]"));
285 clientA.SetAttribute ("OffTime", StringValue ("ns3::ConstantRandomVariable[Constant=0]"));
286 clientA.SetAttribute ("DataRate", StringValue ("100000kb/s"));
287 clientA.SetAttribute ("PacketSize", UintegerValue (payloadSize));
288
289 ApplicationContainer clientAppA = clientA.Install (wifiStaNodes.Get (0));
290 clientAppA.Start (Seconds (1.0));
291 clientAppA.Stop (Seconds (simulationTime + 1));
292
293 UdpServerHelper serverB (port);
294 ApplicationContainer serverAppB = serverB.Install (wifiApNodes.Get (1));
295 serverAppB.Start (Seconds (0.0));
296 serverAppB.Stop (Seconds (simulationTime + 1));
297
298 InetSocketAddress destB (ApInterfaceB.GetAddress (0), port);
299 destB.SetTos (0x70); //AC_BE
300
301 OnOffHelper clientB ("ns3::UdpSocketFactory", destB);
302 clientB.SetAttribute ("OnTime", StringValue ("ns3::ConstantRandomVariable[Constant=1]"));
303 clientB.SetAttribute ("OffTime", StringValue ("ns3::ConstantRandomVariable[Constant=0]"));
304 clientB.SetAttribute ("DataRate", StringValue ("100000kb/s"));
305 clientB.SetAttribute ("PacketSize", UintegerValue (payloadSize));
306
307 ApplicationContainer clientAppB = clientB.Install (wifiStaNodes.Get (1));
308 clientAppB.Start (Seconds (1.0));
309 clientAppB.Stop (Seconds (simulationTime + 1));
310
311 UdpServerHelper serverC (port);
312 ApplicationContainer serverAppC = serverC.Install (wifiApNodes.Get (2));
313 serverAppC.Start (Seconds (0.0));
314 serverAppC.Stop (Seconds (simulationTime + 1));
315
316 InetSocketAddress destC (ApInterfaceC.GetAddress (0), port);
317 destC.SetTos (0xb8); //AC_VI
318
319 OnOffHelper clientC ("ns3::UdpSocketFactory", destC);
320 clientC.SetAttribute ("OnTime", StringValue ("ns3::ConstantRandomVariable[Constant=1]"));
321 clientC.SetAttribute ("OffTime", StringValue ("ns3::ConstantRandomVariable[Constant=0]"));
322 clientC.SetAttribute ("DataRate", StringValue ("100000kb/s"));
323 clientC.SetAttribute ("PacketSize", UintegerValue (payloadSize));
324
325 ApplicationContainer clientAppC = clientC.Install (wifiStaNodes.Get (2));
326 clientAppC.Start (Seconds (1.0));
327 clientAppC.Stop (Seconds (simulationTime + 1));
328
329 UdpServerHelper serverD (port);
330 ApplicationContainer serverAppD = serverD.Install (wifiApNodes.Get (3));
331 serverAppD.Start (Seconds (0.0));
332 serverAppD.Stop (Seconds (simulationTime + 1));
333
334 InetSocketAddress destD (ApInterfaceD.GetAddress (0), port);
335 destD.SetTos (0xb8); //AC_VI
336
337 OnOffHelper clientD ("ns3::UdpSocketFactory", destD);
338 clientD.SetAttribute ("OnTime", StringValue ("ns3::ConstantRandomVariable[Constant=1]"));
339 clientD.SetAttribute ("OffTime", StringValue ("ns3::ConstantRandomVariable[Constant=0]"));
340 clientD.SetAttribute ("DataRate", StringValue ("100000kb/s"));
341 clientD.SetAttribute ("PacketSize", UintegerValue (payloadSize));
342
343 ApplicationContainer clientAppD = clientD.Install (wifiStaNodes.Get (3));
344 clientAppD.Start (Seconds (1.0));
345 clientAppD.Stop (Seconds (simulationTime + 1));
346
347 if (enablePcap)
348 {
349 phy.EnablePcap ("AP_A", apDeviceA.Get (0));
350 phy.EnablePcap ("STA_A", staDeviceA.Get (0));
351 phy.EnablePcap ("AP_B", apDeviceB.Get (0));
352 phy.EnablePcap ("STA_B", staDeviceB.Get (0));
353 phy.EnablePcap ("AP_C", apDeviceC.Get (0));
354 phy.EnablePcap ("STA_C", staDeviceC.Get (0));
355 phy.EnablePcap ("AP_D", apDeviceD.Get (0));
356 phy.EnablePcap ("STA_D", staDeviceD.Get (0));
357 }
358
359 Simulator::Stop (Seconds (simulationTime + 1));
360 Simulator::Run ();
361
362 /* Show results */
363 uint64_t totalPacketsThroughA = DynamicCast<UdpServer> (serverAppA.Get (0))->GetReceived ();
364 uint64_t totalPacketsThroughB = DynamicCast<UdpServer> (serverAppB.Get (0))->GetReceived ();
365 uint64_t totalPacketsThroughC = DynamicCast<UdpServer> (serverAppC.Get (0))->GetReceived ();
366 uint64_t totalPacketsThroughD = DynamicCast<UdpServer> (serverAppD.Get (0))->GetReceived ();
367
368 Simulator::Destroy ();
369
370 double throughput = totalPacketsThroughA * payloadSize * 8 / (simulationTime * 1000000.0);
371 std::cout << "AC_BE with default TXOP limit (0ms): " << '\n'
372 << " Throughput = " << throughput << " Mbit/s" << '\n';
373 if (verifyResults && (throughput < 28 || throughput > 29))
374 {
375 NS_LOG_ERROR ("Obtained throughput " << throughput << " is not in the expected boundaries!");
376 exit (1);
377 }
378
379 throughput = totalPacketsThroughB * payloadSize * 8 / (simulationTime * 1000000.0);
380 std::cout << "AC_BE with non-default TXOP limit (3.008ms): " << '\n'
381 << " Throughput = " << throughput << " Mbit/s" << '\n';
382 if (verifyResults && (throughput < 35 || throughput > 36))
383 {
384 NS_LOG_ERROR ("Obtained throughput " << throughput << " is not in the expected boundaries!");
385 exit (1);
386 }
387 std::cout << " Maximum TXOP duration = " << beTxopTracer.m_max.GetMicroSeconds () << " us" << '\n';
388 if (verifyResults && (beTxopTracer.m_max < MicroSeconds (2700) || beTxopTracer.m_max > MicroSeconds (3008)))
389 {
390 NS_LOG_ERROR ("Maximum TXOP duration " << beTxopTracer.m_max << " is not in the expected boundaries!");
391 exit (1);
392 }
393
394 throughput = totalPacketsThroughC * payloadSize * 8 / (simulationTime * 1000000.0);
395 std::cout << "AC_VI with default TXOP limit (3.008ms): " << '\n'
396 << " Throughput = " << throughput << " Mbit/s" << '\n';
397 if (verifyResults && (throughput < 35.5 || throughput > 36.5))
398 {
399 NS_LOG_ERROR ("Obtained throughput " << throughput << " is not in the expected boundaries!");
400 exit (1);
401 }
402 std::cout << " Maximum TXOP duration = " << viTxopTracer.m_max.GetMicroSeconds () << " us" << '\n';
403 if (verifyResults && (viTxopTracer.m_max < MicroSeconds (2700) || viTxopTracer.m_max > MicroSeconds (3008)))
404 {
405 NS_LOG_ERROR ("Maximum TXOP duration " << viTxopTracer.m_max << " is not in the expected boundaries!");
406 exit (1);
407 }
408
409 throughput = totalPacketsThroughD * payloadSize * 8 / (simulationTime * 1000000.0);
410 std::cout << "AC_VI with non-default TXOP limit (0ms): " << '\n'
411 << " Throughput = " << throughput << " Mbit/s" << '\n';
412 if (verifyResults && (throughput < 31.5 || throughput > 32.5))
413 {
414 NS_LOG_ERROR ("Obtained throughput " << throughput << " is not in the expected boundaries!");
415 exit (1);
416 }
417
418 return 0;
419}
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.
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:229
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.
holds a vector of std::pair of Ptr<Ipv4> and interface index.
Ipv4Address GetAddress(uint32_t i, uint32_t j=0) const
Helper class used to assign positions and mobility models to nodes.
holds a vector of ns3::NetDevice pointers
Ptr< NetDevice > Get(uint32_t i) const
Get the Ptr<NetDevice> stored in this container at a given index.
keep track of a set of node pointers.
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.
Ptr< NetDevice > GetDevice(uint32_t index) const
Retrieve the index-th NetDevice associated to this node.
Definition: node.cc:144
bool TraceConnectWithoutContext(std::string name, const CallbackBase &cb)
Connect a TraceSource to a Callback without a context.
Definition: object-base.cc:364
A helper to make it easier to instantiate an ns3::OnOffApplication on a set of nodes.
Definition: on-off-helper.h:43
Hold objects of type Ptr<T>.
Definition: pointer.h:37
Ptr< T > Get(void) const
Definition: pointer.h:201
Handle packet fragmentation and retransmissions for QoS data frames as well as MSDU aggregation (A-MS...
Definition: qos-txop.h:72
The IEEE 802.11 SSID Information Element.
Definition: ssid.h:36
AttributeValue implementation for Ssid.
Hold variables of type string.
Definition: string.h:41
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:103
void SetTxopLimit(Time txopLimit)
Set the TXOP limit.
Definition: txop.cc:254
Create a server application which waits for input UDP packets and uses the information carried into t...
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
create MAC layers for a ns3::WifiNetDevice.
Ptr< WifiMac > GetMac(void) const
manage and create wifi channel objects for the YANS model.
Make it easy to create and manage PHY objects for the YANS model.
uint16_t port
Definition: dsdv-manet.cc:45
#define NS_LOG_ERROR(msg)
Use NS_LOG to output a message of level LOG_ERROR.
Definition: log.h:257
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:205
Time MicroSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:1260
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1244
@ WIFI_STANDARD_80211a
address
Definition: first.py:44
stack
Definition: first.py:41
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
cmd
Definition: second.py:35
ssid
Definition: third.py:97
channel
Definition: third.py:92
mac
Definition: third.py:96
wifi
Definition: third.py:99
mobility
Definition: third.py:107
wifiStaNodes
Definition: third.py:88
phy
Definition: third.py:93
Keeps the maximum duration among all TXOPs.
Time m_max
maximum TXOP duration
void Trace(Time startTime, Time duration)
Callback connected to TXOP duration trace source.