A Discrete-Event Network Simulator
API
wifi-phy.cc
Go to the documentation of this file.
1 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * Copyright (c) 2005,2006 INRIA
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  * Authors: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
19  * Sébastien Deronne <sebastien.deronne@gmail.com>
20  */
21 
22 #include "wifi-phy.h"
23 #include "wifi-mode.h"
24 #include "wifi-channel.h"
25 #include "wifi-preamble.h"
26 #include "wifi-phy-state-helper.h"
27 #include "ns3/simulator.h"
28 #include "ns3/assert.h"
29 #include "ns3/log.h"
30 #include "ns3/boolean.h"
31 #include "ns3/double.h"
32 #include "ns3/uinteger.h"
33 #include "ns3/enum.h"
34 #include "ns3/pointer.h"
35 #include "ns3/trace-source-accessor.h"
36 #include "ns3/fatal-error.h"
37 #include <cmath>
38 
39 namespace ns3 {
40 
41 NS_LOG_COMPONENT_DEFINE ("WifiPhy");
42 
43 /****************************************************************
44  * This destructor is needed.
45  ****************************************************************/
46 
47 WifiPhyListener::~WifiPhyListener ()
48 {
49 }
50 
51 /****************************************************************
52  * The actual WifiPhy class
53  ****************************************************************/
54 
55 NS_OBJECT_ENSURE_REGISTERED (WifiPhy);
56 
65 WifiPhy::ChannelToFrequencyWidthMap WifiPhy::m_channelToFrequencyWidth =
66 {
67  // 802.11b uses width of 22, while OFDM modes use width of 20
68  { std::make_pair (1, WIFI_PHY_STANDARD_80211b), std::make_pair (2412, 22) },
69  { std::make_pair (1, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (2412, 20) },
70  { std::make_pair (2, WIFI_PHY_STANDARD_80211b), std::make_pair (2417, 22) },
71  { std::make_pair (2, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (2417, 20) },
72  { std::make_pair (3, WIFI_PHY_STANDARD_80211b), std::make_pair (2422, 22) },
73  { std::make_pair (3, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (2422, 20) },
74  { std::make_pair (4, WIFI_PHY_STANDARD_80211b), std::make_pair (2427, 22) },
75  { std::make_pair (4, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (2427, 20) },
76  { std::make_pair (5, WIFI_PHY_STANDARD_80211b), std::make_pair (2432, 22) },
77  { std::make_pair (5, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (2432, 20) },
78  { std::make_pair (6, WIFI_PHY_STANDARD_80211b), std::make_pair (2437, 22) },
79  { std::make_pair (6, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (2437, 20) },
80  { std::make_pair (7, WIFI_PHY_STANDARD_80211b), std::make_pair (2442, 22) },
81  { std::make_pair (7, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (2442, 20) },
82  { std::make_pair (8, WIFI_PHY_STANDARD_80211b), std::make_pair (2447, 22) },
83  { std::make_pair (8, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (2447, 20) },
84  { std::make_pair (9, WIFI_PHY_STANDARD_80211b), std::make_pair (2452, 22) },
85  { std::make_pair (9, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (2452, 20) },
86  { std::make_pair (10, WIFI_PHY_STANDARD_80211b), std::make_pair (2457, 22) },
87  { std::make_pair (10, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (2457, 20) },
88  { std::make_pair (11, WIFI_PHY_STANDARD_80211b), std::make_pair (2462, 22) },
89  { std::make_pair (11, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (2462, 20) },
90  { std::make_pair (12, WIFI_PHY_STANDARD_80211b), std::make_pair (2467, 22) },
91  { std::make_pair (12, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (2467, 20) },
92  { std::make_pair (13, WIFI_PHY_STANDARD_80211b), std::make_pair (2472, 22) },
93  { std::make_pair (13, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (2472, 20) },
94  // Only defined for 802.11b
95  { std::make_pair (14, WIFI_PHY_STANDARD_80211b), std::make_pair (2484, 22) },
96 
97  // Now the 5GHz channels; UNSPECIFIED for 802.11a/n channels, but limited
98  // to 802.11ac for the 80/160 MHz channels
99  // 20 MHz channels
100  { std::make_pair (36, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5180, 20) },
101  { std::make_pair (40, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5200, 20) },
102  { std::make_pair (44, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5220, 20) },
103  { std::make_pair (48, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5240, 20) },
104  { std::make_pair (52, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5260, 20) },
105  { std::make_pair (56, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5280, 20) },
106  { std::make_pair (60, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5300, 20) },
107  { std::make_pair (64, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5320, 20) },
108  { std::make_pair (100, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5500, 20) },
109  { std::make_pair (104, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5520, 20) },
110  { std::make_pair (108, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5540, 20) },
111  { std::make_pair (112, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5560, 20) },
112  { std::make_pair (116, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5580, 20) },
113  { std::make_pair (120, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5600, 20) },
114  { std::make_pair (124, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5620, 20) },
115  { std::make_pair (128, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5640, 20) },
116  { std::make_pair (132, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5660, 20) },
117  { std::make_pair (136, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5680, 20) },
118  { std::make_pair (140, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5700, 20) },
119  { std::make_pair (144, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5720, 20) },
120  { std::make_pair (149, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5745, 20) },
121  { std::make_pair (153, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5765, 20) },
122  { std::make_pair (157, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5785, 20) },
123  { std::make_pair (161, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5805, 20) },
124  { std::make_pair (165, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5825, 20) },
125  // 40 MHz channels
126  { std::make_pair (38, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5190, 40) },
127  { std::make_pair (46, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5230, 40) },
128  { std::make_pair (54, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5230, 40) },
129  { std::make_pair (62, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5310, 40) },
130  { std::make_pair (102, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5510, 40) },
131  { std::make_pair (110, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5550, 40) },
132  { std::make_pair (118, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5590, 40) },
133  { std::make_pair (126, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5590, 40) },
134  { std::make_pair (134, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5670, 40) },
135  { std::make_pair (142, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5710, 40) },
136  { std::make_pair (151, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5755, 40) },
137  { std::make_pair (159, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5795, 40) },
138  // 80 MHz channels
139  { std::make_pair (42, WIFI_PHY_STANDARD_80211ac), std::make_pair (5210, 80) },
140  { std::make_pair (58, WIFI_PHY_STANDARD_80211ac), std::make_pair (5290, 80) },
141  { std::make_pair (106, WIFI_PHY_STANDARD_80211ac), std::make_pair (5530, 80) },
142  { std::make_pair (122, WIFI_PHY_STANDARD_80211ac), std::make_pair (5610, 80) },
143  { std::make_pair (138, WIFI_PHY_STANDARD_80211ac), std::make_pair (5690, 80) },
144  { std::make_pair (155, WIFI_PHY_STANDARD_80211ac), std::make_pair (5775, 80) },
145  // 160 MHz channels
146  { std::make_pair (50, WIFI_PHY_STANDARD_80211ac), std::make_pair (5250, 160) },
147  { std::make_pair (114, WIFI_PHY_STANDARD_80211ac), std::make_pair (5570, 160) },
148 
149  // 802.11p (10 MHz channels at the 5.855-5.925 band
150  { std::make_pair (172, WIFI_PHY_STANDARD_80211_10MHZ), std::make_pair (5860, 10) },
151  { std::make_pair (174, WIFI_PHY_STANDARD_80211_10MHZ), std::make_pair (5870, 10) },
152  { std::make_pair (176, WIFI_PHY_STANDARD_80211_10MHZ), std::make_pair (5880, 10) },
153  { std::make_pair (178, WIFI_PHY_STANDARD_80211_10MHZ), std::make_pair (5890, 10) },
154  { std::make_pair (180, WIFI_PHY_STANDARD_80211_10MHZ), std::make_pair (5900, 10) },
155  { std::make_pair (182, WIFI_PHY_STANDARD_80211_10MHZ), std::make_pair (5910, 10) },
156  { std::make_pair (184, WIFI_PHY_STANDARD_80211_10MHZ), std::make_pair (5920, 10) }
157 };
158 
159 TypeId
160 WifiPhy::GetTypeId (void)
161 {
162  static TypeId tid = TypeId ("ns3::WifiPhy")
163  .SetParent<Object> ()
164  .SetGroupName ("Wifi")
165  .AddAttribute ("Frequency",
166  "The operating center frequency (MHz)",
167  UintegerValue (0),
168  MakeUintegerAccessor (&WifiPhy::GetFrequency,
169  &WifiPhy::SetFrequency),
170  MakeUintegerChecker<uint32_t> ())
171  .AddAttribute ("ChannelWidth",
172  "Whether 5MHz, 10MHz, 20MHz, 22MHz, 40MHz, 80 MHz or 160 MHz.",
173  UintegerValue (20),
174  MakeUintegerAccessor (&WifiPhy::GetChannelWidth,
175  &WifiPhy::SetChannelWidth),
176  MakeUintegerChecker<uint32_t> ())
177  .AddAttribute ("ChannelNumber",
178  "If set to non-zero defined value, will control Frequency and ChannelWidth assignment",
179  UintegerValue (0),
180  MakeUintegerAccessor (&WifiPhy::SetChannelNumber,
181  &WifiPhy::GetChannelNumber),
182  MakeUintegerChecker<uint16_t> ())
183  .AddAttribute ("EnergyDetectionThreshold",
184  "The energy of a received signal should be higher than "
185  "this threshold (dbm) to allow the PHY layer to detect the signal.",
186  DoubleValue (-96.0),
187  MakeDoubleAccessor (&WifiPhy::SetEdThreshold,
188  &WifiPhy::GetEdThreshold),
189  MakeDoubleChecker<double> ())
190  .AddAttribute ("CcaMode1Threshold",
191  "The energy of a received signal should be higher than "
192  "this threshold (dbm) to allow the PHY layer to declare CCA BUSY state.",
193  DoubleValue (-99.0),
194  MakeDoubleAccessor (&WifiPhy::SetCcaMode1Threshold,
195  &WifiPhy::GetCcaMode1Threshold),
196  MakeDoubleChecker<double> ())
197  .AddAttribute ("TxGain",
198  "Transmission gain (dB).",
199  DoubleValue (1.0),
200  MakeDoubleAccessor (&WifiPhy::SetTxGain,
201  &WifiPhy::GetTxGain),
202  MakeDoubleChecker<double> ())
203  .AddAttribute ("RxGain",
204  "Reception gain (dB).",
205  DoubleValue (1.0),
206  MakeDoubleAccessor (&WifiPhy::SetRxGain,
207  &WifiPhy::GetRxGain),
208  MakeDoubleChecker<double> ())
209  .AddAttribute ("TxPowerLevels",
210  "Number of transmission power levels available between "
211  "TxPowerStart and TxPowerEnd included.",
212  UintegerValue (1),
213  MakeUintegerAccessor (&WifiPhy::m_nTxPower),
214  MakeUintegerChecker<uint32_t> ())
215  .AddAttribute ("TxPowerEnd",
216  "Maximum available transmission level (dbm).",
217  DoubleValue (16.0206),
218  MakeDoubleAccessor (&WifiPhy::SetTxPowerEnd,
219  &WifiPhy::GetTxPowerEnd),
220  MakeDoubleChecker<double> ())
221  .AddAttribute ("TxPowerStart",
222  "Minimum available transmission level (dbm).",
223  DoubleValue (16.0206),
224  MakeDoubleAccessor (&WifiPhy::SetTxPowerStart,
225  &WifiPhy::GetTxPowerStart),
226  MakeDoubleChecker<double> ())
227  .AddAttribute ("RxNoiseFigure",
228  "Loss (dB) in the Signal-to-Noise-Ratio due to non-idealities in the receiver."
229  " According to Wikipedia (http://en.wikipedia.org/wiki/Noise_figure), this is "
230  "\"the difference in decibels (dB) between"
231  " the noise output of the actual receiver to the noise output of an "
232  " ideal receiver with the same overall gain and bandwidth when the receivers "
233  " are connected to sources at the standard noise temperature T0 (usually 290 K)\".",
234  DoubleValue (7),
235  MakeDoubleAccessor (&WifiPhy::SetRxNoiseFigure,
236  &WifiPhy::GetRxNoiseFigure),
237  MakeDoubleChecker<double> ())
238  .AddAttribute ("State",
239  "The state of the PHY layer.",
240  PointerValue (),
241  MakePointerAccessor (&WifiPhy::m_state),
242  MakePointerChecker<WifiPhyStateHelper> ())
243  .AddAttribute ("ChannelSwitchDelay",
244  "Delay between two short frames transmitted on different frequencies.",
245  TimeValue (MicroSeconds (250)),
246  MakeTimeAccessor (&WifiPhy::m_channelSwitchDelay),
247  MakeTimeChecker ())
248  .AddAttribute ("TxAntennas",
249  "The number of supported Tx antennas.",
250  UintegerValue (1),
251  MakeUintegerAccessor (&WifiPhy::GetNumberOfTransmitAntennas,
252  &WifiPhy::SetNumberOfTransmitAntennas),
253  MakeUintegerChecker<uint32_t> ())
254  .AddAttribute ("RxAntennas",
255  "The number of supported Rx antennas.",
256  UintegerValue (1),
257  MakeUintegerAccessor (&WifiPhy::GetNumberOfReceiveAntennas,
258  &WifiPhy::SetNumberOfReceiveAntennas),
259  MakeUintegerChecker<uint32_t> ())
260  .AddAttribute ("ShortGuardEnabled",
261  "Whether or not short guard interval is enabled."
262  "This parameter is only valuable for 802.11n/ac STAs and APs.",
263  BooleanValue (false),
264  MakeBooleanAccessor (&WifiPhy::GetGuardInterval,
265  &WifiPhy::SetGuardInterval),
266  MakeBooleanChecker ())
267  .AddAttribute ("LdpcEnabled",
268  "Whether or not LDPC is enabled.",
269  BooleanValue (false),
270  MakeBooleanAccessor (&WifiPhy::GetLdpc,
271  &WifiPhy::SetLdpc),
272  MakeBooleanChecker ())
273  .AddAttribute ("STBCEnabled",
274  "Whether or not STBC is enabled.",
275  BooleanValue (false),
276  MakeBooleanAccessor (&WifiPhy::GetStbc,
277  &WifiPhy::SetStbc),
278  MakeBooleanChecker ())
279  .AddAttribute ("GreenfieldEnabled",
280  "Whether or not Greenfield is enabled."
281  "This parameter is only valuable for 802.11n STAs and APs.",
282  BooleanValue (false),
283  MakeBooleanAccessor (&WifiPhy::GetGreenfield,
284  &WifiPhy::SetGreenfield),
285  MakeBooleanChecker ())
286  .AddAttribute ("ShortPlcpPreambleSupported",
287  "Whether or not short PLCP preamble is supported."
288  "This parameter is only valuable for 802.11b STAs and APs."
289  "Note: 802.11g APs and STAs always support short PLCP preamble.",
290  BooleanValue (false),
291  MakeBooleanAccessor (&WifiPhy::GetShortPlcpPreambleSupported,
292  &WifiPhy::SetShortPlcpPreambleSupported),
293  MakeBooleanChecker ())
294  .AddTraceSource ("PhyTxBegin",
295  "Trace source indicating a packet "
296  "has begun transmitting over the channel medium",
297  MakeTraceSourceAccessor (&WifiPhy::m_phyTxBeginTrace),
298  "ns3::Packet::TracedCallback")
299  .AddTraceSource ("PhyTxEnd",
300  "Trace source indicating a packet "
301  "has been completely transmitted over the channel. "
302  "NOTE: the only official WifiPhy implementation "
303  "available to this date never fires "
304  "this trace source.",
305  MakeTraceSourceAccessor (&WifiPhy::m_phyTxEndTrace),
306  "ns3::Packet::TracedCallback")
307  .AddTraceSource ("PhyTxDrop",
308  "Trace source indicating a packet "
309  "has been dropped by the device during transmission",
310  MakeTraceSourceAccessor (&WifiPhy::m_phyTxDropTrace),
311  "ns3::Packet::TracedCallback")
312  .AddTraceSource ("PhyRxBegin",
313  "Trace source indicating a packet "
314  "has begun being received from the channel medium "
315  "by the device",
316  MakeTraceSourceAccessor (&WifiPhy::m_phyRxBeginTrace),
317  "ns3::Packet::TracedCallback")
318  .AddTraceSource ("PhyRxEnd",
319  "Trace source indicating a packet "
320  "has been completely received from the channel medium "
321  "by the device",
322  MakeTraceSourceAccessor (&WifiPhy::m_phyRxEndTrace),
323  "ns3::Packet::TracedCallback")
324  .AddTraceSource ("PhyRxDrop",
325  "Trace source indicating a packet "
326  "has been dropped by the device during reception",
327  MakeTraceSourceAccessor (&WifiPhy::m_phyRxDropTrace),
328  "ns3::Packet::TracedCallback")
329  .AddTraceSource ("MonitorSnifferRx",
330  "Trace source simulating a wifi device in monitor mode "
331  "sniffing all received frames",
332  MakeTraceSourceAccessor (&WifiPhy::m_phyMonitorSniffRxTrace),
333  "ns3::WifiPhy::MonitorSnifferRxTracedCallback")
334  .AddTraceSource ("MonitorSnifferTx",
335  "Trace source simulating the capability of a wifi device "
336  "in monitor mode to sniff all frames being transmitted",
337  MakeTraceSourceAccessor (&WifiPhy::m_phyMonitorSniffTxTrace),
338  "ns3::WifiPhy::MonitorSnifferTxTracedCallback")
339  ;
340  return tid;
341 }
342 
343 WifiPhy::WifiPhy ()
344  : m_mpdusNum (0),
345  m_plcpSuccess (false),
346  m_txMpduReferenceNumber (0xffffffff),
347  m_rxMpduReferenceNumber (0xffffffff),
348  m_endRxEvent (),
349  m_endPlcpRxEvent (),
350  m_standard (WIFI_PHY_STANDARD_UNSPECIFIED),
351  m_isConstructed (false),
352  m_channelCenterFrequency (0),
353  m_initialFrequency (0),
354  m_frequencyChannelNumberInitialized (false),
355  m_channelNumber (0),
356  m_initialChannelNumber (0),
357  m_totalAmpduSize (0),
358  m_totalAmpduNumSymbols (0)
359 {
360  NS_LOG_FUNCTION (this);
361  m_random = CreateObject<UniformRandomVariable> ();
362  m_state = CreateObject<WifiPhyStateHelper> ();
363 }
364 
365 WifiPhy::~WifiPhy ()
366 {
367  NS_LOG_FUNCTION (this);
368 }
369 
370 void
371 WifiPhy::DoDispose (void)
372 {
373  NS_LOG_FUNCTION (this);
374  m_device = 0;
375  m_mobility = 0;
376  m_state = 0;
377  m_deviceRateSet.clear ();
378  m_deviceMcsSet.clear ();
379 }
380 
381 void
382 WifiPhy::DoInitialize (void)
383 {
384  NS_LOG_FUNCTION (this);
385  m_isConstructed = true;
386  if (m_frequencyChannelNumberInitialized == true)
387  {
388  NS_LOG_DEBUG ("Frequency already initialized");
389  return;
390  }
391  InitializeFrequencyChannelNumber ();
392 }
393 
394 void
395 WifiPhy::InitializeFrequencyChannelNumber (void)
396 {
397  NS_LOG_FUNCTION (this);
398 
399  NS_ASSERT_MSG (m_frequencyChannelNumberInitialized == false, "Initialization called twice");
400 
401  // If frequency has been set to a non-zero value during attribute
402  // construction phase, the frequency and channel width will drive the
403  // initial configuration. If frequency has not been set, but both
404  // standard and channel number have been set, that pair will instead
405  // drive the configuration, and frequency and channel number will be
406  // aligned
407  if (m_initialFrequency != 0)
408  {
409  SetFrequency (m_initialFrequency);
410  }
411  else if (m_initialChannelNumber != 0 && GetStandard () != WIFI_PHY_STANDARD_UNSPECIFIED)
412  {
413  SetChannelNumber (m_initialChannelNumber);
414  }
415  else if (m_initialChannelNumber != 0 && GetStandard () == WIFI_PHY_STANDARD_UNSPECIFIED)
416  {
417  NS_FATAL_ERROR ("Error, ChannelNumber " << GetChannelNumber () << " was set by user, but neither a standard nor a frequency");
418  }
419  m_frequencyChannelNumberInitialized = true;
420 }
421 
422 void
423 WifiPhy::SetEdThreshold (double threshold)
424 {
425  NS_LOG_FUNCTION (this << threshold);
426  m_edThresholdW = DbmToW (threshold);
427 }
428 
429 double
430 WifiPhy::GetEdThresholdW (void) const
431 {
432  return m_edThresholdW;
433 }
434 
435 double
436 WifiPhy::GetEdThreshold (void) const
437 {
438  return WToDbm (m_edThresholdW);
439 }
440 
441 void
442 WifiPhy::SetCcaMode1Threshold (double threshold)
443 {
444  NS_LOG_FUNCTION (this << threshold);
445  m_ccaMode1ThresholdW = DbmToW (threshold);
446 }
447 
448 double
449 WifiPhy::GetCcaMode1Threshold (void) const
450 {
451  return WToDbm (m_ccaMode1ThresholdW);
452 }
453 
454 void
455 WifiPhy::SetRxNoiseFigure (double noiseFigureDb)
456 {
457  NS_LOG_FUNCTION (this << noiseFigureDb);
458  m_interference.SetNoiseFigure (DbToRatio (noiseFigureDb));
459 }
460 
461 double
462 WifiPhy::GetRxNoiseFigure (void) const
463 {
464  return RatioToDb (m_interference.GetNoiseFigure ());
465 }
466 
467 void
468 WifiPhy::SetTxPowerStart (double start)
469 {
470  NS_LOG_FUNCTION (this << start);
471  m_txPowerBaseDbm = start;
472 }
473 
474 double
475 WifiPhy::GetTxPowerStart (void) const
476 {
477  return m_txPowerBaseDbm;
478 }
479 
480 void
481 WifiPhy::SetTxPowerEnd (double end)
482 {
483  NS_LOG_FUNCTION (this << end);
484  m_txPowerEndDbm = end;
485 }
486 
487 double
488 WifiPhy::GetTxPowerEnd (void) const
489 {
490  return m_txPowerEndDbm;
491 }
492 
493 void
494 WifiPhy::SetNTxPower (uint32_t n)
495 {
496  NS_LOG_FUNCTION (this << n);
497  m_nTxPower = n;
498 }
499 
500 uint32_t
501 WifiPhy::GetNTxPower (void) const
502 {
503  return m_nTxPower;
504 }
505 
506 void
507 WifiPhy::SetTxGain (double gain)
508 {
509  NS_LOG_FUNCTION (this << gain);
510  m_txGainDb = gain;
511 }
512 
513 double
514 WifiPhy::GetTxGain (void) const
515 {
516  return m_txGainDb;
517 }
518 
519 void
520 WifiPhy::SetRxGain (double gain)
521 {
522  NS_LOG_FUNCTION (this << gain);
523  m_rxGainDb = gain;
524 }
525 
526 double
527 WifiPhy::GetRxGain (void) const
528 {
529  return m_rxGainDb;
530 }
531 
532 void
533 WifiPhy::SetLdpc (bool ldpc)
534 {
535  NS_LOG_FUNCTION (this << ldpc);
536  m_ldpc = ldpc;
537 }
538 
539 bool
540 WifiPhy::GetLdpc (void) const
541 {
542  return m_ldpc;
543 }
544 
545 void
546 WifiPhy::SetStbc (bool stbc)
547 {
548  NS_LOG_FUNCTION (this << stbc);
549  m_stbc = stbc;
550 }
551 
552 bool
553 WifiPhy::GetStbc (void) const
554 {
555  return m_stbc;
556 }
557 
558 void
559 WifiPhy::SetGreenfield (bool greenfield)
560 {
561  NS_LOG_FUNCTION (this << greenfield);
562  m_greenfield = greenfield;
563 }
564 
565 bool
566 WifiPhy::GetGreenfield (void) const
567 {
568  return m_greenfield;
569 }
570 
571 void
572 WifiPhy::SetGuardInterval (bool guardInterval)
573 {
574  NS_LOG_FUNCTION (this << guardInterval);
575  m_guardInterval = guardInterval;
576 }
577 
578 bool
579 WifiPhy::GetGuardInterval (void) const
580 {
581  return m_guardInterval;
582 }
583 
584 void
585 WifiPhy::SetShortPlcpPreambleSupported (bool enable)
586 {
587  NS_LOG_FUNCTION (this << enable);
588  m_shortPreamble = enable;
589 }
590 
591 bool
592 WifiPhy::GetShortPlcpPreambleSupported (void) const
593 {
594  return m_shortPreamble;
595 }
596 
597 void
598 WifiPhy::SetDevice (Ptr<NetDevice> device)
599 {
600  m_device = device;
601 }
602 
603 Ptr<NetDevice>
604 WifiPhy::GetDevice (void) const
605 {
606  return m_device;
607 }
608 
609 void
610 WifiPhy::SetMobility (Ptr<MobilityModel> mobility)
611 {
612  m_mobility = mobility;
613 }
614 
615 Ptr<MobilityModel>
616 WifiPhy::GetMobility (void)
617 {
618  if (m_mobility != 0)
619  {
620  return m_mobility;
621  }
622  else
623  {
624  return m_device->GetNode ()->GetObject<MobilityModel> ();
625  }
626 }
627 
628 void
629 WifiPhy::SetErrorRateModel (Ptr<ErrorRateModel> rate)
630 {
631  m_interference.SetErrorRateModel (rate);
632 }
633 
634 Ptr<ErrorRateModel>
635 WifiPhy::GetErrorRateModel (void) const
636 {
637  return m_interference.GetErrorRateModel ();
638 }
639 
640 double
641 WifiPhy::GetPowerDbm (uint8_t power) const
642 {
643  NS_ASSERT (m_txPowerBaseDbm <= m_txPowerEndDbm);
644  NS_ASSERT (m_nTxPower > 0);
645  double dbm;
646  if (m_nTxPower > 1)
647  {
648  dbm = m_txPowerBaseDbm + power * (m_txPowerEndDbm - m_txPowerBaseDbm) / (m_nTxPower - 1);
649  }
650  else
651  {
652  NS_ASSERT_MSG (m_txPowerBaseDbm == m_txPowerEndDbm, "cannot have TxPowerEnd != TxPowerStart with TxPowerLevels == 1");
653  dbm = m_txPowerBaseDbm;
654  }
655  return dbm;
656 }
657 
658 Time
659 WifiPhy::GetChannelSwitchDelay (void) const
660 {
661  return m_channelSwitchDelay;
662 }
663 
664 double
665 WifiPhy::CalculateSnr (WifiTxVector txVector, double ber) const
666 {
667  return m_interference.GetErrorRateModel ()->CalculateSnr (txVector, ber);
668 }
669 
670 void
671 WifiPhy::ConfigureDefaultsForStandard (enum WifiPhyStandard standard)
672 {
673  NS_LOG_FUNCTION (this << standard);
674  switch (standard)
675  {
676  case WIFI_PHY_STANDARD_80211a:
677  SetChannelWidth (20);
678  SetFrequency (5180);
679  // Channel number should be aligned by SetFrequency () to 36
680  NS_ASSERT (GetChannelNumber () == 36);
681  break;
682  case WIFI_PHY_STANDARD_80211b:
683  SetChannelWidth (22);
684  SetFrequency (2412);
685  // Channel number should be aligned by SetFrequency () to 1
686  NS_ASSERT (GetChannelNumber () == 1);
687  break;
688  case WIFI_PHY_STANDARD_80211g:
689  SetChannelWidth (20);
690  SetFrequency (2412);
691  // Channel number should be aligned by SetFrequency () to 1
692  NS_ASSERT (GetChannelNumber () == 1);
693  break;
694  case WIFI_PHY_STANDARD_80211_10MHZ:
695  SetChannelWidth (10);
696  SetFrequency (5860);
697  // Channel number should be aligned by SetFrequency () to 172
698  NS_ASSERT (GetChannelNumber () == 172);
699  break;
700  case WIFI_PHY_STANDARD_80211_5MHZ:
701  SetChannelWidth (5);
702  SetFrequency (5860);
703  // Channel number should be aligned by SetFrequency () to 0
704  NS_ASSERT (GetChannelNumber () == 0);
705  break;
706  case WIFI_PHY_STANDARD_holland:
707  SetChannelWidth (20);
708  SetFrequency (5180);
709  // Channel number should be aligned by SetFrequency () to 36
710  NS_ASSERT (GetChannelNumber () == 36);
711  break;
712  case WIFI_PHY_STANDARD_80211n_2_4GHZ:
713  SetChannelWidth (20);
714  SetFrequency (2412);
715  // Channel number should be aligned by SetFrequency () to 1
716  NS_ASSERT (GetChannelNumber () == 1);
717  break;
718  case WIFI_PHY_STANDARD_80211n_5GHZ:
719  SetChannelWidth (20);
720  SetFrequency (5180);
721  // Channel number should be aligned by SetFrequency () to 36
722  NS_ASSERT (GetChannelNumber () == 36);
723  break;
724  case WIFI_PHY_STANDARD_80211ac:
725  SetChannelWidth (80);
726  SetFrequency (5210);
727  // Channel number should be aligned by SetFrequency () to 42
728  NS_ASSERT (GetChannelNumber () == 42);
729  break;
730  case WIFI_PHY_STANDARD_UNSPECIFIED:
731  NS_LOG_WARN ("Configuring unspecified standard; performing no action");
732  break;
733  default:
734  NS_ASSERT (false);
735  break;
736  }
737 }
738 
739 void
740 WifiPhy::Configure80211a (void)
741 {
742  NS_LOG_FUNCTION (this);
743 
744  m_deviceRateSet.push_back (WifiPhy::GetOfdmRate6Mbps ());
745  m_deviceRateSet.push_back (WifiPhy::GetOfdmRate9Mbps ());
746  m_deviceRateSet.push_back (WifiPhy::GetOfdmRate12Mbps ());
747  m_deviceRateSet.push_back (WifiPhy::GetOfdmRate18Mbps ());
748  m_deviceRateSet.push_back (WifiPhy::GetOfdmRate24Mbps ());
749  m_deviceRateSet.push_back (WifiPhy::GetOfdmRate36Mbps ());
750  m_deviceRateSet.push_back (WifiPhy::GetOfdmRate48Mbps ());
751  m_deviceRateSet.push_back (WifiPhy::GetOfdmRate54Mbps ());
752 }
753 
754 void
755 WifiPhy::Configure80211b (void)
756 {
757  NS_LOG_FUNCTION (this);
758 
759  m_deviceRateSet.push_back (WifiPhy::GetDsssRate1Mbps ());
760  m_deviceRateSet.push_back (WifiPhy::GetDsssRate2Mbps ());
761  m_deviceRateSet.push_back (WifiPhy::GetDsssRate5_5Mbps ());
762  m_deviceRateSet.push_back (WifiPhy::GetDsssRate11Mbps ());
763 }
764 
765 void
766 WifiPhy::Configure80211g (void)
767 {
768  NS_LOG_FUNCTION (this);
769  Configure80211b ();
770 
771  m_deviceRateSet.push_back (WifiPhy::GetErpOfdmRate6Mbps ());
772  m_deviceRateSet.push_back (WifiPhy::GetErpOfdmRate9Mbps ());
773  m_deviceRateSet.push_back (WifiPhy::GetErpOfdmRate12Mbps ());
774  m_deviceRateSet.push_back (WifiPhy::GetErpOfdmRate18Mbps ());
775  m_deviceRateSet.push_back (WifiPhy::GetErpOfdmRate24Mbps ());
776  m_deviceRateSet.push_back (WifiPhy::GetErpOfdmRate36Mbps ());
777  m_deviceRateSet.push_back (WifiPhy::GetErpOfdmRate48Mbps ());
778  m_deviceRateSet.push_back (WifiPhy::GetErpOfdmRate54Mbps ());
779 }
780 
781 void
782 WifiPhy::Configure80211_10Mhz (void)
783 {
784  NS_LOG_FUNCTION (this);
785 
786  m_deviceRateSet.push_back (WifiPhy::GetOfdmRate3MbpsBW10MHz ());
787  m_deviceRateSet.push_back (WifiPhy::GetOfdmRate4_5MbpsBW10MHz ());
788  m_deviceRateSet.push_back (WifiPhy::GetOfdmRate6MbpsBW10MHz ());
789  m_deviceRateSet.push_back (WifiPhy::GetOfdmRate9MbpsBW10MHz ());
790  m_deviceRateSet.push_back (WifiPhy::GetOfdmRate12MbpsBW10MHz ());
791  m_deviceRateSet.push_back (WifiPhy::GetOfdmRate18MbpsBW10MHz ());
792  m_deviceRateSet.push_back (WifiPhy::GetOfdmRate24MbpsBW10MHz ());
793  m_deviceRateSet.push_back (WifiPhy::GetOfdmRate27MbpsBW10MHz ());
794 }
795 
796 void
797 WifiPhy::Configure80211_5Mhz (void)
798 {
799  NS_LOG_FUNCTION (this);
800 
801  m_deviceRateSet.push_back (WifiPhy::GetOfdmRate1_5MbpsBW5MHz ());
802  m_deviceRateSet.push_back (WifiPhy::GetOfdmRate2_25MbpsBW5MHz ());
803  m_deviceRateSet.push_back (WifiPhy::GetOfdmRate3MbpsBW5MHz ());
804  m_deviceRateSet.push_back (WifiPhy::GetOfdmRate4_5MbpsBW5MHz ());
805  m_deviceRateSet.push_back (WifiPhy::GetOfdmRate6MbpsBW5MHz ());
806  m_deviceRateSet.push_back (WifiPhy::GetOfdmRate9MbpsBW5MHz ());
807  m_deviceRateSet.push_back (WifiPhy::GetOfdmRate12MbpsBW5MHz ());
808  m_deviceRateSet.push_back (WifiPhy::GetOfdmRate13_5MbpsBW5MHz ());
809 }
810 
811 void
812 WifiPhy::ConfigureHolland (void)
813 {
814  NS_LOG_FUNCTION (this);
815 
816  m_deviceRateSet.push_back (WifiPhy::GetOfdmRate6Mbps ());
817  m_deviceRateSet.push_back (WifiPhy::GetOfdmRate12Mbps ());
818  m_deviceRateSet.push_back (WifiPhy::GetOfdmRate18Mbps ());
819  m_deviceRateSet.push_back (WifiPhy::GetOfdmRate36Mbps ());
820  m_deviceRateSet.push_back (WifiPhy::GetOfdmRate54Mbps ());
821 }
822 
823 void
824 WifiPhy::ConfigureHtDeviceMcsSet (void)
825 {
826  NS_LOG_FUNCTION (this);
827 
828  bool htFound = false;
829  for (std::vector<uint32_t>::size_type i = 0; i < m_bssMembershipSelectorSet.size (); i++)
830  {
831  if (m_bssMembershipSelectorSet[i] == HT_PHY)
832  {
833  htFound = true;
834  break;
835  }
836  }
837  if (htFound)
838  {
839  // erase all HtMcs modes from deviceMcsSet
840  size_t index = m_deviceMcsSet.size () - 1;
841  for (std::vector<WifiMode>::reverse_iterator rit = m_deviceMcsSet.rbegin (); rit != m_deviceMcsSet.rend(); ++rit, --index)
842  {
843  if (m_deviceMcsSet[index].GetModulationClass ()== WIFI_MOD_CLASS_HT)
844  {
845  m_deviceMcsSet.erase (m_deviceMcsSet.begin () + index);
846  }
847  }
848  m_deviceMcsSet.push_back (WifiPhy::GetHtMcs0 ());
849  m_deviceMcsSet.push_back (WifiPhy::GetHtMcs1 ());
850  m_deviceMcsSet.push_back (WifiPhy::GetHtMcs2 ());
851  m_deviceMcsSet.push_back (WifiPhy::GetHtMcs3 ());
852  m_deviceMcsSet.push_back (WifiPhy::GetHtMcs4 ());
853  m_deviceMcsSet.push_back (WifiPhy::GetHtMcs5 ());
854  m_deviceMcsSet.push_back (WifiPhy::GetHtMcs6 ());
855  m_deviceMcsSet.push_back (WifiPhy::GetHtMcs7 ());
856  if (GetSupportedTxSpatialStreams () > 1)
857  {
858  m_deviceMcsSet.push_back (WifiPhy::GetHtMcs8 ());
859  m_deviceMcsSet.push_back (WifiPhy::GetHtMcs9 ());
860  m_deviceMcsSet.push_back (WifiPhy::GetHtMcs10 ());
861  m_deviceMcsSet.push_back (WifiPhy::GetHtMcs11 ());
862  m_deviceMcsSet.push_back (WifiPhy::GetHtMcs12 ());
863  m_deviceMcsSet.push_back (WifiPhy::GetHtMcs13 ());
864  m_deviceMcsSet.push_back (WifiPhy::GetHtMcs14 ());
865  m_deviceMcsSet.push_back (WifiPhy::GetHtMcs15 ());
866  }
867  if (GetSupportedTxSpatialStreams () > 2)
868  {
869  m_deviceMcsSet.push_back (WifiPhy::GetHtMcs16 ());
870  m_deviceMcsSet.push_back (WifiPhy::GetHtMcs17 ());
871  m_deviceMcsSet.push_back (WifiPhy::GetHtMcs18 ());
872  m_deviceMcsSet.push_back (WifiPhy::GetHtMcs19 ());
873  m_deviceMcsSet.push_back (WifiPhy::GetHtMcs20 ());
874  m_deviceMcsSet.push_back (WifiPhy::GetHtMcs21 ());
875  m_deviceMcsSet.push_back (WifiPhy::GetHtMcs22 ());
876  m_deviceMcsSet.push_back (WifiPhy::GetHtMcs23 ());
877  }
878  if (GetSupportedTxSpatialStreams () > 3)
879  {
880  m_deviceMcsSet.push_back (WifiPhy::GetHtMcs24 ());
881  m_deviceMcsSet.push_back (WifiPhy::GetHtMcs25 ());
882  m_deviceMcsSet.push_back (WifiPhy::GetHtMcs26 ());
883  m_deviceMcsSet.push_back (WifiPhy::GetHtMcs27 ());
884  m_deviceMcsSet.push_back (WifiPhy::GetHtMcs28 ());
885  m_deviceMcsSet.push_back (WifiPhy::GetHtMcs29 ());
886  m_deviceMcsSet.push_back (WifiPhy::GetHtMcs30 ());
887  m_deviceMcsSet.push_back (WifiPhy::GetHtMcs31 ());
888  }
889  }
890 }
891 
892 void
893 WifiPhy::Configure80211n (void)
894 {
895  NS_LOG_FUNCTION (this);
896  if (GetFrequency () >= 2400 && GetFrequency () <= 2500) //at 2.4 GHz
897  {
898  Configure80211b ();
899  Configure80211g ();
900  }
901  if (GetFrequency () >= 5000 && GetFrequency () <= 6000) //at 5 GHz
902  {
903  Configure80211a ();
904  }
905  m_bssMembershipSelectorSet.push_back (HT_PHY);
906  ConfigureHtDeviceMcsSet ();
907 }
908 
909 void
910 WifiPhy::Configure80211ac (void)
911 {
912  NS_LOG_FUNCTION (this);
913  Configure80211n ();
914 
915  m_deviceMcsSet.push_back (WifiPhy::GetVhtMcs0 ());
916  m_deviceMcsSet.push_back (WifiPhy::GetVhtMcs1 ());
917  m_deviceMcsSet.push_back (WifiPhy::GetVhtMcs2 ());
918  m_deviceMcsSet.push_back (WifiPhy::GetVhtMcs3 ());
919  m_deviceMcsSet.push_back (WifiPhy::GetVhtMcs4 ());
920  m_deviceMcsSet.push_back (WifiPhy::GetVhtMcs5 ());
921  m_deviceMcsSet.push_back (WifiPhy::GetVhtMcs6 ());
922  m_deviceMcsSet.push_back (WifiPhy::GetVhtMcs7 ());
923  m_deviceMcsSet.push_back (WifiPhy::GetVhtMcs8 ());
924  m_deviceMcsSet.push_back (WifiPhy::GetVhtMcs9 ());
925 
926  m_bssMembershipSelectorSet.push_back (VHT_PHY);
927 }
928 
929 bool
930 WifiPhy::DefineChannelNumber (uint16_t channelNumber, enum WifiPhyStandard standard, uint32_t frequency, uint32_t channelWidth)
931 {
932  NS_LOG_FUNCTION (this << channelNumber << standard << frequency << channelWidth);
933  ChannelNumberStandardPair p = std::make_pair (channelNumber, standard);
934  ChannelToFrequencyWidthMap::const_iterator it;
935  it = m_channelToFrequencyWidth.find (p);
936  if (it != m_channelToFrequencyWidth.end ())
937  {
938  NS_LOG_DEBUG ("channel number/standard already defined; returning false");
939  return false;
940  }
941  FrequencyWidthPair f = std::make_pair (frequency, channelWidth);
942  m_channelToFrequencyWidth[p] = f;
943  return true;
944 }
945 
946 uint16_t
947 WifiPhy::FindChannelNumberForFrequencyWidth (uint32_t frequency, uint32_t width) const
948 {
949  NS_LOG_FUNCTION (this << frequency << width);
950  bool found = false;
951  FrequencyWidthPair f = std::make_pair (frequency, width);
952  ChannelToFrequencyWidthMap::const_iterator it = m_channelToFrequencyWidth.begin ();
953  while (it != m_channelToFrequencyWidth.end ())
954  {
955  if (it->second == f)
956  {
957  found = true;
958  break;
959  }
960  ++it;
961  }
962  if (found)
963  {
964  NS_LOG_DEBUG ("Found, returning " << it->first.first);
965  return (it->first.first);
966  }
967  else
968  {
969  NS_LOG_DEBUG ("Not found, returning 0");
970  return 0;
971  }
972 }
973 
974 void
975 WifiPhy::ConfigureChannelForStandard (enum WifiPhyStandard standard)
976 {
977  NS_LOG_FUNCTION (this << standard);
978  // If the user has configured both Frequency and ChannelNumber, Frequency
979  // takes precedence
980  if (GetFrequency () != 0)
981  {
982  // If Frequency is already set, then see whether a ChannelNumber can
983  // be found that matches Frequency and ChannelWidth. If so, configure
984  // the ChannelNumber to that channel number. If not, set
985  // ChannelNumber to zero.
986  NS_LOG_DEBUG ("Frequency set; checking whether a channel number corresponds");
987  uint32_t channelNumberSearched = FindChannelNumberForFrequencyWidth (GetFrequency (), GetChannelWidth ());
988  if (channelNumberSearched)
989  {
990  NS_LOG_DEBUG ("Channel number found; setting to " << channelNumberSearched);
991  SetChannelNumber (channelNumberSearched);
992  }
993  else
994  {
995  NS_LOG_DEBUG ("Channel number not found; setting to zero");
996  SetChannelNumber (0);
997  }
998  }
999  else if (GetChannelNumber () != 0)
1000  {
1001  // If the channel number is known for this particular standard or for
1002  // the unspecified standard, configure using the known values;
1003  // otherwise, this is a configuration error
1004  NS_LOG_DEBUG ("Configuring for channel number " << GetChannelNumber ());
1005  FrequencyWidthPair f = GetFrequencyWidthForChannelNumberStandard (GetChannelNumber (), standard);
1006  if (f.first == 0)
1007  {
1008  // the specific pair of number/standard is not known
1009  NS_LOG_DEBUG ("Falling back to check WIFI_PHY_STANDARD_UNSPECIFIED");
1010  f = GetFrequencyWidthForChannelNumberStandard (GetChannelNumber (), WIFI_PHY_STANDARD_UNSPECIFIED);
1011  }
1012  if (f.first == 0)
1013  {
1014  NS_FATAL_ERROR ("Error, ChannelNumber " << GetChannelNumber () << " is unknown for this standard");
1015  }
1016  else
1017  {
1018  NS_LOG_DEBUG ("Setting frequency to " << f.first << "; width to " << f.second);
1019  SetFrequency (f.first);
1020  SetChannelWidth (f.second);
1021  }
1022  }
1023 }
1024 
1025 void
1026 WifiPhy::ConfigureStandard (enum WifiPhyStandard standard)
1027 {
1028  NS_LOG_FUNCTION (this << standard);
1029  m_standard = standard;
1030  m_isConstructed = true;
1031  if (m_frequencyChannelNumberInitialized == false)
1032  {
1033  InitializeFrequencyChannelNumber ();
1034  }
1035  if (GetFrequency () == 0 && GetChannelNumber () == 0)
1036  {
1037  ConfigureDefaultsForStandard (standard);
1038  }
1039  else
1040  {
1041  // The user has configured either (or both) Frequency or ChannelNumber
1042  ConfigureChannelForStandard (standard);
1043  }
1044  switch (standard)
1045  {
1046  case WIFI_PHY_STANDARD_80211a:
1047  Configure80211a ();
1048  break;
1049  case WIFI_PHY_STANDARD_80211b:
1050  Configure80211b ();
1051  break;
1052  case WIFI_PHY_STANDARD_80211g:
1053  Configure80211g ();
1054  break;
1055  case WIFI_PHY_STANDARD_80211_10MHZ:
1056  Configure80211_10Mhz ();
1057  break;
1058  case WIFI_PHY_STANDARD_80211_5MHZ:
1059  Configure80211_5Mhz ();
1060  break;
1061  case WIFI_PHY_STANDARD_holland:
1062  ConfigureHolland ();
1063  break;
1064  case WIFI_PHY_STANDARD_80211n_2_4GHZ:
1065  Configure80211n ();
1066  break;
1067  case WIFI_PHY_STANDARD_80211n_5GHZ:
1068  Configure80211n ();
1069  break;
1070  case WIFI_PHY_STANDARD_80211ac:
1071  Configure80211ac ();
1072  break;
1073  default:
1074  NS_ASSERT (false);
1075  break;
1076  }
1077 }
1078 
1079 enum WifiPhyStandard
1080 WifiPhy::GetStandard (void) const
1081 {
1082  return m_standard;
1083 }
1084 
1085 void
1086 WifiPhy::SetFrequency (uint32_t frequency)
1087 {
1088  NS_LOG_FUNCTION (this << frequency);
1089  if (m_isConstructed == false)
1090  {
1091  NS_LOG_DEBUG ("Saving frequency configuration for initialization");
1092  m_initialFrequency = frequency;
1093  return;
1094  }
1095  if (GetFrequency () == frequency)
1096  {
1097  NS_LOG_DEBUG ("No frequency change requested");
1098  return;
1099  }
1100  if (frequency == 0)
1101  {
1102  DoFrequencySwitch (0);
1103  NS_LOG_DEBUG ("Setting frequency and channel number to zero");
1104  m_channelCenterFrequency = 0;
1105  m_channelNumber = 0;
1106  return;
1107  }
1108  // If the user has configured both Frequency and ChannelNumber, Frequency
1109  // takes precedence. Lookup the channel number corresponding to the
1110  // requested frequency.
1111  uint16_t nch = FindChannelNumberForFrequencyWidth (frequency, GetChannelWidth ());
1112  if (nch != 0)
1113  {
1114  NS_LOG_DEBUG ("Setting frequency " << frequency << " corresponds to channel " << nch);
1115  if (DoFrequencySwitch (frequency))
1116  {
1117  NS_LOG_DEBUG ("Channel frequency switched to " << frequency << "; channel number to " << nch);
1118  m_channelCenterFrequency = frequency;
1119  m_channelNumber = nch;
1120  }
1121  else
1122  {
1123  NS_LOG_DEBUG ("Suppressing reassignment of frequency");
1124  }
1125  }
1126  else
1127  {
1128  NS_LOG_DEBUG ("Channel number is unknown for frequency " << frequency);
1129  if (DoFrequencySwitch (frequency))
1130  {
1131  NS_LOG_DEBUG ("Channel frequency switched to " << frequency << "; channel number to " << 0);
1132  m_channelCenterFrequency = frequency;
1133  m_channelNumber = 0;
1134  }
1135  else
1136  {
1137  NS_LOG_DEBUG ("Suppressing reassignment of frequency");
1138  }
1139  }
1140 }
1141 
1142 uint32_t
1143 WifiPhy::GetFrequency (void) const
1144 {
1145  return m_channelCenterFrequency;
1146 }
1147 
1148 void
1149 WifiPhy::SetChannelWidth (uint32_t channelwidth)
1150 {
1151  NS_ASSERT_MSG (channelwidth == 5 || channelwidth == 10 || channelwidth == 20 || channelwidth == 22 || channelwidth == 40 || channelwidth == 80 || channelwidth == 160, "wrong channel width value");
1152  m_channelWidth = channelwidth;
1153  AddSupportedChannelWidth (channelwidth);
1154 }
1155 
1156 uint32_t
1157 WifiPhy::GetChannelWidth (void) const
1158 {
1159  return m_channelWidth;
1160 }
1161 
1162 void
1163 WifiPhy::SetNumberOfTransmitAntennas (uint32_t tx)
1164 {
1165  m_numberOfTransmitters = tx;
1166  ConfigureHtDeviceMcsSet ();
1167 }
1168 
1169 void
1170 WifiPhy::SetNumberOfReceiveAntennas (uint32_t rx)
1171 {
1172  m_numberOfReceivers = rx;
1173 }
1174 
1175 uint32_t
1176 WifiPhy::GetNumberOfTransmitAntennas (void) const
1177 {
1178  return m_numberOfTransmitters;
1179 }
1180 
1181 uint32_t
1182 WifiPhy::GetNumberOfReceiveAntennas (void) const
1183 {
1184  return m_numberOfReceivers;
1185 }
1186 
1187 uint8_t
1188 WifiPhy::GetSupportedRxSpatialStreams (void) const
1189 {
1190  return (static_cast<uint8_t> (GetNumberOfReceiveAntennas ()));
1191 }
1192 
1193 uint8_t
1194 WifiPhy::GetSupportedTxSpatialStreams (void) const
1195 {
1196  return (static_cast<uint8_t> (GetNumberOfTransmitAntennas ()));
1197 }
1198 
1199 uint32_t
1200 WifiPhy::GetNBssMembershipSelectors (void) const
1201 {
1202  return m_bssMembershipSelectorSet.size ();
1203 }
1204 
1205 uint32_t
1206 WifiPhy::GetBssMembershipSelector (uint32_t selector) const
1207 {
1208  return m_bssMembershipSelectorSet[selector];
1209 }
1210 
1211 WifiModeList
1212 WifiPhy::GetMembershipSelectorModes (uint32_t selector)
1213 {
1214  uint32_t id = GetBssMembershipSelector (selector);
1215  WifiModeList supportedmodes;
1216  if (id == HT_PHY || id == VHT_PHY)
1217  {
1218  //mandatory MCS 0 to 7
1219  supportedmodes.push_back (WifiPhy::GetHtMcs0 ());
1220  supportedmodes.push_back (WifiPhy::GetHtMcs1 ());
1221  supportedmodes.push_back (WifiPhy::GetHtMcs2 ());
1222  supportedmodes.push_back (WifiPhy::GetHtMcs3 ());
1223  supportedmodes.push_back (WifiPhy::GetHtMcs4 ());
1224  supportedmodes.push_back (WifiPhy::GetHtMcs5 ());
1225  supportedmodes.push_back (WifiPhy::GetHtMcs6 ());
1226  supportedmodes.push_back (WifiPhy::GetHtMcs7 ());
1227  }
1228  if (id == VHT_PHY)
1229  {
1230  //mandatory MCS 0 to 9
1231  supportedmodes.push_back (WifiPhy::GetVhtMcs0 ());
1232  supportedmodes.push_back (WifiPhy::GetVhtMcs1 ());
1233  supportedmodes.push_back (WifiPhy::GetVhtMcs2 ());
1234  supportedmodes.push_back (WifiPhy::GetVhtMcs3 ());
1235  supportedmodes.push_back (WifiPhy::GetVhtMcs4 ());
1236  supportedmodes.push_back (WifiPhy::GetVhtMcs5 ());
1237  supportedmodes.push_back (WifiPhy::GetVhtMcs6 ());
1238  supportedmodes.push_back (WifiPhy::GetVhtMcs7 ());
1239  supportedmodes.push_back (WifiPhy::GetVhtMcs8 ());
1240  supportedmodes.push_back (WifiPhy::GetVhtMcs9 ());
1241  }
1242  return supportedmodes;
1243 }
1244 
1245 void
1246 WifiPhy::AddSupportedChannelWidth (uint32_t width)
1247 {
1248  NS_LOG_FUNCTION (this << width);
1249  for (std::vector<uint32_t>::size_type i = 0; i != m_supportedChannelWidthSet.size (); i++)
1250  {
1251  if (m_supportedChannelWidthSet[i] == width)
1252  {
1253  return;
1254  }
1255  }
1256  NS_LOG_FUNCTION ("Adding " << width << " to supported channel width set");
1257  m_supportedChannelWidthSet.push_back (width);
1258 }
1259 
1260 std::vector<uint32_t>
1261 WifiPhy::GetSupportedChannelWidthSet (void) const
1262 {
1263  return m_supportedChannelWidthSet;
1264 }
1265 
1266 WifiPhy::FrequencyWidthPair
1267 WifiPhy::GetFrequencyWidthForChannelNumberStandard (uint16_t channelNumber, enum WifiPhyStandard standard) const
1268 {
1269  ChannelNumberStandardPair p = std::make_pair (channelNumber, standard);
1270  FrequencyWidthPair f = m_channelToFrequencyWidth[p];
1271  return f;
1272 }
1273 
1274 void
1275 WifiPhy::SetChannelNumber (uint16_t nch)
1276 {
1277  NS_LOG_FUNCTION (this << nch);
1278  if (m_isConstructed == false)
1279  {
1280  NS_LOG_DEBUG ("Saving channel number configuration for initialization");
1281  m_initialChannelNumber = nch;
1282  return;
1283  }
1284  if (GetChannelNumber () == nch)
1285  {
1286  NS_LOG_DEBUG ("No channel change requested");
1287  return;
1288  }
1289  if (nch == 0)
1290  {
1291  // This case corresponds to when there is not a known channel
1292  // number for the requested frequency. There is no need to call
1293  // DoChannelSwitch () because DoFrequencySwitch () should have been
1294  // called by the client
1295  NS_LOG_DEBUG ("Setting channel number to zero");
1296  m_channelNumber = 0;
1297  return;
1298  }
1299 
1300  // First make sure that the channel number is defined for the standard
1301  // in use
1302  FrequencyWidthPair f = GetFrequencyWidthForChannelNumberStandard (nch, GetStandard ());
1303  if (f.first == 0)
1304  {
1305  f = GetFrequencyWidthForChannelNumberStandard (nch, WIFI_PHY_STANDARD_UNSPECIFIED);
1306  }
1307  if (f.first != 0)
1308  {
1309  if (DoChannelSwitch (nch))
1310  {
1311  NS_LOG_DEBUG ("Setting frequency to " << f.first << "; width to " << f.second);
1312  m_channelCenterFrequency = f.first;
1313  SetChannelWidth (f.second);
1314  m_channelNumber = nch;
1315  }
1316  else
1317  {
1318  // Subclass may have suppressed (e.g. waiting for state change)
1319  NS_LOG_DEBUG ("Channel switch suppressed");
1320  }
1321  }
1322  else
1323  {
1324  NS_FATAL_ERROR ("Frequency not found for channel number " << nch);
1325  }
1326 }
1327 
1328 uint16_t
1329 WifiPhy::GetChannelNumber (void) const
1330 {
1331  return m_channelNumber;
1332 }
1333 
1334 bool
1335 WifiPhy::DoChannelSwitch (uint16_t nch)
1336 {
1337  return true;
1338 }
1339 
1340 bool
1341 WifiPhy::DoFrequencySwitch (uint32_t frequency)
1342 {
1343  return true;
1344 }
1345 
1346 WifiMode
1347 WifiPhy::GetHtPlcpHeaderMode (WifiMode payloadMode)
1348 {
1349  return WifiPhy::GetHtMcs0 ();
1350 }
1351 
1352 WifiMode
1353 WifiPhy::GetVhtPlcpHeaderMode (WifiMode payloadMode)
1354 {
1355  return WifiPhy::GetVhtMcs0 ();
1356 }
1357 
1358 Time
1359 WifiPhy::GetPlcpHtTrainingSymbolDuration (WifiPreamble preamble, WifiTxVector txVector)
1360 {
1361  uint8_t Ndltf, Neltf;
1362  //We suppose here that STBC = 0.
1363  //If STBC > 0, we need a different mapping between Nss and Nltf (IEEE 802.11n-2012 standard, page 1682).
1364  if (txVector.GetNss () < 3)
1365  {
1366  Ndltf = txVector.GetNss ();
1367  }
1368  else if (txVector.GetNss () < 5)
1369  {
1370  Ndltf = 4;
1371  }
1372  else if (txVector.GetNss () < 7)
1373  {
1374  Ndltf = 6;
1375  }
1376  else
1377  {
1378  Ndltf = 8;
1379  }
1380 
1381  if (txVector.GetNess () < 3)
1382  {
1383  Neltf = txVector.GetNess ();
1384  }
1385  else
1386  {
1387  Neltf = 4;
1388  }
1389 
1390  switch (preamble)
1391  {
1392  case WIFI_PREAMBLE_HT_MF:
1393  return MicroSeconds (4 + (4 * Ndltf) + (4 * Neltf));
1394  case WIFI_PREAMBLE_HT_GF:
1395  return MicroSeconds ((4 * Ndltf) + (4 * Neltf));
1396  case WIFI_PREAMBLE_VHT:
1397  return MicroSeconds (4 + (4 * Ndltf));
1398  default:
1399  //no training for non HT
1400  return MicroSeconds (0);
1401  }
1402 }
1403 
1404 Time
1405 WifiPhy::GetPlcpHtSigHeaderDuration (WifiPreamble preamble)
1406 {
1407  switch (preamble)
1408  {
1409  case WIFI_PREAMBLE_HT_MF:
1410  case WIFI_PREAMBLE_HT_GF:
1411  //HT-SIG
1412  return MicroSeconds (8);
1413  default:
1414  //no HT-SIG for non HT
1415  return MicroSeconds (0);
1416  }
1417 }
1418 
1419 Time
1420 WifiPhy::GetPlcpVhtSigA1Duration (WifiPreamble preamble)
1421 {
1422  switch (preamble)
1423  {
1424  case WIFI_PREAMBLE_VHT:
1425  //VHT-SIG-A1
1426  return MicroSeconds (4);
1427  default:
1428  // no VHT-SIG-A1 for non VHT
1429  return MicroSeconds (0);
1430  }
1431 }
1432 
1433 Time
1434 WifiPhy::GetPlcpVhtSigA2Duration (WifiPreamble preamble)
1435 {
1436  switch (preamble)
1437  {
1438  case WIFI_PREAMBLE_VHT:
1439  //VHT-SIG-A2
1440  return MicroSeconds (4);
1441  default:
1442  // no VHT-SIG-A2 for non VHT
1443  return MicroSeconds (0);
1444  }
1445 }
1446 
1447 Time
1448 WifiPhy::GetPlcpVhtSigBDuration (WifiPreamble preamble)
1449 {
1450  switch (preamble)
1451  {
1452  case WIFI_PREAMBLE_VHT:
1453  //VHT-SIG-B
1454  return MicroSeconds (4);
1455  default:
1456  // no VHT-SIG-B for non VHT
1457  return MicroSeconds (0);
1458  }
1459 }
1460 
1461 WifiMode
1462 WifiPhy::GetPlcpHeaderMode (WifiMode payloadMode, WifiPreamble preamble, WifiTxVector txVector)
1463 {
1464  switch (payloadMode.GetModulationClass ())
1465  {
1466  case WIFI_MOD_CLASS_OFDM:
1467  case WIFI_MOD_CLASS_HT:
1468  case WIFI_MOD_CLASS_VHT:
1469  switch (txVector.GetChannelWidth ())
1470  {
1471  case 5:
1472  return WifiPhy::GetOfdmRate1_5MbpsBW5MHz ();
1473  case 10:
1474  return WifiPhy::GetOfdmRate3MbpsBW10MHz ();
1475  case 20:
1476  case 40:
1477  case 80:
1478  case 160:
1479  default:
1480  //(Section 18.3.2 "PLCP frame format"; IEEE Std 802.11-2012)
1481  //actually this is only the first part of the PlcpHeader,
1482  //because the last 16 bits of the PlcpHeader are using the
1483  //same mode of the payload
1484  return WifiPhy::GetOfdmRate6Mbps ();
1485  }
1486  case WIFI_MOD_CLASS_ERP_OFDM:
1487  return WifiPhy::GetErpOfdmRate6Mbps ();
1488  case WIFI_MOD_CLASS_DSSS:
1489  case WIFI_MOD_CLASS_HR_DSSS:
1490  if (preamble == WIFI_PREAMBLE_LONG || payloadMode == WifiPhy::GetDsssRate1Mbps ())
1491  {
1492  //(Section 16.2.3 "PLCP field definitions" and Section 17.2.2.2 "Long PPDU format"; IEEE Std 802.11-2012)
1493  return WifiPhy::GetDsssRate1Mbps ();
1494  }
1495  else //WIFI_PREAMBLE_SHORT
1496  {
1497  //(Section 17.2.2.3 "Short PPDU format"; IEEE Std 802.11-2012)
1498  return WifiPhy::GetDsssRate2Mbps ();
1499  }
1500  default:
1501  NS_FATAL_ERROR ("unsupported modulation class");
1502  return WifiMode ();
1503  }
1504 }
1505 
1506 Time
1507 WifiPhy::GetPlcpHeaderDuration (WifiTxVector txVector, WifiPreamble preamble)
1508 {
1509  if (preamble == WIFI_PREAMBLE_NONE)
1510  {
1511  return MicroSeconds (0);
1512  }
1513  switch (txVector.GetMode ().GetModulationClass ())
1514  {
1515  case WIFI_MOD_CLASS_OFDM:
1516  {
1517  switch (txVector.GetChannelWidth ())
1518  {
1519  case 20:
1520  default:
1521  //(Section 18.3.3 "PLCP preamble (SYNC))" and Figure 18-4 "OFDM training structure"; IEEE Std 802.11-2012)
1522  //also (Section 18.3.2.4 "Timing related parameters" Table 18-5 "Timing-related parameters"; IEEE Std 802.11-2012)
1523  //We return the duration of the SIGNAL field only, since the
1524  //SERVICE field (which strictly speaking belongs to the PLCP
1525  //header, see Section 18.3.2 and Figure 18-1) is sent using the
1526  //payload mode.
1527  return MicroSeconds (4);
1528  case 10:
1529  //(Section 18.3.2.4 "Timing related parameters" Table 18-5 "Timing-related parameters"; IEEE Std 802.11-2012)
1530  return MicroSeconds (8);
1531  case 5:
1532  //(Section 18.3.2.4 "Timing related parameters" Table 18-5 "Timing-related parameters"; IEEE Std 802.11-2012)
1533  return MicroSeconds (16);
1534  }
1535  }
1536  case WIFI_MOD_CLASS_HT:
1537  {
1538  //L-SIG
1539  //IEEE 802.11n Figure 20.1
1540  switch (preamble)
1541  {
1542  case WIFI_PREAMBLE_HT_MF:
1543  default:
1544  return MicroSeconds (4);
1545  case WIFI_PREAMBLE_HT_GF:
1546  return MicroSeconds (0);
1547  }
1548  }
1549  case WIFI_MOD_CLASS_VHT:
1550  case WIFI_MOD_CLASS_ERP_OFDM:
1551  return MicroSeconds (4);
1552  case WIFI_MOD_CLASS_DSSS:
1553  case WIFI_MOD_CLASS_HR_DSSS:
1554  if ((preamble == WIFI_PREAMBLE_SHORT) && (txVector.GetMode ().GetDataRate (22, 0, 1) > 1000000))
1555  {
1556  //(Section 17.2.2.3 "Short PPDU format" and Figure 17-2 "Short PPDU format"; IEEE Std 802.11-2012)
1557  return MicroSeconds (24);
1558  }
1559  else //WIFI_PREAMBLE_LONG
1560  {
1561  //(Section 17.2.2.2 "Long PPDU format" and Figure 17-1 "Short PPDU format"; IEEE Std 802.11-2012)
1562  return MicroSeconds (48);
1563  }
1564  default:
1565  NS_FATAL_ERROR ("unsupported modulation class");
1566  return MicroSeconds (0);
1567  }
1568 }
1569 
1570 Time
1571 WifiPhy::GetPlcpPreambleDuration (WifiTxVector txVector, WifiPreamble preamble)
1572 {
1573  if (preamble == WIFI_PREAMBLE_NONE)
1574  {
1575  return MicroSeconds (0);
1576  }
1577  switch (txVector.GetMode ().GetModulationClass ())
1578  {
1579  case WIFI_MOD_CLASS_OFDM:
1580  {
1581  switch (txVector.GetChannelWidth ())
1582  {
1583  case 20:
1584  default:
1585  //(Section 18.3.3 "PLCP preamble (SYNC))" Figure 18-4 "OFDM training structure"
1586  //also Section 18.3.2.3 "Modulation-dependent parameters" Table 18-4 "Modulation-dependent parameters"; IEEE Std 802.11-2012)
1587  return MicroSeconds (16);
1588  case 10:
1589  //(Section 18.3.3 "PLCP preamble (SYNC))" Figure 18-4 "OFDM training structure"
1590  //also Section 18.3.2.3 "Modulation-dependent parameters" Table 18-4 "Modulation-dependent parameters"; IEEE Std 802.11-2012)
1591  return MicroSeconds (32);
1592  case 5:
1593  //(Section 18.3.3 "PLCP preamble (SYNC))" Figure 18-4 "OFDM training structure"
1594  //also Section 18.3.2.3 "Modulation-dependent parameters" Table 18-4 "Modulation-dependent parameters"; IEEE Std 802.11-2012)
1595  return MicroSeconds (64);
1596  }
1597  }
1598  case WIFI_MOD_CLASS_VHT:
1599  case WIFI_MOD_CLASS_HT:
1600  //IEEE 802.11n Figure 20.1 the training symbols before L_SIG or HT_SIG
1601  return MicroSeconds (16);
1602  case WIFI_MOD_CLASS_ERP_OFDM:
1603  return MicroSeconds (16);
1604  case WIFI_MOD_CLASS_DSSS:
1605  case WIFI_MOD_CLASS_HR_DSSS:
1606  if ((preamble == WIFI_PREAMBLE_SHORT) && (txVector.GetMode ().GetDataRate (22, 0, 1) > 1000000))
1607  {
1608  //(Section 17.2.2.3 "Short PPDU format)" Figure 17-2 "Short PPDU format"; IEEE Std 802.11-2012)
1609  return MicroSeconds (72);
1610  }
1611  else //WIFI_PREAMBLE_LONG
1612  {
1613  //(Section 17.2.2.2 "Long PPDU format)" Figure 17-1 "Long PPDU format"; IEEE Std 802.11-2012)
1614  return MicroSeconds (144);
1615  }
1616  default:
1617  NS_FATAL_ERROR ("unsupported modulation class");
1618  return MicroSeconds (0);
1619  }
1620 }
1621 
1622 Time
1623 WifiPhy::GetPayloadDuration (uint32_t size, WifiTxVector txVector, WifiPreamble preamble, double frequency)
1624 {
1625  return GetPayloadDuration (size, txVector, preamble, frequency, NORMAL_MPDU, 0);
1626 }
1627 
1628 Time
1629 WifiPhy::GetPayloadDuration (uint32_t size, WifiTxVector txVector, WifiPreamble preamble, double frequency, enum mpduType mpdutype, uint8_t incFlag)
1630 {
1631  WifiMode payloadMode = txVector.GetMode ();
1632  NS_LOG_FUNCTION (size << payloadMode);
1633 
1634  switch (payloadMode.GetModulationClass ())
1635  {
1636  case WIFI_MOD_CLASS_OFDM:
1637  case WIFI_MOD_CLASS_ERP_OFDM:
1638  {
1639  //(Section 18.3.2.4 "Timing related parameters" Table 18-5 "Timing-related parameters"; IEEE Std 802.11-2012
1640  //corresponds to T_{SYM} in the table)
1641  Time symbolDuration;
1642 
1643  switch (txVector.GetChannelWidth ())
1644  {
1645  case 20:
1646  default:
1647  symbolDuration = MicroSeconds (4);
1648  break;
1649  case 10:
1650  symbolDuration = MicroSeconds (8);
1651  break;
1652  case 5:
1653  symbolDuration = MicroSeconds (16);
1654  break;
1655  }
1656 
1657  //(Section 18.3.2.3 "Modulation-dependent parameters" Table 18-4 "Modulation-dependent parameters"; IEEE Std 802.11-2012)
1658  //corresponds to N_{DBPS} in the table
1659  double numDataBitsPerSymbol = payloadMode.GetDataRate (txVector.GetChannelWidth (), 0, 1) * symbolDuration.GetNanoSeconds () / 1e9;
1660  double numSymbols;
1661 
1662  if (mpdutype == MPDU_IN_AGGREGATE && preamble != WIFI_PREAMBLE_NONE)
1663  {
1664  //First packet in an A-MPDU
1665  numSymbols = ((16 + size * 8.0 + 6) / numDataBitsPerSymbol);
1666  if (incFlag == 1)
1667  {
1668  m_totalAmpduSize += size;
1669  m_totalAmpduNumSymbols += numSymbols;
1670  }
1671  }
1672  else if (mpdutype == MPDU_IN_AGGREGATE && preamble == WIFI_PREAMBLE_NONE)
1673  {
1674  //consecutive packets in an A-MPDU
1675  numSymbols = ((size * 8.0) / numDataBitsPerSymbol);
1676  if (incFlag == 1)
1677  {
1678  m_totalAmpduSize += size;
1679  m_totalAmpduNumSymbols += numSymbols;
1680  }
1681  }
1682  else if (mpdutype == LAST_MPDU_IN_AGGREGATE && preamble == WIFI_PREAMBLE_NONE)
1683  {
1684  //last packet in an A-MPDU
1685  uint32_t totalAmpduSize = m_totalAmpduSize + size;
1686  numSymbols = lrint (ceil ((16 + totalAmpduSize * 8.0 + 6) / numDataBitsPerSymbol));
1687  NS_ASSERT (m_totalAmpduNumSymbols <= numSymbols);
1688  numSymbols -= m_totalAmpduNumSymbols;
1689  if (incFlag == 1)
1690  {
1691  m_totalAmpduSize = 0;
1692  m_totalAmpduNumSymbols = 0;
1693  }
1694  }
1695  else if (mpdutype == NORMAL_MPDU && preamble != WIFI_PREAMBLE_NONE)
1696  {
1697  //Not an A-MPDU
1698  numSymbols = lrint (ceil ((16 + size * 8.0 + 6.0) / numDataBitsPerSymbol));
1699  }
1700  else
1701  {
1702  NS_FATAL_ERROR ("Wrong combination of preamble and packet type");
1703  }
1704 
1705  //Add signal extension for ERP PHY
1706  if (payloadMode.GetModulationClass () == WIFI_MOD_CLASS_ERP_OFDM)
1707  {
1708  return FemtoSeconds (numSymbols * symbolDuration.GetFemtoSeconds ()) + MicroSeconds (6);
1709  }
1710  else
1711  {
1712  return FemtoSeconds (numSymbols * symbolDuration.GetFemtoSeconds ());
1713  }
1714  }
1715  case WIFI_MOD_CLASS_HT:
1716  case WIFI_MOD_CLASS_VHT:
1717  {
1718  Time symbolDuration;
1719  double m_Stbc;
1720  //if short GI data rate is used then symbol duration is 3.6us else symbol duration is 4us
1721  //In the future has to create a stationmanager that only uses these data rates if sender and reciever support GI
1722  if (txVector.IsShortGuardInterval ())
1723  {
1724  symbolDuration = NanoSeconds (3600);
1725  }
1726  else
1727  {
1728  symbolDuration = MicroSeconds (4);
1729  }
1730 
1731  if (txVector.IsStbc ())
1732  {
1733  m_Stbc = 2;
1734  }
1735  else
1736  {
1737  m_Stbc = 1;
1738  }
1739 
1740  //check tables 20-35 and 20-36 in the .11n standard to get cases when nes = 2
1741  double Nes = 1;
1742  if (payloadMode.GetUniqueName () == "HtMcs21"
1743  || payloadMode.GetUniqueName () == "HtMcs22"
1744  || payloadMode.GetUniqueName () == "HtMcs23"
1745  || payloadMode.GetUniqueName () == "HtMcs28"
1746  || payloadMode.GetUniqueName () == "HtMcs29"
1747  || payloadMode.GetUniqueName () == "HtMcs30"
1748  || payloadMode.GetUniqueName () == "HtMcs31")
1749  {
1750  Nes = 2;
1751  }
1752  //check tables 22-30 to 22-61 in the .11ac standard to get cases when nes > 1
1753  //todo: improve logic to reduce the number of if cases
1754  //todo: extend to NSS > 4 for VHT rates
1755  if (txVector.GetChannelWidth () == 40
1756  && txVector.GetNss () == 3
1757  && payloadMode.GetMcsValue () >= 8)
1758  {
1759  Nes = 2;
1760  }
1761  if (txVector.GetChannelWidth () == 80
1762  && txVector.GetNss () == 2
1763  && payloadMode.GetMcsValue () >= 7)
1764  {
1765  Nes = 2;
1766  }
1767  if (txVector.GetChannelWidth () == 80
1768  && txVector.GetNss () == 3
1769  && payloadMode.GetMcsValue () >= 7)
1770  {
1771  Nes = 2;
1772  }
1773  if (txVector.GetChannelWidth () == 80
1774  && txVector.GetNss () == 3
1775  && payloadMode.GetMcsValue () == 9)
1776  {
1777  Nes = 3;
1778  }
1779  if (txVector.GetChannelWidth () == 80
1780  && txVector.GetNss () == 4
1781  && payloadMode.GetMcsValue () >= 4)
1782  {
1783  Nes = 2;
1784  }
1785  if (txVector.GetChannelWidth () == 80
1786  && txVector.GetNss () == 4
1787  && payloadMode.GetMcsValue () >= 7)
1788  {
1789  Nes = 3;
1790  }
1791  if (txVector.GetChannelWidth () == 160
1792  && payloadMode.GetMcsValue () >= 7)
1793  {
1794  Nes = 2;
1795  }
1796  if (txVector.GetChannelWidth () == 160
1797  && txVector.GetNss () == 2
1798  && payloadMode.GetMcsValue () >= 4)
1799  {
1800  Nes = 2;
1801  }
1802  if (txVector.GetChannelWidth () == 160
1803  && txVector.GetNss () == 2
1804  && payloadMode.GetMcsValue () >= 7)
1805  {
1806  Nes = 3;
1807  }
1808  if (txVector.GetChannelWidth () == 160
1809  && txVector.GetNss () == 3
1810  && payloadMode.GetMcsValue () >= 3)
1811  {
1812  Nes = 2;
1813  }
1814  if (txVector.GetChannelWidth () == 160
1815  && txVector.GetNss () == 3
1816  && payloadMode.GetMcsValue () >= 5)
1817  {
1818  Nes = 3;
1819  }
1820  if (txVector.GetChannelWidth () == 160
1821  && txVector.GetNss () == 3
1822  && payloadMode.GetMcsValue () >= 7)
1823  {
1824  Nes = 4;
1825  }
1826  if (txVector.GetChannelWidth () == 160
1827  && txVector.GetNss () == 4
1828  && payloadMode.GetMcsValue () >= 2)
1829  {
1830  Nes = 2;
1831  }
1832  if (txVector.GetChannelWidth () == 160
1833  && txVector.GetNss () == 4
1834  && payloadMode.GetMcsValue () >= 4)
1835  {
1836  Nes = 3;
1837  }
1838  if (txVector.GetChannelWidth () == 160
1839  && txVector.GetNss () == 4
1840  && payloadMode.GetMcsValue () >= 5)
1841  {
1842  Nes = 4;
1843  }
1844  if (txVector.GetChannelWidth () == 160
1845  && txVector.GetNss () == 4
1846  && payloadMode.GetMcsValue () >= 7)
1847  {
1848  Nes = 6;
1849  }
1850 
1851  //IEEE Std 802.11n, section 20.3.11, equation (20-32)
1852  double numDataBitsPerSymbol = payloadMode.GetDataRate (txVector.GetChannelWidth (), txVector.IsShortGuardInterval (), txVector.GetNss ()) * symbolDuration.GetNanoSeconds () / 1e9;
1853  double numSymbols;
1854 
1855  if (mpdutype == MPDU_IN_AGGREGATE && preamble != WIFI_PREAMBLE_NONE)
1856  {
1857  //First packet in an A-MPDU
1858  numSymbols = (m_Stbc * (16 + size * 8.0 + 6 * Nes) / (m_Stbc * numDataBitsPerSymbol));
1859  if (incFlag == 1)
1860  {
1861  m_totalAmpduSize += size;
1862  m_totalAmpduNumSymbols += numSymbols;
1863  }
1864  }
1865  else if (mpdutype == MPDU_IN_AGGREGATE && preamble == WIFI_PREAMBLE_NONE)
1866  {
1867  //consecutive packets in an A-MPDU
1868  numSymbols = (m_Stbc * size * 8.0) / (m_Stbc * numDataBitsPerSymbol);
1869  if (incFlag == 1)
1870  {
1871  m_totalAmpduSize += size;
1872  m_totalAmpduNumSymbols += numSymbols;
1873  }
1874  }
1875  else if (mpdutype == LAST_MPDU_IN_AGGREGATE && preamble == WIFI_PREAMBLE_NONE)
1876  {
1877  //last packet in an A-MPDU
1878  uint32_t totalAmpduSize = m_totalAmpduSize + size;
1879  numSymbols = lrint (m_Stbc * ceil ((16 + totalAmpduSize * 8.0 + 6 * Nes) / (m_Stbc * numDataBitsPerSymbol)));
1880  NS_ASSERT (m_totalAmpduNumSymbols <= numSymbols);
1881  numSymbols -= m_totalAmpduNumSymbols;
1882  if (incFlag == 1)
1883  {
1884  m_totalAmpduSize = 0;
1885  m_totalAmpduNumSymbols = 0;
1886  }
1887  }
1888  else if (mpdutype == NORMAL_MPDU && preamble != WIFI_PREAMBLE_NONE)
1889  {
1890  //Not an A-MPDU
1891  numSymbols = lrint (m_Stbc * ceil ((16 + size * 8.0 + 6.0 * Nes) / (m_Stbc * numDataBitsPerSymbol)));
1892  }
1893  else
1894  {
1895  NS_FATAL_ERROR ("Wrong combination of preamble and packet type");
1896  }
1897 
1898  if (payloadMode.GetModulationClass () == WIFI_MOD_CLASS_HT && frequency >= 2400 && frequency <= 2500 && ((mpdutype == NORMAL_MPDU && preamble != WIFI_PREAMBLE_NONE) || (mpdutype == LAST_MPDU_IN_AGGREGATE && preamble == WIFI_PREAMBLE_NONE))) //at 2.4 GHz
1899  {
1900  return FemtoSeconds (numSymbols * symbolDuration.GetFemtoSeconds ()) + MicroSeconds (6);
1901  }
1902  else //at 5 GHz
1903  {
1904  return FemtoSeconds (numSymbols * symbolDuration.GetFemtoSeconds ());
1905  }
1906  }
1907  case WIFI_MOD_CLASS_DSSS:
1908  case WIFI_MOD_CLASS_HR_DSSS:
1909  //(Section 17.2.3.6 "Long PLCP LENGTH field"; IEEE Std 802.11-2012)
1910  NS_LOG_LOGIC (" size=" << size
1911  << " mode=" << payloadMode
1912  << " rate=" << payloadMode.GetDataRate (22, 0, 1));
1913  return MicroSeconds (lrint (ceil ((size * 8.0) / (payloadMode.GetDataRate (22, 0, 1) / 1.0e6))));
1914  default:
1915  NS_FATAL_ERROR ("unsupported modulation class");
1916  return MicroSeconds (0);
1917  }
1918 }
1919 
1920 Time
1921 WifiPhy::CalculatePlcpPreambleAndHeaderDuration (WifiTxVector txVector, WifiPreamble preamble)
1922 {
1923  Time duration = GetPlcpPreambleDuration (txVector, preamble)
1924  + GetPlcpHeaderDuration (txVector, preamble)
1925  + GetPlcpHtSigHeaderDuration (preamble)
1926  + GetPlcpVhtSigA1Duration (preamble)
1927  + GetPlcpVhtSigA2Duration (preamble)
1928  + GetPlcpHtTrainingSymbolDuration (preamble, txVector)
1929  + GetPlcpVhtSigBDuration (preamble);
1930  return duration;
1931 }
1932 
1933 Time
1934 WifiPhy::CalculateTxDuration (uint32_t size, WifiTxVector txVector, WifiPreamble preamble, double frequency, enum mpduType mpdutype, uint8_t incFlag)
1935 {
1936  Time duration = CalculatePlcpPreambleAndHeaderDuration (txVector, preamble)
1937  + GetPayloadDuration (size, txVector, preamble, frequency, mpdutype, incFlag);
1938  return duration;
1939 }
1940 
1941 Time
1942 WifiPhy::CalculateTxDuration (uint32_t size, WifiTxVector txVector, WifiPreamble preamble, double frequency)
1943 {
1944  return CalculateTxDuration (size, txVector, preamble, frequency, NORMAL_MPDU, 0);
1945 }
1946 
1947 void
1948 WifiPhy::NotifyTxBegin (Ptr<const Packet> packet)
1949 {
1950  m_phyTxBeginTrace (packet);
1951 }
1952 
1953 void
1954 WifiPhy::NotifyTxEnd (Ptr<const Packet> packet)
1955 {
1956  m_phyTxEndTrace (packet);
1957 }
1958 
1959 void
1960 WifiPhy::NotifyTxDrop (Ptr<const Packet> packet)
1961 {
1962  m_phyTxDropTrace (packet);
1963 }
1964 
1965 void
1966 WifiPhy::NotifyRxBegin (Ptr<const Packet> packet)
1967 {
1968  m_phyRxBeginTrace (packet);
1969 }
1970 
1971 void
1972 WifiPhy::NotifyRxEnd (Ptr<const Packet> packet)
1973 {
1974  m_phyRxEndTrace (packet);
1975 }
1976 
1977 void
1978 WifiPhy::NotifyRxDrop (Ptr<const Packet> packet)
1979 {
1980  m_phyRxDropTrace (packet);
1981 }
1982 
1983 void
1984 WifiPhy::NotifyMonitorSniffRx (Ptr<const Packet> packet, uint16_t channelFreqMhz, uint16_t channelNumber, uint32_t rate, WifiPreamble preamble, WifiTxVector txVector, struct mpduInfo aMpdu, struct signalNoiseDbm signalNoise)
1985 {
1986  m_phyMonitorSniffRxTrace (packet, channelFreqMhz, channelNumber, rate, preamble, txVector, aMpdu, signalNoise);
1987 }
1988 
1989 void
1990 WifiPhy::NotifyMonitorSniffTx (Ptr<const Packet> packet, uint16_t channelFreqMhz, uint16_t channelNumber, uint32_t rate, WifiPreamble preamble, WifiTxVector txVector, struct mpduInfo aMpdu)
1991 {
1992  m_phyMonitorSniffTxTrace (packet, channelFreqMhz, channelNumber, rate, preamble, txVector, aMpdu);
1993 }
1994 
1995 
1996 // Clause 15 rates (DSSS)
1997 
1998 WifiMode
1999 WifiPhy::GetDsssRate1Mbps ()
2000 {
2001  static WifiMode mode =
2002  WifiModeFactory::CreateWifiMode ("DsssRate1Mbps",
2003  WIFI_MOD_CLASS_DSSS,
2004  true,
2005  WIFI_CODE_RATE_UNDEFINED,
2006  2);
2007  return mode;
2008 }
2009 
2010 WifiMode
2011 WifiPhy::GetDsssRate2Mbps ()
2012 {
2013  static WifiMode mode =
2014  WifiModeFactory::CreateWifiMode ("DsssRate2Mbps",
2015  WIFI_MOD_CLASS_DSSS,
2016  true,
2017  WIFI_CODE_RATE_UNDEFINED,
2018  4);
2019  return mode;
2020 }
2021 
2022 
2023 // Clause 18 rates (HR/DSSS)
2024 
2025 WifiMode
2026 WifiPhy::GetDsssRate5_5Mbps ()
2027 {
2028  static WifiMode mode =
2029  WifiModeFactory::CreateWifiMode ("DsssRate5_5Mbps",
2030  WIFI_MOD_CLASS_HR_DSSS,
2031  true,
2032  WIFI_CODE_RATE_UNDEFINED,
2033  16);
2034  return mode;
2035 }
2036 
2037 WifiMode
2038 WifiPhy::GetDsssRate11Mbps ()
2039 {
2040  static WifiMode mode =
2041  WifiModeFactory::CreateWifiMode ("DsssRate11Mbps",
2042  WIFI_MOD_CLASS_HR_DSSS,
2043  true,
2044  WIFI_CODE_RATE_UNDEFINED,
2045  256);
2046  return mode;
2047 }
2048 
2049 
2050 // Clause 19.5 rates (ERP-OFDM)
2051 
2052 WifiMode
2053 WifiPhy::GetErpOfdmRate6Mbps ()
2054 {
2055  static WifiMode mode =
2056  WifiModeFactory::CreateWifiMode ("ErpOfdmRate6Mbps",
2057  WIFI_MOD_CLASS_ERP_OFDM,
2058  true,
2059  WIFI_CODE_RATE_1_2,
2060  2);
2061  return mode;
2062 }
2063 
2064 WifiMode
2065 WifiPhy::GetErpOfdmRate9Mbps ()
2066 {
2067  static WifiMode mode =
2068  WifiModeFactory::CreateWifiMode ("ErpOfdmRate9Mbps",
2069  WIFI_MOD_CLASS_ERP_OFDM,
2070  false,
2071  WIFI_CODE_RATE_3_4,
2072  2);
2073  return mode;
2074 }
2075 
2076 WifiMode
2077 WifiPhy::GetErpOfdmRate12Mbps ()
2078 {
2079  static WifiMode mode =
2080  WifiModeFactory::CreateWifiMode ("ErpOfdmRate12Mbps",
2081  WIFI_MOD_CLASS_ERP_OFDM,
2082  true,
2083  WIFI_CODE_RATE_1_2,
2084  4);
2085  return mode;
2086 }
2087 
2088 WifiMode
2089 WifiPhy::GetErpOfdmRate18Mbps ()
2090 {
2091  static WifiMode mode =
2092  WifiModeFactory::CreateWifiMode ("ErpOfdmRate18Mbps",
2093  WIFI_MOD_CLASS_ERP_OFDM,
2094  false,
2095  WIFI_CODE_RATE_3_4,
2096  4);
2097  return mode;
2098 }
2099 
2100 WifiMode
2101 WifiPhy::GetErpOfdmRate24Mbps ()
2102 {
2103  static WifiMode mode =
2104  WifiModeFactory::CreateWifiMode ("ErpOfdmRate24Mbps",
2105  WIFI_MOD_CLASS_ERP_OFDM,
2106  true,
2107  WIFI_CODE_RATE_1_2,
2108  16);
2109  return mode;
2110 }
2111 
2112 WifiMode
2113 WifiPhy::GetErpOfdmRate36Mbps ()
2114 {
2115  static WifiMode mode =
2116  WifiModeFactory::CreateWifiMode ("ErpOfdmRate36Mbps",
2117  WIFI_MOD_CLASS_ERP_OFDM,
2118  false,
2119  WIFI_CODE_RATE_3_4,
2120  16);
2121  return mode;
2122 }
2123 
2124 WifiMode
2125 WifiPhy::GetErpOfdmRate48Mbps ()
2126 {
2127  static WifiMode mode =
2128  WifiModeFactory::CreateWifiMode ("ErpOfdmRate48Mbps",
2129  WIFI_MOD_CLASS_ERP_OFDM,
2130  false,
2131  WIFI_CODE_RATE_2_3,
2132  64);
2133  return mode;
2134 }
2135 
2136 WifiMode
2137 WifiPhy::GetErpOfdmRate54Mbps ()
2138 {
2139  static WifiMode mode =
2140  WifiModeFactory::CreateWifiMode ("ErpOfdmRate54Mbps",
2141  WIFI_MOD_CLASS_ERP_OFDM,
2142  false,
2143  WIFI_CODE_RATE_3_4,
2144  64);
2145  return mode;
2146 }
2147 
2148 
2149 // Clause 17 rates (OFDM)
2150 
2151 WifiMode
2152 WifiPhy::GetOfdmRate6Mbps ()
2153 {
2154  static WifiMode mode =
2155  WifiModeFactory::CreateWifiMode ("OfdmRate6Mbps",
2156  WIFI_MOD_CLASS_OFDM,
2157  true,
2158  WIFI_CODE_RATE_1_2,
2159  2);
2160  return mode;
2161 }
2162 
2163 WifiMode
2164 WifiPhy::GetOfdmRate9Mbps ()
2165 {
2166  static WifiMode mode =
2167  WifiModeFactory::CreateWifiMode ("OfdmRate9Mbps",
2168  WIFI_MOD_CLASS_OFDM,
2169  false,
2170  WIFI_CODE_RATE_3_4,
2171  2);
2172  return mode;
2173 }
2174 
2175 WifiMode
2176 WifiPhy::GetOfdmRate12Mbps ()
2177 {
2178  static WifiMode mode =
2179  WifiModeFactory::CreateWifiMode ("OfdmRate12Mbps",
2180  WIFI_MOD_CLASS_OFDM,
2181  true,
2182  WIFI_CODE_RATE_1_2,
2183  4);
2184  return mode;
2185 }
2186 
2187 WifiMode
2188 WifiPhy::GetOfdmRate18Mbps ()
2189 {
2190  static WifiMode mode =
2191  WifiModeFactory::CreateWifiMode ("OfdmRate18Mbps",
2192  WIFI_MOD_CLASS_OFDM,
2193  false,
2194  WIFI_CODE_RATE_3_4,
2195  4);
2196  return mode;
2197 }
2198 
2199 WifiMode
2200 WifiPhy::GetOfdmRate24Mbps ()
2201 {
2202  static WifiMode mode =
2203  WifiModeFactory::CreateWifiMode ("OfdmRate24Mbps",
2204  WIFI_MOD_CLASS_OFDM,
2205  true,
2206  WIFI_CODE_RATE_1_2,
2207  16);
2208  return mode;
2209 }
2210 
2211 WifiMode
2212 WifiPhy::GetOfdmRate36Mbps ()
2213 {
2214  static WifiMode mode =
2215  WifiModeFactory::CreateWifiMode ("OfdmRate36Mbps",
2216  WIFI_MOD_CLASS_OFDM,
2217  false,
2218  WIFI_CODE_RATE_3_4,
2219  16);
2220  return mode;
2221 }
2222 
2223 WifiMode
2224 WifiPhy::GetOfdmRate48Mbps ()
2225 {
2226  static WifiMode mode =
2227  WifiModeFactory::CreateWifiMode ("OfdmRate48Mbps",
2228  WIFI_MOD_CLASS_OFDM,
2229  false,
2230  WIFI_CODE_RATE_2_3,
2231  64);
2232  return mode;
2233 }
2234 
2235 WifiMode
2236 WifiPhy::GetOfdmRate54Mbps ()
2237 {
2238  static WifiMode mode =
2239  WifiModeFactory::CreateWifiMode ("OfdmRate54Mbps",
2240  WIFI_MOD_CLASS_OFDM,
2241  false,
2242  WIFI_CODE_RATE_3_4,
2243  64);
2244  return mode;
2245 }
2246 
2247 
2248 // 10 MHz channel rates
2249 
2250 WifiMode
2251 WifiPhy::GetOfdmRate3MbpsBW10MHz ()
2252 {
2253  static WifiMode mode =
2254  WifiModeFactory::CreateWifiMode ("OfdmRate3MbpsBW10MHz",
2255  WIFI_MOD_CLASS_OFDM,
2256  true,
2257  WIFI_CODE_RATE_1_2,
2258  2);
2259  return mode;
2260 }
2261 
2262 WifiMode
2263 WifiPhy::GetOfdmRate4_5MbpsBW10MHz ()
2264 {
2265  static WifiMode mode =
2266  WifiModeFactory::CreateWifiMode ("OfdmRate4_5MbpsBW10MHz",
2267  WIFI_MOD_CLASS_OFDM,
2268  false,
2269  WIFI_CODE_RATE_3_4,
2270  2);
2271  return mode;
2272 }
2273 
2274 WifiMode
2275 WifiPhy::GetOfdmRate6MbpsBW10MHz ()
2276 {
2277  static WifiMode mode =
2278  WifiModeFactory::CreateWifiMode ("OfdmRate6MbpsBW10MHz",
2279  WIFI_MOD_CLASS_OFDM,
2280  true,
2281  WIFI_CODE_RATE_1_2,
2282  4);
2283  return mode;
2284 }
2285 
2286 WifiMode
2287 WifiPhy::GetOfdmRate9MbpsBW10MHz ()
2288 {
2289  static WifiMode mode =
2290  WifiModeFactory::CreateWifiMode ("OfdmRate9MbpsBW10MHz",
2291  WIFI_MOD_CLASS_OFDM,
2292  false,
2293  WIFI_CODE_RATE_3_4,
2294  4);
2295  return mode;
2296 }
2297 
2298 WifiMode
2299 WifiPhy::GetOfdmRate12MbpsBW10MHz ()
2300 {
2301  static WifiMode mode =
2302  WifiModeFactory::CreateWifiMode ("OfdmRate12MbpsBW10MHz",
2303  WIFI_MOD_CLASS_OFDM,
2304  true,
2305  WIFI_CODE_RATE_1_2,
2306  16);
2307  return mode;
2308 }
2309 
2310 WifiMode
2311 WifiPhy::GetOfdmRate18MbpsBW10MHz ()
2312 {
2313  static WifiMode mode =
2314  WifiModeFactory::CreateWifiMode ("OfdmRate18MbpsBW10MHz",
2315  WIFI_MOD_CLASS_OFDM,
2316  false,
2317  WIFI_CODE_RATE_3_4,
2318  16);
2319  return mode;
2320 }
2321 
2322 WifiMode
2323 WifiPhy::GetOfdmRate24MbpsBW10MHz ()
2324 {
2325  static WifiMode mode =
2326  WifiModeFactory::CreateWifiMode ("OfdmRate24MbpsBW10MHz",
2327  WIFI_MOD_CLASS_OFDM,
2328  false,
2329  WIFI_CODE_RATE_2_3,
2330  64);
2331  return mode;
2332 }
2333 
2334 WifiMode
2335 WifiPhy::GetOfdmRate27MbpsBW10MHz ()
2336 {
2337  static WifiMode mode =
2338  WifiModeFactory::CreateWifiMode ("OfdmRate27MbpsBW10MHz",
2339  WIFI_MOD_CLASS_OFDM,
2340  false,
2341  WIFI_CODE_RATE_3_4,
2342  64);
2343  return mode;
2344 }
2345 
2346 
2347 // 5 MHz channel rates
2348 
2349 WifiMode
2350 WifiPhy::GetOfdmRate1_5MbpsBW5MHz ()
2351 {
2352  static WifiMode mode =
2353  WifiModeFactory::CreateWifiMode ("OfdmRate1_5MbpsBW5MHz",
2354  WIFI_MOD_CLASS_OFDM,
2355  true,
2356  WIFI_CODE_RATE_1_2,
2357  2);
2358  return mode;
2359 }
2360 
2361 WifiMode
2362 WifiPhy::GetOfdmRate2_25MbpsBW5MHz ()
2363 {
2364  static WifiMode mode =
2365  WifiModeFactory::CreateWifiMode ("OfdmRate2_25MbpsBW5MHz",
2366  WIFI_MOD_CLASS_OFDM,
2367  false,
2368  WIFI_CODE_RATE_3_4,
2369  2);
2370  return mode;
2371 }
2372 
2373 WifiMode
2374 WifiPhy::GetOfdmRate3MbpsBW5MHz ()
2375 {
2376  static WifiMode mode =
2377  WifiModeFactory::CreateWifiMode ("OfdmRate3MbpsBW5MHz",
2378  WIFI_MOD_CLASS_OFDM,
2379  true,
2380  WIFI_CODE_RATE_1_2,
2381  4);
2382  return mode;
2383 }
2384 
2385 WifiMode
2386 WifiPhy::GetOfdmRate4_5MbpsBW5MHz ()
2387 {
2388  static WifiMode mode =
2389  WifiModeFactory::CreateWifiMode ("OfdmRate4_5MbpsBW5MHz",
2390  WIFI_MOD_CLASS_OFDM,
2391  false,
2392  WIFI_CODE_RATE_3_4,
2393  4);
2394  return mode;
2395 }
2396 
2397 WifiMode
2398 WifiPhy::GetOfdmRate6MbpsBW5MHz ()
2399 {
2400  static WifiMode mode =
2401  WifiModeFactory::CreateWifiMode ("OfdmRate6MbpsBW5MHz",
2402  WIFI_MOD_CLASS_OFDM,
2403  true,
2404  WIFI_CODE_RATE_1_2,
2405  16);
2406  return mode;
2407 }
2408 
2409 WifiMode
2410 WifiPhy::GetOfdmRate9MbpsBW5MHz ()
2411 {
2412  static WifiMode mode =
2413  WifiModeFactory::CreateWifiMode ("OfdmRate9MbpsBW5MHz",
2414  WIFI_MOD_CLASS_OFDM,
2415  false,
2416  WIFI_CODE_RATE_3_4,
2417  16);
2418  return mode;
2419 }
2420 
2421 WifiMode
2422 WifiPhy::GetOfdmRate12MbpsBW5MHz ()
2423 {
2424  static WifiMode mode =
2425  WifiModeFactory::CreateWifiMode ("OfdmRate12MbpsBW5MHz",
2426  WIFI_MOD_CLASS_OFDM,
2427  false,
2428  WIFI_CODE_RATE_2_3,
2429  64);
2430  return mode;
2431 }
2432 
2433 WifiMode
2434 WifiPhy::GetOfdmRate13_5MbpsBW5MHz ()
2435 {
2436  static WifiMode mode =
2437  WifiModeFactory::CreateWifiMode ("OfdmRate13_5MbpsBW5MHz",
2438  WIFI_MOD_CLASS_OFDM,
2439  false,
2440  WIFI_CODE_RATE_3_4,
2441  64);
2442  return mode;
2443 }
2444 
2445 
2446 // Clause 20
2447 
2448 WifiMode
2449 WifiPhy::GetHtMcs0 ()
2450 {
2451  static WifiMode mcs =
2452  WifiModeFactory::CreateWifiMcs ("HtMcs0", 0, WIFI_MOD_CLASS_HT);
2453  return mcs;
2454 }
2455 
2456 WifiMode
2457 WifiPhy::GetHtMcs1 ()
2458 {
2459  static WifiMode mcs =
2460  WifiModeFactory::CreateWifiMcs ("HtMcs1", 1, WIFI_MOD_CLASS_HT);
2461  return mcs;
2462 }
2463 
2464 WifiMode
2465 WifiPhy::GetHtMcs2 ()
2466 {
2467  static WifiMode mcs =
2468  WifiModeFactory::CreateWifiMcs ("HtMcs2", 2, WIFI_MOD_CLASS_HT);
2469  return mcs;
2470 }
2471 
2472 WifiMode
2473 WifiPhy::GetHtMcs3 ()
2474 {
2475  static WifiMode mcs =
2476  WifiModeFactory::CreateWifiMcs ("HtMcs3", 3, WIFI_MOD_CLASS_HT);
2477  return mcs;
2478 }
2479 
2480 WifiMode
2481 WifiPhy::GetHtMcs4 ()
2482 {
2483  static WifiMode mcs =
2484  WifiModeFactory::CreateWifiMcs ("HtMcs4", 4, WIFI_MOD_CLASS_HT);
2485  return mcs;
2486 }
2487 
2488 WifiMode
2489 WifiPhy::GetHtMcs5 ()
2490 {
2491  static WifiMode mcs =
2492  WifiModeFactory::CreateWifiMcs ("HtMcs5", 5, WIFI_MOD_CLASS_HT);
2493  return mcs;
2494 }
2495 
2496 WifiMode
2497 WifiPhy::GetHtMcs6 ()
2498 {
2499  static WifiMode mcs =
2500  WifiModeFactory::CreateWifiMcs ("HtMcs6", 6, WIFI_MOD_CLASS_HT);
2501  return mcs;
2502 }
2503 
2504 WifiMode
2505 WifiPhy::GetHtMcs7 ()
2506 {
2507  static WifiMode mcs =
2508  WifiModeFactory::CreateWifiMcs ("HtMcs7", 7, WIFI_MOD_CLASS_HT);
2509  return mcs;
2510 }
2511 
2512 WifiMode
2513 WifiPhy::GetHtMcs8 ()
2514 {
2515  static WifiMode mcs =
2516  WifiModeFactory::CreateWifiMcs ("HtMcs8", 8, WIFI_MOD_CLASS_HT);
2517  return mcs;
2518 }
2519 
2520 WifiMode
2521 WifiPhy::GetHtMcs9 ()
2522 {
2523  static WifiMode mcs =
2524  WifiModeFactory::CreateWifiMcs ("HtMcs9", 9, WIFI_MOD_CLASS_HT);
2525  return mcs;
2526 }
2527 
2528 WifiMode
2529 WifiPhy::GetHtMcs10 ()
2530 {
2531  static WifiMode mcs =
2532  WifiModeFactory::CreateWifiMcs ("HtMcs10", 10, WIFI_MOD_CLASS_HT);
2533  return mcs;
2534 }
2535 
2536 WifiMode
2537 WifiPhy::GetHtMcs11 ()
2538 {
2539  static WifiMode mcs =
2540  WifiModeFactory::CreateWifiMcs ("HtMcs11", 11, WIFI_MOD_CLASS_HT);
2541  return mcs;
2542 }
2543 
2544 WifiMode
2545 WifiPhy::GetHtMcs12 ()
2546 {
2547  static WifiMode mcs =
2548  WifiModeFactory::CreateWifiMcs ("HtMcs12", 12, WIFI_MOD_CLASS_HT);
2549  return mcs;
2550 }
2551 
2552 WifiMode
2553 WifiPhy::GetHtMcs13 ()
2554 {
2555  static WifiMode mcs =
2556  WifiModeFactory::CreateWifiMcs ("HtMcs13", 13, WIFI_MOD_CLASS_HT);
2557  return mcs;
2558 }
2559 
2560 WifiMode
2561 WifiPhy::GetHtMcs14 ()
2562 {
2563  static WifiMode mcs =
2564  WifiModeFactory::CreateWifiMcs ("HtMcs14", 14, WIFI_MOD_CLASS_HT);
2565  return mcs;
2566 }
2567 
2568 WifiMode
2569 WifiPhy::GetHtMcs15 ()
2570 {
2571  static WifiMode mcs =
2572  WifiModeFactory::CreateWifiMcs ("HtMcs15", 15, WIFI_MOD_CLASS_HT);
2573  return mcs;
2574 }
2575 
2576 WifiMode
2577 WifiPhy::GetHtMcs16 ()
2578 {
2579  static WifiMode mcs =
2580  WifiModeFactory::CreateWifiMcs ("HtMcs16", 16, WIFI_MOD_CLASS_HT);
2581  return mcs;
2582 }
2583 
2584 WifiMode
2585 WifiPhy::GetHtMcs17 ()
2586 {
2587  static WifiMode mcs =
2588  WifiModeFactory::CreateWifiMcs ("HtMcs17", 17, WIFI_MOD_CLASS_HT);
2589  return mcs;
2590 }
2591 
2592 WifiMode
2593 WifiPhy::GetHtMcs18 ()
2594 {
2595  static WifiMode mcs =
2596  WifiModeFactory::CreateWifiMcs ("HtMcs18", 18, WIFI_MOD_CLASS_HT);
2597  return mcs;
2598 }
2599 
2600 WifiMode
2601 WifiPhy::GetHtMcs19 ()
2602 {
2603  static WifiMode mcs =
2604  WifiModeFactory::CreateWifiMcs ("HtMcs19", 19, WIFI_MOD_CLASS_HT);
2605  return mcs;
2606 }
2607 
2608 WifiMode
2609 WifiPhy::GetHtMcs20 ()
2610 {
2611  static WifiMode mcs =
2612  WifiModeFactory::CreateWifiMcs ("HtMcs20", 20, WIFI_MOD_CLASS_HT);
2613  return mcs;
2614 }
2615 
2616 WifiMode
2617 WifiPhy::GetHtMcs21 ()
2618 {
2619  static WifiMode mcs =
2620  WifiModeFactory::CreateWifiMcs ("HtMcs21", 21, WIFI_MOD_CLASS_HT);
2621  return mcs;
2622 }
2623 
2624 WifiMode
2625 WifiPhy::GetHtMcs22 ()
2626 {
2627  static WifiMode mcs =
2628  WifiModeFactory::CreateWifiMcs ("HtMcs22", 22, WIFI_MOD_CLASS_HT);
2629  return mcs;
2630 }
2631 
2632 WifiMode
2633 WifiPhy::GetHtMcs23 ()
2634 {
2635  static WifiMode mcs =
2636  WifiModeFactory::CreateWifiMcs ("HtMcs23", 23, WIFI_MOD_CLASS_HT);
2637  return mcs;
2638 }
2639 
2640 WifiMode
2641 WifiPhy::GetHtMcs24 ()
2642 {
2643  static WifiMode mcs =
2644  WifiModeFactory::CreateWifiMcs ("HtMcs24", 24, WIFI_MOD_CLASS_HT);
2645  return mcs;
2646 }
2647 
2648 WifiMode
2649 WifiPhy::GetHtMcs25 ()
2650 {
2651  static WifiMode mcs =
2652  WifiModeFactory::CreateWifiMcs ("HtMcs25", 25, WIFI_MOD_CLASS_HT);
2653  return mcs;
2654 }
2655 
2656 WifiMode
2657 WifiPhy::GetHtMcs26 ()
2658 {
2659  static WifiMode mcs =
2660  WifiModeFactory::CreateWifiMcs ("HtMcs26", 26, WIFI_MOD_CLASS_HT);
2661  return mcs;
2662 }
2663 
2664 WifiMode
2665 WifiPhy::GetHtMcs27 ()
2666 {
2667  static WifiMode mcs =
2668  WifiModeFactory::CreateWifiMcs ("HtMcs27", 27, WIFI_MOD_CLASS_HT);
2669  return mcs;
2670 }
2671 
2672 WifiMode
2673 WifiPhy::GetHtMcs28 ()
2674 {
2675  static WifiMode mcs =
2676  WifiModeFactory::CreateWifiMcs ("HtMcs28", 28, WIFI_MOD_CLASS_HT);
2677  return mcs;
2678 }
2679 
2680 WifiMode
2681 WifiPhy::GetHtMcs29 ()
2682 {
2683  static WifiMode mcs =
2684  WifiModeFactory::CreateWifiMcs ("HtMcs29", 29, WIFI_MOD_CLASS_HT);
2685  return mcs;
2686 }
2687 
2688 WifiMode
2689 WifiPhy::GetHtMcs30 ()
2690 {
2691  static WifiMode mcs =
2692  WifiModeFactory::CreateWifiMcs ("HtMcs30", 30, WIFI_MOD_CLASS_HT);
2693  return mcs;
2694 }
2695 
2696 WifiMode
2697 WifiPhy::GetHtMcs31 ()
2698 {
2699  static WifiMode mcs =
2700  WifiModeFactory::CreateWifiMcs ("HtMcs31", 31, WIFI_MOD_CLASS_HT);
2701  return mcs;
2702 }
2703 
2704 
2705 // Clause 22
2706 
2707 WifiMode
2708 WifiPhy::GetVhtMcs0 ()
2709 {
2710  static WifiMode mcs =
2711  WifiModeFactory::CreateWifiMcs ("VhtMcs0", 0, WIFI_MOD_CLASS_VHT);
2712  return mcs;
2713 }
2714 
2715 WifiMode
2716 WifiPhy::GetVhtMcs1 ()
2717 {
2718  static WifiMode mcs =
2719  WifiModeFactory::CreateWifiMcs ("VhtMcs1", 1, WIFI_MOD_CLASS_VHT);
2720  return mcs;
2721 }
2722 
2723 WifiMode
2724 WifiPhy::GetVhtMcs2 ()
2725 {
2726  static WifiMode mcs =
2727  WifiModeFactory::CreateWifiMcs ("VhtMcs2", 2, WIFI_MOD_CLASS_VHT);
2728  return mcs;
2729 }
2730 
2731 WifiMode
2732 WifiPhy::GetVhtMcs3 ()
2733 {
2734  static WifiMode mcs =
2735  WifiModeFactory::CreateWifiMcs ("VhtMcs3", 3, WIFI_MOD_CLASS_VHT);
2736  return mcs;
2737 }
2738 
2739 WifiMode
2740 WifiPhy::GetVhtMcs4 ()
2741 {
2742  static WifiMode mcs =
2743  WifiModeFactory::CreateWifiMcs ("VhtMcs4", 4, WIFI_MOD_CLASS_VHT);
2744  return mcs;
2745 }
2746 
2747 WifiMode
2748 WifiPhy::GetVhtMcs5 ()
2749 {
2750  static WifiMode mcs =
2751  WifiModeFactory::CreateWifiMcs ("VhtMcs5", 5, WIFI_MOD_CLASS_VHT);
2752  return mcs;
2753 }
2754 
2755 WifiMode
2756 WifiPhy::GetVhtMcs6 ()
2757 {
2758  static WifiMode mcs =
2759  WifiModeFactory::CreateWifiMcs ("VhtMcs6", 6, WIFI_MOD_CLASS_VHT);
2760  return mcs;
2761 }
2762 
2763 WifiMode
2764 WifiPhy::GetVhtMcs7 ()
2765 {
2766  static WifiMode mcs =
2767  WifiModeFactory::CreateWifiMcs ("VhtMcs7", 7, WIFI_MOD_CLASS_VHT);
2768  return mcs;
2769 }
2770 
2771 WifiMode
2772 WifiPhy::GetVhtMcs8 ()
2773 {
2774  static WifiMode mcs =
2775  WifiModeFactory::CreateWifiMcs ("VhtMcs8", 8, WIFI_MOD_CLASS_VHT);
2776  return mcs;
2777 }
2778 
2779 WifiMode
2780 WifiPhy::GetVhtMcs9 ()
2781 {
2782  static WifiMode mcs =
2783  WifiModeFactory::CreateWifiMcs ("VhtMcs9", 9, WIFI_MOD_CLASS_VHT);
2784  return mcs;
2785 }
2786 
2787 bool
2788 WifiPhy::IsValidTxVector (WifiTxVector txVector)
2789 {
2790  uint32_t chWidth = txVector.GetChannelWidth();
2791  uint8_t nss = txVector.GetNss();
2792  std::string modeName = txVector.GetMode().GetUniqueName();
2793 
2794  if (chWidth == 20)
2795  {
2796  if (nss != 3 && nss != 6)
2797  {
2798  return (modeName != "VhtMcs9");
2799  }
2800  }
2801  else if (chWidth == 80)
2802  {
2803  if (nss == 3 || nss == 7)
2804  {
2805  return (modeName != "VhtMcs6");
2806  }
2807  else if (nss == 6)
2808  {
2809  return (modeName != "VhtMcs9");
2810  }
2811  }
2812  else if (chWidth == 160)
2813  {
2814  if (nss == 3)
2815  {
2816  return (modeName != "VhtMcs9");
2817  }
2818  }
2819 
2820  return true;
2821 }
2822 
2823 bool
2824 WifiPhy::IsModeSupported (WifiMode mode) const
2825 {
2826  for (uint32_t i = 0; i < GetNModes (); i++)
2827  {
2828  if (mode == GetMode (i))
2829  {
2830  return true;
2831  }
2832  }
2833  return false;
2834 }
2835 
2836 bool
2837 WifiPhy::IsMcsSupported (WifiMode mcs) const
2838 {
2839  for (uint32_t i = 0; i < GetNMcs (); i++)
2840  {
2841  if (mcs == GetMcs (i))
2842  {
2843  return true;
2844  }
2845  }
2846  return false;
2847 }
2848 
2849 uint32_t
2850 WifiPhy::GetNModes (void) const
2851 {
2852  return m_deviceRateSet.size ();
2853 }
2854 
2855 WifiMode
2856 WifiPhy::GetMode (uint32_t mode) const
2857 {
2858  return m_deviceRateSet[mode];
2859 }
2860 
2861 uint8_t
2862 WifiPhy::GetNMcs (void) const
2863 {
2864  return m_deviceMcsSet.size ();
2865 }
2866 
2867 WifiMode
2868 WifiPhy::GetMcs (uint8_t mcs) const
2869 {
2870  return m_deviceMcsSet[mcs];
2871 }
2872 
2873 double
2874 WifiPhy::DbToRatio (double dB) const
2875 {
2876  double ratio = std::pow (10.0, dB / 10.0);
2877  return ratio;
2878 }
2879 
2880 double
2881 WifiPhy::DbmToW (double dBm) const
2882 {
2883  double mW = std::pow (10.0, dBm / 10.0);
2884  return mW / 1000.0;
2885 }
2886 
2887 double
2888 WifiPhy::WToDbm (double w) const
2889 {
2890  return 10.0 * std::log10 (w * 1000.0);
2891 }
2892 
2893 double
2894 WifiPhy::RatioToDb (double ratio) const
2895 {
2896  return 10.0 * std::log10 (ratio);
2897 }
2898 
2899 bool
2900 WifiPhy::IsStateCcaBusy (void)
2901 {
2902  return m_state->IsStateCcaBusy ();
2903 }
2904 
2905 bool
2906 WifiPhy::IsStateIdle (void)
2907 {
2908  return m_state->IsStateIdle ();
2909 }
2910 
2911 bool
2912 WifiPhy::IsStateBusy (void)
2913 {
2914  return m_state->IsStateBusy ();
2915 }
2916 
2917 bool
2918 WifiPhy::IsStateRx (void)
2919 {
2920  return m_state->IsStateRx ();
2921 }
2922 
2923 bool
2924 WifiPhy::IsStateTx (void)
2925 {
2926  return m_state->IsStateTx ();
2927 }
2928 
2929 bool
2930 WifiPhy::IsStateSwitching (void)
2931 {
2932  return m_state->IsStateSwitching ();
2933 }
2934 
2935 bool
2936 WifiPhy::IsStateSleep (void)
2937 {
2938  return m_state->IsStateSleep ();
2939 }
2940 
2941 Time
2942 WifiPhy::GetStateDuration (void)
2943 {
2944  return m_state->GetStateDuration ();
2945 }
2946 
2947 Time
2948 WifiPhy::GetDelayUntilIdle (void)
2949 {
2950  return m_state->GetDelayUntilIdle ();
2951 }
2952 
2953 Time
2954 WifiPhy::GetLastRxStartTime (void) const
2955 {
2956  return m_state->GetLastRxStartTime ();
2957 }
2958 
2959 int64_t
2960 WifiPhy::AssignStreams (int64_t stream)
2961 {
2962  NS_LOG_FUNCTION (this << stream);
2963  m_random->SetStream (stream);
2964  return 1;
2965 }
2966 
2967 std::ostream& operator<< (std::ostream& os, enum WifiPhy::State state)
2968 {
2969  switch (state)
2970  {
2971  case WifiPhy::IDLE:
2972  return (os << "IDLE");
2973  case WifiPhy::CCA_BUSY:
2974  return (os << "CCA_BUSY");
2975  case WifiPhy::TX:
2976  return (os << "TX");
2977  case WifiPhy::RX:
2978  return (os << "RX");
2979  case WifiPhy::SWITCHING:
2980  return (os << "SWITCHING");
2981  case WifiPhy::SLEEP:
2982  return (os << "SLEEP");
2983  default:
2984  NS_FATAL_ERROR ("Invalid WifiPhy state");
2985  return (os << "INVALID");
2986  }
2987 }
2988 
2989 } //namespace ns3
2990 
2991 namespace {
2992 
2993 static class Constructor
2994 {
2995 public:
2996  Constructor ()
2997  {
2998  ns3::WifiPhy::GetDsssRate1Mbps ();
2999  ns3::WifiPhy::GetDsssRate2Mbps ();
3000  ns3::WifiPhy::GetDsssRate5_5Mbps ();
3001  ns3::WifiPhy::GetDsssRate11Mbps ();
3002  ns3::WifiPhy::GetErpOfdmRate6Mbps ();
3003  ns3::WifiPhy::GetErpOfdmRate9Mbps ();
3004  ns3::WifiPhy::GetErpOfdmRate12Mbps ();
3005  ns3::WifiPhy::GetErpOfdmRate18Mbps ();
3006  ns3::WifiPhy::GetErpOfdmRate24Mbps ();
3007  ns3::WifiPhy::GetErpOfdmRate36Mbps ();
3008  ns3::WifiPhy::GetErpOfdmRate48Mbps ();
3009  ns3::WifiPhy::GetErpOfdmRate54Mbps ();
3010  ns3::WifiPhy::GetOfdmRate6Mbps ();
3011  ns3::WifiPhy::GetOfdmRate9Mbps ();
3012  ns3::WifiPhy::GetOfdmRate12Mbps ();
3013  ns3::WifiPhy::GetOfdmRate18Mbps ();
3014  ns3::WifiPhy::GetOfdmRate24Mbps ();
3015  ns3::WifiPhy::GetOfdmRate36Mbps ();
3016  ns3::WifiPhy::GetOfdmRate48Mbps ();
3017  ns3::WifiPhy::GetOfdmRate54Mbps ();
3018  ns3::WifiPhy::GetOfdmRate3MbpsBW10MHz ();
3019  ns3::WifiPhy::GetOfdmRate4_5MbpsBW10MHz ();
3020  ns3::WifiPhy::GetOfdmRate6MbpsBW10MHz ();
3021  ns3::WifiPhy::GetOfdmRate9MbpsBW10MHz ();
3022  ns3::WifiPhy::GetOfdmRate12MbpsBW10MHz ();
3023  ns3::WifiPhy::GetOfdmRate18MbpsBW10MHz ();
3024  ns3::WifiPhy::GetOfdmRate24MbpsBW10MHz ();
3025  ns3::WifiPhy::GetOfdmRate27MbpsBW10MHz ();
3026  ns3::WifiPhy::GetOfdmRate1_5MbpsBW5MHz ();
3027  ns3::WifiPhy::GetOfdmRate2_25MbpsBW5MHz ();
3028  ns3::WifiPhy::GetOfdmRate3MbpsBW5MHz ();
3029  ns3::WifiPhy::GetOfdmRate4_5MbpsBW5MHz ();
3030  ns3::WifiPhy::GetOfdmRate6MbpsBW5MHz ();
3031  ns3::WifiPhy::GetOfdmRate9MbpsBW5MHz ();
3032  ns3::WifiPhy::GetOfdmRate12MbpsBW5MHz ();
3033  ns3::WifiPhy::GetOfdmRate13_5MbpsBW5MHz ();
3034  ns3::WifiPhy::GetHtMcs0 ();
3035  ns3::WifiPhy::GetHtMcs1 ();
3036  ns3::WifiPhy::GetHtMcs2 ();
3037  ns3::WifiPhy::GetHtMcs3 ();
3038  ns3::WifiPhy::GetHtMcs4 ();
3039  ns3::WifiPhy::GetHtMcs5 ();
3040  ns3::WifiPhy::GetHtMcs6 ();
3041  ns3::WifiPhy::GetHtMcs7 ();
3042  ns3::WifiPhy::GetHtMcs8 ();
3043  ns3::WifiPhy::GetHtMcs9 ();
3044  ns3::WifiPhy::GetHtMcs10 ();
3045  ns3::WifiPhy::GetHtMcs11 ();
3046  ns3::WifiPhy::GetHtMcs12 ();
3047  ns3::WifiPhy::GetHtMcs13 ();
3048  ns3::WifiPhy::GetHtMcs14 ();
3049  ns3::WifiPhy::GetHtMcs15 ();
3050  ns3::WifiPhy::GetHtMcs16 ();
3051  ns3::WifiPhy::GetHtMcs17 ();
3052  ns3::WifiPhy::GetHtMcs18 ();
3053  ns3::WifiPhy::GetHtMcs19 ();
3054  ns3::WifiPhy::GetHtMcs20 ();
3055  ns3::WifiPhy::GetHtMcs21 ();
3056  ns3::WifiPhy::GetHtMcs22 ();
3057  ns3::WifiPhy::GetHtMcs23 ();
3058  ns3::WifiPhy::GetHtMcs24 ();
3059  ns3::WifiPhy::GetHtMcs25 ();
3060  ns3::WifiPhy::GetHtMcs26 ();
3061  ns3::WifiPhy::GetHtMcs27 ();
3062  ns3::WifiPhy::GetHtMcs28 ();
3063  ns3::WifiPhy::GetHtMcs29 ();
3064  ns3::WifiPhy::GetHtMcs30 ();
3065  ns3::WifiPhy::GetHtMcs31 ();
3066  ns3::WifiPhy::GetVhtMcs0 ();
3067  ns3::WifiPhy::GetVhtMcs1 ();
3068  ns3::WifiPhy::GetVhtMcs2 ();
3069  ns3::WifiPhy::GetVhtMcs3 ();
3070  ns3::WifiPhy::GetVhtMcs4 ();
3071  ns3::WifiPhy::GetVhtMcs5 ();
3072  ns3::WifiPhy::GetVhtMcs6 ();
3073  ns3::WifiPhy::GetVhtMcs7 ();
3074  ns3::WifiPhy::GetVhtMcs8 ();
3075  ns3::WifiPhy::GetVhtMcs9 ();
3076  }
3077 } g_constructor;
3078 
3079 }
anonymous_namespace{wifi-phy.cc}::g_constructor
static class anonymous_namespace{wifi-phy.cc}::Constructor g_constructor
ns3::WIFI_PHY_STANDARD_80211g
ERP-OFDM PHY (Clause 19, Section 19.5)
Definition: wifi-phy-standard.h:37
ns3::WifiPhy::GetVhtMcs6
static WifiMode GetVhtMcs6()
Return MCS 6 from VHT MCS values.
Definition: wifi-phy.cc:2756
ns3::WifiPhy::GetOfdmRate9MbpsBW5MHz
static WifiMode GetOfdmRate9MbpsBW5MHz()
Return a WifiMode for OFDM at 9Mbps with 5MHz channel spacing.
Definition: wifi-phy.cc:2410
ns3::WifiPhy::m_phyRxBeginTrace
TracedCallback< Ptr< const Packet > > m_phyRxBeginTrace
The trace source fired when a packet begins the reception process from the medium.
Definition: wifi-phy.h:1711
ns3::WifiPhy::m_device
Ptr< NetDevice > m_device
Pointer to the device.
Definition: wifi-phy.h:1834
ns3::WifiPhy::GetErpOfdmRate24Mbps
static WifiMode GetErpOfdmRate24Mbps()
Return a WifiMode for ERP-OFDM at 24Mbps.
Definition: wifi-phy.cc:2101
ns3::WifiPhy::GetDsssRate11Mbps
static WifiMode GetDsssRate11Mbps()
Return a WifiMode for DSSS at 11Mbps.
Definition: wifi-phy.cc:2038
ns3::WifiPhy::GetNBssMembershipSelectors
virtual uint32_t GetNBssMembershipSelectors(void) const
The WifiPhy::NBssMembershipSelectors() method is used (e.g., by a WifiRemoteStationManager) to determ...
Definition: wifi-phy.cc:1200
ns3::Time
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:102
ns3::WifiPhy::DoFrequencySwitch
virtual bool DoFrequencySwitch(uint32_t frequency)
The default implementation does nothing and returns true.
Definition: wifi-phy.cc:1341
ns3::WifiPhy::SetDevice
void SetDevice(Ptr< NetDevice > device)
Sets the device this PHY is associated with.
Definition: wifi-phy.cc:598
ns3::WifiPhy::m_supportedChannelWidthSet
std::vector< uint32_t > m_supportedChannelWidthSet
Supported channel width.
Definition: wifi-phy.h:1826
ns3::WifiPhy::GetErpOfdmRate36Mbps
static WifiMode GetErpOfdmRate36Mbps()
Return a WifiMode for ERP-OFDM at 36Mbps.
Definition: wifi-phy.cc:2113
ns3::WifiPhy::SetNumberOfTransmitAntennas
virtual void SetNumberOfTransmitAntennas(uint32_t tx)
Definition: wifi-phy.cc:1163
ns3::WifiPhy::NotifyMonitorSniffTx
void NotifyMonitorSniffTx(Ptr< const Packet > packet, uint16_t channelFreqMhz, uint16_t channelNumber, uint32_t rate, WifiPreamble preamble, WifiTxVector txVector, struct mpduInfo aMpdu)
Public method used to fire a MonitorSniffer trace for a wifi packet being transmitted.
Definition: wifi-phy.cc:1990
ns3::WifiPhy::IsStateBusy
virtual bool IsStateBusy(void)
Definition: wifi-phy.cc:2912
ns3::Ptr
Smart pointer class similar to boost::intrusive_ptr.
Definition: ptr.h:73
NS_LOG_FUNCTION
#define NS_LOG_FUNCTION(parameters)
If log level LOG_FUNCTION is enabled, this macro will output all input parameters separated by "...
Definition: log-macros-enabled.h:213
ns3::WIFI_PHY_STANDARD_80211_5MHZ
OFDM PHY for the 5 GHz band (Clause 17 with 5 MHz channel bandwidth)
Definition: wifi-phy-standard.h:41
ns3::WifiPhy::RatioToDb
double RatioToDb(double ratio) const
Convert from ratio to dB.
Definition: wifi-phy.cc:2894
ns3::RandomVariableStream::SetStream
void SetStream(int64_t stream)
Specifies the stream number for this RNG stream.
Definition: random-variable-stream.cc:98
ns3::WifiPhy::m_rxGainDb
double m_rxGainDb
Reception gain (dB)
Definition: wifi-phy.h:1809
ns3::WifiPhy::GetVhtMcs8
static WifiMode GetVhtMcs8()
Return MCS 8 from VHT MCS values.
Definition: wifi-phy.cc:2772
ns3::WIFI_MOD_CLASS_ERP_OFDM
ERP-OFDM PHY (19.5)
Definition: wifi-mode.h:58
ns3::WifiPhy::GetTxGain
double GetTxGain(void) const
Return the transmission gain (dB).
Definition: wifi-phy.cc:514
ns3::WifiPhy::GetRxNoiseFigure
double GetRxNoiseFigure(void) const
Return the RX noise figure (dBm).
Definition: wifi-phy.cc:462
ns3::WifiPhy::SetShortPlcpPreambleSupported
virtual void SetShortPlcpPreambleSupported(bool preamble)
Enable or disable short PLCP preamble.
Definition: wifi-phy.cc:585
ns3::BooleanValue
AttributeValue implementation for Boolean.
Definition: boolean.h:34
ns3::WifiPhy::IsMcsSupported
virtual bool IsMcsSupported(WifiMode mcs) const
Check if the given WifiMode is supported by the PHY.
Definition: wifi-phy.cc:2837
ns3::InterferenceHelper::GetErrorRateModel
Ptr< ErrorRateModel > GetErrorRateModel(void) const
Return the error rate model.
Definition: interference-helper.cc:193
ns3::WifiPhy::m_channelNumber
uint16_t m_channelNumber
Operating channel number.
Definition: wifi-phy.h:1827
ns3::WifiPhy::GetOfdmRate9Mbps
static WifiMode GetOfdmRate9Mbps()
Return a WifiMode for OFDM at 9Mbps.
Definition: wifi-phy.cc:2164
ns3::WIFI_PHY_STANDARD_80211n_5GHZ
HT OFDM PHY for the 5 GHz band (clause 20)
Definition: wifi-phy-standard.h:51
ns3::WifiPhy::GetGuardInterval
virtual bool GetGuardInterval(void) const
Return whether guard interval is being used.
Definition: wifi-phy.cc:579
ns3::WifiPhy::GetOfdmRate18MbpsBW10MHz
static WifiMode GetOfdmRate18MbpsBW10MHz()
Return a WifiMode for OFDM at 18Mbps with 10MHz channel spacing.
Definition: wifi-phy.cc:2311
ns3::WifiTxVector
This class mimics the TXVECTOR which is to be passed to the PHY in order to define the parameters whi...
Definition: wifi-tx-vector.h:61
ns3::WifiPhy::GetOfdmRate27MbpsBW10MHz
static WifiMode GetOfdmRate27MbpsBW10MHz()
Return a WifiMode for OFDM at 27Mbps with 10MHz channel spacing.
Definition: wifi-phy.cc:2335
ns3::WifiPhy::m_txGainDb
double m_txGainDb
Transmission gain (dB)
Definition: wifi-phy.h:1808
NS_OBJECT_ENSURE_REGISTERED
#define NS_OBJECT_ENSURE_REGISTERED(type)
Register an Object subclass with the TypeId system.
Definition: object-base.h:44
ns3::WifiPhy::GetOfdmRate3MbpsBW5MHz
static WifiMode GetOfdmRate3MbpsBW5MHz()
Return a WifiMode for OFDM at 3Mbps with 5MHz channel spacing.
Definition: wifi-phy.cc:2374
ns3::WifiPhy::GetVhtMcs0
static WifiMode GetVhtMcs0()
Return MCS 0 from VHT MCS values.
Definition: wifi-phy.cc:2708
ns3::WifiPhy::~WifiPhy
virtual ~WifiPhy()
Definition: wifi-phy.cc:365
ns3::WifiPhy::SetLdpc
virtual void SetLdpc(bool ldpc)
Enable or disable LDPC.
Definition: wifi-phy.cc:533
ns3::WifiPhy::GetDsssRate1Mbps
static WifiMode GetDsssRate1Mbps()
Return a WifiMode for DSSS at 1Mbps.
Definition: wifi-phy.cc:1999
ns3::WifiPhy::m_ldpc
bool m_ldpc
Flag if LDPC is used.
Definition: wifi-phy.h:1814
ns3::WifiPhy::GetGreenfield
virtual bool GetGreenfield(void) const
Return whether Greenfield is supported.
Definition: wifi-phy.cc:566
ns3::WifiPhy
802.11 PHY layer model
Definition: wifi-phy.h:162
ns3::WifiPhy::GetErpOfdmRate18Mbps
static WifiMode GetErpOfdmRate18Mbps()
Return a WifiMode for ERP-OFDM at 18Mbps.
Definition: wifi-phy.cc:2089
ns3::WifiPhy::SetTxGain
void SetTxGain(double gain)
Sets the transmission gain (dB).
Definition: wifi-phy.cc:507
ns3::WifiPhy::CCA_BUSY
The PHY layer has sense the medium busy through the CCA mechanism.
Definition: wifi-phy.h:177
ns3::WifiPhy::GetHtMcs7
static WifiMode GetHtMcs7()
Return MCS 7 from HT MCS values.
Definition: wifi-phy.cc:2505
ns3::MakeBooleanAccessor
Ptr< const AttributeAccessor > MakeBooleanAccessor(T1 a1)
Create an AttributeAccessor for a class data member, or a lone class get functor or set method...
Definition: boolean.h:81
ns3::WifiPhy::DoDispose
virtual void DoDispose(void)
Destructor implementation.
Definition: wifi-phy.cc:371
ns3::WifiPhy::GetHtPlcpHeaderMode
static WifiMode GetHtPlcpHeaderMode(WifiMode payloadMode)
Definition: wifi-phy.cc:1347
visualizer.core.start
def start()
Definition: core.py:1482
ns3::WifiPhy::SetStbc
virtual void SetStbc(bool stbc)
Enable or disable STBC.
Definition: wifi-phy.cc:546
ns3::WifiPhy::GetPlcpHtSigHeaderDuration
static Time GetPlcpHtSigHeaderDuration(WifiPreamble preamble)
Definition: wifi-phy.cc:1405
ns3::WifiPhy::GetVhtMcs5
static WifiMode GetVhtMcs5()
Return MCS 5 from VHT MCS values.
Definition: wifi-phy.cc:2748
anonymous_namespace{wifi-phy.cc}::Constructor::Constructor
Constructor()
Definition: wifi-phy.cc:2996
ns3::WifiPhy::GetHtMcs22
static WifiMode GetHtMcs22()
Return MCS 22 from HT MCS values.
Definition: wifi-phy.cc:2625
ns3::WifiPhy::m_bssMembershipSelectorSet
std::vector< uint32_t > m_bssMembershipSelectorSet
Definition: wifi-phy.h:1797
ns3::WifiPhy::GetHtMcs14
static WifiMode GetHtMcs14()
Return MCS 14 from HT MCS values.
Definition: wifi-phy.cc:2561
ns3::WifiPhy::GetOfdmRate12Mbps
static WifiMode GetOfdmRate12Mbps()
Return a WifiMode for OFDM at 12Mbps.
Definition: wifi-phy.cc:2176
ns3::WifiPhy::m_phyRxEndTrace
TracedCallback< Ptr< const Packet > > m_phyRxEndTrace
The trace source fired when a packet ends the reception process from the medium.
Definition: wifi-phy.h:1719
ns3::WifiMode::GetModulationClass
enum WifiModulationClass GetModulationClass() const
Definition: wifi-mode.cc:379
ns3::WifiPhy::GetHtMcs31
static WifiMode GetHtMcs31()
Return MCS 31 from HT MCS values.
Definition: wifi-phy.cc:2697
ns3::WifiPhy::GetHtMcs21
static WifiMode GetHtMcs21()
Return MCS 21 from HT MCS values.
Definition: wifi-phy.cc:2617
NS_ASSERT
#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
ns3::WifiPhy::m_numberOfReceivers
uint32_t m_numberOfReceivers
Number of receivers.
Definition: wifi-phy.h:1821
ns3::WifiPhy::GetHtMcs30
static WifiMode GetHtMcs30()
Return MCS 30 from HT MCS values.
Definition: wifi-phy.cc:2689
ns3::WIFI_PREAMBLE_NONE
Definition: wifi-preamble.h:37
NS_LOG_COMPONENT_DEFINE
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:201
ns3::WifiPhy::GetHtMcs10
static WifiMode GetHtMcs10()
Return MCS 10 from HT MCS values.
Definition: wifi-phy.cc:2529
ns3::WifiPhy::GetErrorRateModel
Ptr< ErrorRateModel > GetErrorRateModel(void) const
Return the error rate model this PHY is using.
Definition: wifi-phy.cc:635
ns3::WifiPhy::GetHtMcs26
static WifiMode GetHtMcs26()
Return MCS 26 from HT MCS values.
Definition: wifi-phy.cc:2657
ns3::WifiTxVector::IsShortGuardInterval
bool IsShortGuardInterval(void) const
Definition: wifi-tx-vector.cc:90
ns3::WifiPhy::GetOfdmRate1_5MbpsBW5MHz
static WifiMode GetOfdmRate1_5MbpsBW5MHz()
Return a WifiMode for OFDM at 1.5Mbps with 5MHz channel spacing.
Definition: wifi-phy.cc:2350
ns3::WifiPhy::SetNumberOfReceiveAntennas
virtual void SetNumberOfReceiveAntennas(uint32_t rx)
Definition: wifi-phy.cc:1170
ns3::WIFI_PHY_STANDARD_80211_10MHZ
OFDM PHY for the 5 GHz band (Clause 17 with 10 MHz channel bandwidth)
Definition: wifi-phy-standard.h:39
ns3::WifiPhy::SLEEP
The PHY layer is sleeping.
Definition: wifi-phy.h:193
ns3::WifiPhy::GetHtMcs17
static WifiMode GetHtMcs17()
Return MCS 17 from HT MCS values.
Definition: wifi-phy.cc:2585
ns3::WifiPhy::GetHtMcs24
static WifiMode GetHtMcs24()
Return MCS 24 from HT MCS values.
Definition: wifi-phy.cc:2641
ns3::WifiPhy::GetOfdmRate4_5MbpsBW10MHz
static WifiMode GetOfdmRate4_5MbpsBW10MHz()
Return a WifiMode for OFDM at 4.5Mbps with 10MHz channel spacing.
Definition: wifi-phy.cc:2263
ns3::WifiPhy::GetOfdmRate54Mbps
static WifiMode GetOfdmRate54Mbps()
Return a WifiMode for OFDM at 54Mbps.
Definition: wifi-phy.cc:2236
ns3::WifiPhy::SetRxNoiseFigure
void SetRxNoiseFigure(double noiseFigureDb)
Sets the RX loss (dB) in the Signal-to-Noise-Ratio due to non-idealities in the receiver.
Definition: wifi-phy.cc:455
NS_FATAL_ERROR
#define NS_FATAL_ERROR(msg)
Report a fatal error with a message and terminate.
Definition: fatal-error.h:162
ns3::WifiPhy::ConfigureHolland
void ConfigureHolland(void)
Definition: wifi-phy.cc:812
ns3::WifiPhy::GetNMcs
virtual uint8_t GetNMcs(void) const
The WifiPhy::GetNMcs() method is used (e.g., by a WifiRemoteStationManager) to determine the set of t...
Definition: wifi-phy.cc:2862
ns3::WifiPhy::NotifyTxDrop
void NotifyTxDrop(Ptr< const Packet > packet)
Public method used to fire a PhyTxDrop trace.
Definition: wifi-phy.cc:1960
ns3::Time::GetFemtoSeconds
int64_t GetFemtoSeconds(void) const
Get an approximation of the time stored in this instance in the indicated unit.
Definition: nstime.h:361
ns3::WIFI_PHY_STANDARD_80211n_2_4GHZ
HT OFDM PHY for the 2.4 GHz band (clause 20)
Definition: wifi-phy-standard.h:49
ns3::WifiPhy::SetGreenfield
virtual void SetGreenfield(bool greenfield)
Enable or disable Greenfield support.
Definition: wifi-phy.cc:559
ns3::WIFI_MOD_CLASS_VHT
VHT PHY (Clause 22)
Definition: wifi-mode.h:64
ns3::WifiPhy::Configure80211_10Mhz
void Configure80211_10Mhz(void)
Configure WifiPhy with appropriate channel frequency and supported rates for 802.11a standard with 10...
Definition: wifi-phy.cc:782
ns3::WIFI_MOD_CLASS_HR_DSSS
HR/DSSS PHY (Clause 18)
Definition: wifi-mode.h:52
ns3::WifiPhy::GetHtMcs8
static WifiMode GetHtMcs8()
Return MCS 8 from HT MCS values.
Definition: wifi-phy.cc:2513
ns3::WifiPhy::GetHtMcs18
static WifiMode GetHtMcs18()
Return MCS 18 from HT MCS values.
Definition: wifi-phy.cc:2593
ns3::WifiPhy::SetGuardInterval
virtual void SetGuardInterval(bool guardInterval)
Enable or disable short/long guard interval.
Definition: wifi-phy.cc:572
ns3::WifiPhy::NotifyTxBegin
void NotifyTxBegin(Ptr< const Packet > packet)
Public method used to fire a PhyTxBegin trace.
Definition: wifi-phy.cc:1948
ns3::WifiPhy::GetVhtMcs4
static WifiMode GetVhtMcs4()
Return MCS 4 from VHT MCS values.
Definition: wifi-phy.cc:2740
ns3::WifiPhy::GetHtMcs27
static WifiMode GetHtMcs27()
Return MCS 27 from HT MCS values.
Definition: wifi-phy.cc:2665
ns3::WifiMode
represent a single transmission modeA WifiMode is implemented by a single integer which is used to lo...
Definition: wifi-mode.h:99
ns3::WifiPhy::IsModeSupported
virtual bool IsModeSupported(WifiMode mode) const
Check if the given WifiMode is supported by the PHY.
Definition: wifi-phy.cc:2824
ns3::WifiPhy::GetOfdmRate36Mbps
static WifiMode GetOfdmRate36Mbps()
Return a WifiMode for OFDM at 36Mbps.
Definition: wifi-phy.cc:2212
ns3::WifiPhy::GetPayloadDuration
Time GetPayloadDuration(uint32_t size, WifiTxVector txVector, WifiPreamble preamble, double frequency)
Definition: wifi-phy.cc:1623
ns3::WifiModeFactory::CreateWifiMcs
static WifiMode CreateWifiMcs(std::string uniqueName, uint8_t mcsValue, enum WifiModulationClass modClass)
Definition: wifi-mode.cc:581
ns3::WifiPhy::GetVhtMcs7
static WifiMode GetVhtMcs7()
Return MCS 7 from VHT MCS values.
Definition: wifi-phy.cc:2764
ns3::WifiPhy::GetOfdmRate6MbpsBW5MHz
static WifiMode GetOfdmRate6MbpsBW5MHz()
Return a WifiMode for OFDM at 6Mbps with 5MHz channel spacing.
Definition: wifi-phy.cc:2398
ns3::WifiPhy::GetStbc
virtual bool GetStbc(void) const
Return whether STBC is supported.
Definition: wifi-phy.cc:553
ns3::WifiPhy::GetVhtMcs3
static WifiMode GetVhtMcs3()
Return MCS 3 from VHT MCS values.
Definition: wifi-phy.cc:2732
ns3::WifiPhy::NotifyMonitorSniffRx
void NotifyMonitorSniffRx(Ptr< const Packet > packet, uint16_t channelFreqMhz, uint16_t channelNumber, uint32_t rate, WifiPreamble preamble, WifiTxVector txVector, struct mpduInfo aMpdu, struct signalNoiseDbm signalNoise)
Public method used to fire a MonitorSniffer trace for a wifi packet being received.
Definition: wifi-phy.cc:1984
ns3::WifiPhy::GetBssMembershipSelector
virtual uint32_t GetBssMembershipSelector(uint32_t selector) const
The WifiPhy::BssMembershipSelector() method is used (e.g., by a WifiRemoteStationManager) to determin...
Definition: wifi-phy.cc:1206
ns3::MakeTraceSourceAccessor
Ptr< const TraceSourceAccessor > MakeTraceSourceAccessor(T a)
Create a TraceSourceAccessor which will control access to the underlying trace source.
Definition: trace-source-accessor.h:198
ns3::WifiPhy::m_deviceMcsSet
WifiModeList m_deviceMcsSet
Definition: wifi-phy.h:1795
ns3::WifiPhy::GetVhtPlcpHeaderMode
static WifiMode GetVhtPlcpHeaderMode(WifiMode payloadMode)
Definition: wifi-phy.cc:1353
ns3::MakeTimeChecker
Ptr< const AttributeChecker > MakeTimeChecker(const Time min, const Time max)
Helper to make a Time checker with bounded range.
Definition: time.cc:446
ns3::WifiPhy::GetHtMcs16
static WifiMode GetHtMcs16()
Return MCS 16 from HT MCS values.
Definition: wifi-phy.cc:2577
ns3::WifiPhy::GetErpOfdmRate54Mbps
static WifiMode GetErpOfdmRate54Mbps()
Return a WifiMode for ERP-OFDM at 54Mbps.
Definition: wifi-phy.cc:2137
ns3::WifiPhy::GetLdpc
virtual bool GetLdpc(void) const
Return if LDPC is supported.
Definition: wifi-phy.cc:540
ns3::WifiPhy::GetHtMcs29
static WifiMode GetHtMcs29()
Return MCS 29 from HT MCS values.
Definition: wifi-phy.cc:2681
ns3::WifiPhy::GetHtMcs11
static WifiMode GetHtMcs11()
Return MCS 11 from HT MCS values.
Definition: wifi-phy.cc:2537
ns3::WifiPhy::NotifyRxDrop
void NotifyRxDrop(Ptr< const Packet > packet)
Public method used to fire a PhyRxDrop trace.
Definition: wifi-phy.cc:1978
ns3::WifiPhy::GetNumberOfReceiveAntennas
virtual uint32_t GetNumberOfReceiveAntennas(void) const
Definition: wifi-phy.cc:1182
ns3::WifiPreamble
WifiPreamble
The type of preamble to be used by an IEEE 802.11 transmission.
Definition: wifi-preamble.h:30
ns3::MobilityModel
Keep track of the current position and velocity of an object.
Definition: mobility-model.h:39
ns3::WifiPhy::SetNTxPower
void SetNTxPower(uint32_t n)
Sets the number of transmission power levels available between the minimum level and the maximum leve...
Definition: wifi-phy.cc:494
ns3::InterferenceHelper::SetErrorRateModel
void SetErrorRateModel(Ptr< ErrorRateModel > rate)
Set the error rate model for this interference helper.
Definition: interference-helper.cc:187
ns3::WifiPhy::m_channelToFrequencyWidth
static ChannelToFrequencyWidthMap m_channelToFrequencyWidth
This table maintains the mapping of valid ChannelNumber to Frequency/ChannelWidth pairs...
Definition: wifi-phy.h:1824
ns3::WifiPhy::GetPowerDbm
double GetPowerDbm(uint8_t power) const
Get the power of the given power level in dBm.
Definition: wifi-phy.cc:641
ns3::WifiPhy::GetEdThreshold
double GetEdThreshold(void) const
Return the energy detection threshold (dBm).
Definition: wifi-phy.cc:436
ns3::WifiPhyStandard
WifiPhyStandard
Identifies the PHY specification that a Wifi device is configured to use.
Definition: wifi-phy-standard.h:30
ns3::WifiPhy::m_phyMonitorSniffRxTrace
TracedCallback< Ptr< const Packet >, uint16_t, uint16_t, uint32_t, WifiPreamble, WifiTxVector, struct mpduInfo, struct signalNoiseDbm > m_phyMonitorSniffRxTrace
A trace source that emulates a wifi device in monitor mode sniffing a packet being received...
Definition: wifi-phy.h:1741
ns3::NORMAL_MPDU
The MPDU is not part of an A-MPDU.
Definition: wifi-phy.h:59
ns3::WifiPhy::GetHtMcs2
static WifiMode GetHtMcs2()
Return MCS 2 from HT MCS values.
Definition: wifi-phy.cc:2465
third.mobility
tuple mobility
Definition: third.py:101
ns3::WifiPhy::GetChannelNumber
virtual uint16_t GetChannelNumber(void) const
Return current channel number.
Definition: wifi-phy.cc:1329
ns3::MakePointerAccessor
Ptr< const AttributeAccessor > MakePointerAccessor(T1 a1)
Create an AttributeAccessor for a class data member, or a lone class get functor or set method...
Definition: pointer.h:220
ns3::WifiPhy::m_mobility
Ptr< MobilityModel > m_mobility
Pointer to the mobility model.
Definition: wifi-phy.h:1835
ns3::TimeValue
AttributeValue implementation for Time.
Definition: nstime.h:957
ns3::WifiPhy::CalculatePlcpPreambleAndHeaderDuration
Time CalculatePlcpPreambleAndHeaderDuration(WifiTxVector txVector, enum WifiPreamble preamble)
Definition: wifi-phy.cc:1921
ns3::WifiPhy::DefineChannelNumber
bool DefineChannelNumber(uint16_t channelNumber, enum WifiPhyStandard standard, uint32_t frequency, uint32_t channelWidth)
Add a channel definition to the WifiPhy.
Definition: wifi-phy.cc:930
ns3::NanoSeconds
Time NanoSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:919
ns3::WifiPhy::m_phyTxDropTrace
TracedCallback< Ptr< const Packet > > m_phyTxDropTrace
The trace source fired when the phy layer drops a packet as it tries to transmit it.
Definition: wifi-phy.h:1703
ns3::WifiPhy::AddSupportedChannelWidth
virtual void AddSupportedChannelWidth(uint32_t channelwidth)
Definition: wifi-phy.cc:1246
ns3::WifiPhy::m_shortPreamble
bool m_shortPreamble
Flag if short PLCP preamble is supported.
Definition: wifi-phy.h:1818
ns3::WifiPhy::IsStateTx
virtual bool IsStateTx(void)
Definition: wifi-phy.cc:2924
ns3::WifiPhy::SetChannelWidth
virtual void SetChannelWidth(uint32_t channelwidth)
Definition: wifi-phy.cc:1149
ns3::UintegerValue
Hold an unsigned integer type.
Definition: uinteger.h:44
ns3::WifiPhy::GetPlcpHeaderMode
static WifiMode GetPlcpHeaderMode(WifiMode payloadMode, WifiPreamble preamble, WifiTxVector txVector)
Definition: wifi-phy.cc:1462
ns3::WifiPhy::IDLE
The PHY layer is IDLE.
Definition: wifi-phy.h:173
ns3::WifiPhy::FrequencyWidthPair
std::pair< uint32_t, uint32_t > FrequencyWidthPair
A pair of a center Frequency and a ChannelWidth.
Definition: wifi-phy.h:617
ns3::WifiPhy::GetHtMcs12
static WifiMode GetHtMcs12()
Return MCS 12 from HT MCS values.
Definition: wifi-phy.cc:2545
ns3::WifiPhy::GetErpOfdmRate48Mbps
static WifiMode GetErpOfdmRate48Mbps()
Return a WifiMode for ERP-OFDM at 48Mbps.
Definition: wifi-phy.cc:2125
ns3::WifiPhy::SetTxPowerEnd
void SetTxPowerEnd(double end)
Sets the maximum available transmission power level (dBm).
Definition: wifi-phy.cc:481
ns3::WifiTxVector::GetNess
uint8_t GetNess(void) const
Definition: wifi-tx-vector.cc:102
ns3::WifiPhy::GetOfdmRate12MbpsBW10MHz
static WifiMode GetOfdmRate12MbpsBW10MHz()
Return a WifiMode for OFDM at 12Mbps with 10MHz channel spacing.
Definition: wifi-phy.cc:2299
ns3::WifiTxVector::GetChannelWidth
uint32_t GetChannelWidth(void) const
Definition: wifi-tx-vector.cc:84
ns3::WIFI_MOD_CLASS_HT
HT PHY (Clause 20)
Definition: wifi-mode.h:62
ns3::WifiPhy::GetDelayUntilIdle
virtual Time GetDelayUntilIdle(void)
Definition: wifi-phy.cc:2948
ns3::WifiMode::GetMcsValue
uint8_t GetMcsValue(void) const
Definition: wifi-mode.cc:357
ns3::WifiMode::GetUniqueName
std::string GetUniqueName(void) const
Definition: wifi-mode.cc:342
ns3::WifiPhy::CalculateTxDuration
Time CalculateTxDuration(uint32_t size, WifiTxVector txVector, enum WifiPreamble preamble, double frequency)
Definition: wifi-phy.cc:1942
ns3::WifiPhy::RX
The PHY layer is receiving a packet.
Definition: wifi-phy.h:185
ns3::WifiPhy::m_phyRxDropTrace
TracedCallback< Ptr< const Packet > > m_phyRxDropTrace
The trace source fired when the phy layer drops a packet it has received.
Definition: wifi-phy.h:1726
ns3::WifiPhy::m_edThresholdW
double m_edThresholdW
Energy detection threshold in watts.
Definition: wifi-phy.h:1806
ns3::WifiPhy::Configure80211_5Mhz
void Configure80211_5Mhz()
Configure WifiPhy with appropriate channel frequency and supported rates for 802.11a standard with 5M...
Definition: wifi-phy.cc:797
ns3::WifiPhyListener::~WifiPhyListener
virtual ~WifiPhyListener()
Definition: wifi-phy.cc:47
ns3::WifiPhy::GetFrequency
virtual uint32_t GetFrequency(void) const
Definition: wifi-phy.cc:1143
ns3::WifiPhy::FindChannelNumberForFrequencyWidth
uint16_t FindChannelNumberForFrequencyWidth(uint32_t frequency, uint32_t width) const
Look for channel number matching the frequency and width.
Definition: wifi-phy.cc:947
ns3::WifiPhy::NotifyRxBegin
void NotifyRxBegin(Ptr< const Packet > packet)
Public method used to fire a PhyRxBegin trace.
Definition: wifi-phy.cc:1966
ns3::WifiPhy::TX
The PHY layer is sending a packet.
Definition: wifi-phy.h:181
ns3::WifiPhy::GetOfdmRate18Mbps
static WifiMode GetOfdmRate18Mbps()
Return a WifiMode for OFDM at 18Mbps.
Definition: wifi-phy.cc:2188
ns3::WIFI_PREAMBLE_VHT
Definition: wifi-preamble.h:36
ns3::WifiPhy::GetNModes
virtual uint32_t GetNModes(void) const
The WifiPhy::GetNModes() and WifiPhy::GetMode() methods are used (e.g., by a WifiRemoteStationManager...
Definition: wifi-phy.cc:2850
ns3::WifiPhy::GetOfdmRate9MbpsBW10MHz
static WifiMode GetOfdmRate9MbpsBW10MHz()
Return a WifiMode for OFDM at 9Mbps with 10MHz channel spacing.
Definition: wifi-phy.cc:2287
ns3::WifiTxVector::IsStbc
bool IsStbc(void) const
Check if STBC is used or not.
Definition: wifi-tx-vector.cc:114
ns3::WifiPhy::GetOfdmRate12MbpsBW5MHz
static WifiMode GetOfdmRate12MbpsBW5MHz()
Return a WifiMode for OFDM at 12Mbps with 5MHz channel spacing.
Definition: wifi-phy.cc:2422
ns3::WifiPhy::SetChannelNumber
virtual void SetChannelNumber(uint16_t id)
Set channel number.
Definition: wifi-phy.cc:1275
ns3::WifiPhy::GetMembershipSelectorModes
virtual WifiModeList GetMembershipSelectorModes(uint32_t selector)
The WifiPhy::GetMembershipSelectorModes() method is used (e.g., by a WifiRemoteStationManager) to det...
Definition: wifi-phy.cc:1212
NS_LOG_LOGIC
#define NS_LOG_LOGIC(msg)
Use NS_LOG to output a message of level LOG_LOGIC.
Definition: log.h:252
ns3::WifiPhy::ChannelNumberStandardPair
std::pair< uint16_t, enum WifiPhyStandard > ChannelNumberStandardPair
A pair of a ChannelNumber and WifiPhyStandard.
Definition: wifi-phy.h:613
ns3::WifiPhy::SWITCHING
The PHY layer is switching to other channel.
Definition: wifi-phy.h:189
ns3::WifiPhy::DoChannelSwitch
virtual bool DoChannelSwitch(uint16_t id)
The default implementation does nothing and returns true.
Definition: wifi-phy.cc:1335
ns3::WifiPhy::m_phyTxBeginTrace
TracedCallback< Ptr< const Packet > > m_phyTxBeginTrace
The trace source fired when a packet begins the transmission process on the medium.
Definition: wifi-phy.h:1687
ns3::MPDU_IN_AGGREGATE
The MPDU is part of an A-MPDU, but is not the last aggregate.
Definition: wifi-phy.h:61
ns3::WifiPhy::GetNTxPower
virtual uint32_t GetNTxPower(void) const
Return the number of available transmission power levels.
Definition: wifi-phy.cc:501
ns3::WifiPhy::GetVhtMcs1
static WifiMode GetVhtMcs1()
Return MCS 1 from VHT MCS values.
Definition: wifi-phy.cc:2716
ns3::WifiPhy::ConfigureDefaultsForStandard
virtual void ConfigureDefaultsForStandard(enum WifiPhyStandard standard)
Configure the PHY-level parameters for different Wi-Fi standard.
Definition: wifi-phy.cc:671
ns3::WIFI_PHY_STANDARD_holland
This is intended to be the configuration used in this paper: Gavin Holland, Nitin Vaidya and Paramvir...
Definition: wifi-phy-standard.h:47
ns3::WifiPhy::GetOfdmRate48Mbps
static WifiMode GetOfdmRate48Mbps()
Return a WifiMode for OFDM at 48Mbps.
Definition: wifi-phy.cc:2224
ns3::operator<<
std::ostream & operator<<(std::ostream &os, const Angles &a)
print a struct Angles to output
Definition: angles.cc:42
f
double f(double x, void *params)
Definition: 80211b.c:60
ns3::WifiPhy::GetHtMcs0
static WifiMode GetHtMcs0()
Return MCS 0 from HT MCS values.
Definition: wifi-phy.cc:2449
ns3::WifiPhy::GetMcs
virtual WifiMode GetMcs(uint8_t mcs) const
The WifiPhy::GetMcs() method is used (e.g., by a WifiRemoteStationManager) to determine the set of tr...
Definition: wifi-phy.cc:2868
ns3::WifiPhy::GetChannelWidth
virtual uint32_t GetChannelWidth(void) const
Definition: wifi-phy.cc:1157
ns3::WifiPhy::GetTypeId
static TypeId GetTypeId(void)
Definition: wifi-phy.cc:160
ns3::WIFI_PHY_STANDARD_80211a
OFDM PHY for the 5 GHz band (Clause 17)
Definition: wifi-phy-standard.h:33
ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.
ns3::PointerValue
Hold objects of type Ptr.
Definition: pointer.h:36
ns3::WifiPhy::GetTxPowerEnd
virtual double GetTxPowerEnd(void) const
Return the maximum available transmission power level (dBm).
Definition: wifi-phy.cc:488
ns3::WIFI_PHY_STANDARD_80211ac
VHT OFDM PHY (clause 22)
Definition: wifi-phy-standard.h:53
ns3::WifiPhy::IsStateIdle
virtual bool IsStateIdle(void)
Definition: wifi-phy.cc:2906
ns3::WifiPhy::IsValidTxVector
static bool IsValidTxVector(WifiTxVector txVector)
The standard disallows certain combinations of WifiMode, number of spatial streams, and channel widths.
Definition: wifi-phy.cc:2788
ns3::WifiPhy::m_phyMonitorSniffTxTrace
TracedCallback< Ptr< const Packet >, uint16_t, uint16_t, uint32_t, WifiPreamble, WifiTxVector, struct mpduInfo > m_phyMonitorSniffTxTrace
A trace source that emulates a wifi device in monitor mode sniffing a packet being transmitted...
Definition: wifi-phy.h:1756
ns3::WifiPhy::GetOfdmRate24Mbps
static WifiMode GetOfdmRate24Mbps()
Return a WifiMode for OFDM at 24Mbps.
Definition: wifi-phy.cc:2200
ns3::MakeBooleanChecker
Ptr< const AttributeChecker > MakeBooleanChecker(void)
Definition: boolean.cc:121
ns3::WIFI_PHY_STANDARD_80211b
DSSS PHY (Clause 15) and HR/DSSS PHY (Clause 18)
Definition: wifi-phy-standard.h:35
ns3::WifiPhy::GetHtMcs13
static WifiMode GetHtMcs13()
Return MCS 13 from HT MCS values.
Definition: wifi-phy.cc:2553
ns3::WifiPhy::CalculateSnr
virtual double CalculateSnr(WifiTxVector txVector, double ber) const
Definition: wifi-phy.cc:665
ns3::WIFI_PREAMBLE_LONG
Definition: wifi-preamble.h:32
ns3::WifiPhy::GetHtMcs20
static WifiMode GetHtMcs20()
Return MCS 20 from HT MCS values.
Definition: wifi-phy.cc:2609
ns3::WIFI_PREAMBLE_HT_GF
Definition: wifi-preamble.h:35
ns3::WifiPhy::GetHtMcs5
static WifiMode GetHtMcs5()
Return MCS 5 from HT MCS values.
Definition: wifi-phy.cc:2489
ns3::WifiPhy::SetCcaMode1Threshold
void SetCcaMode1Threshold(double threshold)
Sets the CCA threshold (dBm).
Definition: wifi-phy.cc:442
ns3::WifiPhy::GetLastRxStartTime
virtual Time GetLastRxStartTime(void) const
Return the start time of the last received packet.
Definition: wifi-phy.cc:2954
ns3::WifiPhy::SetMobility
void SetMobility(Ptr< MobilityModel > mobility)
assign a mobility model to this device
Definition: wifi-phy.cc:610
ns3::WifiMode::GetDataRate
uint64_t GetDataRate(uint32_t channelWidth, bool isShortGuardInterval, uint8_t nss) const
Definition: wifi-mode.cc:109
ns3::WifiPhy::GetVhtMcs2
static WifiMode GetVhtMcs2()
Return MCS 2 from VHT MCS values.
Definition: wifi-phy.cc:2724
ns3::WifiPhy::IsStateCcaBusy
virtual bool IsStateCcaBusy(void)
Definition: wifi-phy.cc:2900
ns3::WifiPhy::GetDsssRate5_5Mbps
static WifiMode GetDsssRate5_5Mbps()
Return a WifiMode for DSSS at 5.5Mbps.
Definition: wifi-phy.cc:2026
ns3::WifiPhy::GetMobility
Ptr< MobilityModel > GetMobility(void)
Return the mobility model this PHY is associated with.
Definition: wifi-phy.cc:616
ns3::WifiPhy::Configure80211ac
void Configure80211ac(void)
Configure WifiPhy with appropriate channel frequency and supported rates for 802.11ac standard...
Definition: wifi-phy.cc:910
ns3::WifiPhy::DoInitialize
virtual void DoInitialize(void)
Initialize() implementation.
Definition: wifi-phy.cc:382
ns3::WifiPhy::GetOfdmRate2_25MbpsBW5MHz
static WifiMode GetOfdmRate2_25MbpsBW5MHz()
Return a WifiMode for OFDM at 2.25Mbps with 5MHz channel spacing.
Definition: wifi-phy.cc:2362
ns3::MakeTimeAccessor
Ptr< const AttributeAccessor > MakeTimeAccessor(T1 a1)
Create an AttributeAccessor for a class data member, or a lone class get functor or set method...
Definition: nstime.h:958
anonymous_namespace{wifi-phy.cc}::Constructor
Definition: wifi-phy.cc:2993
ns3::WifiModeList
std::vector< WifiMode > WifiModeList
In various parts of the code, folk are interested in maintaining a list of transmission modes...
Definition: wifi-mode.h:226
ns3::WifiPhy::GetPlcpVhtSigA1Duration
static Time GetPlcpVhtSigA1Duration(WifiPreamble preamble)
Definition: wifi-phy.cc:1420
ns3::WifiPhy::GetErpOfdmRate9Mbps
static WifiMode GetErpOfdmRate9Mbps()
Return a WifiMode for ERP-OFDM at 9Mbps.
Definition: wifi-phy.cc:2065
ns3::WifiPhy::NotifyTxEnd
void NotifyTxEnd(Ptr< const Packet > packet)
Public method used to fire a PhyTxEnd trace.
Definition: wifi-phy.cc:1954
ns3::WifiPhy::m_random
Ptr< UniformRandomVariable > m_random
Provides uniform random variables.
Definition: wifi-phy.h:1584
ns3::WifiPhy::GetStateDuration
virtual Time GetStateDuration(void)
Definition: wifi-phy.cc:2942
ns3::WIFI_PHY_STANDARD_UNSPECIFIED
Unspecified.
Definition: wifi-phy-standard.h:55
ns3::WifiPhy::InitializeFrequencyChannelNumber
void InitializeFrequencyChannelNumber(void)
post-construction setting of frequency and/or channel number
Definition: wifi-phy.cc:395
ns3::WifiModeFactory::CreateWifiMode
static WifiMode CreateWifiMode(std::string uniqueName, enum WifiModulationClass modClass, bool isMandatory, enum WifiCodeRate codingRate, uint16_t constellationSize)
Definition: wifi-mode.cc:543
NS_ASSERT_MSG
#define NS_ASSERT_MSG(condition, message)
At runtime, in debugging builds, if this condition is not true, the program prints the message to out...
Definition: assert.h:90
ns3::MakeDoubleAccessor
Ptr< const AttributeAccessor > MakeDoubleAccessor(T1 a1)
Create an AttributeAccessor for a class data member, or a lone class get functor or set method...
Definition: double.h:42
ns3::Time::GetNanoSeconds
int64_t GetNanoSeconds(void) const
Get an approximation of the time stored in this instance in the indicated unit.
Definition: nstime.h:353
ns3::WifiPhy::ConfigureStandard
virtual void ConfigureStandard(enum WifiPhyStandard standard)
Configure the PHY-level parameters for different Wi-Fi standard.
Definition: wifi-phy.cc:1026
ns3::WifiPhy::GetDevice
Ptr< NetDevice > GetDevice(void) const
Return the device this PHY is associated with.
Definition: wifi-phy.cc:604
ns3::WifiPhy::SetRxGain
void SetRxGain(double gain)
Sets the reception gain (dB).
Definition: wifi-phy.cc:520
ns3::WifiPhy::Configure80211b
void Configure80211b(void)
Configure WifiPhy with appropriate channel frequency and supported rates for 802.11b standard...
Definition: wifi-phy.cc:755
ns3::WIFI_CODE_RATE_UNDEFINED
No explicit coding (e.g., DSSS rates)
Definition: wifi-mode.h:77
ns3::WifiPhy::GetSupportedChannelWidthSet
virtual std::vector< uint32_t > GetSupportedChannelWidthSet(void) const
Definition: wifi-phy.cc:1261
ns3::WifiPhy::GetErpOfdmRate6Mbps
static WifiMode GetErpOfdmRate6Mbps()
Return a WifiMode for ERP-OFDM at 6Mbps.
Definition: wifi-phy.cc:2053
ns3::WifiTxVector::GetNss
uint8_t GetNss(void) const
Definition: wifi-tx-vector.cc:96
ns3::WifiPhy::GetErpOfdmRate12Mbps
static WifiMode GetErpOfdmRate12Mbps()
Return a WifiMode for ERP-OFDM at 12Mbps.
Definition: wifi-phy.cc:2077
ns3::WifiPhy::m_greenfield
bool m_greenfield
Flag if GreenField format is supported.
Definition: wifi-phy.h:1816
ns3::WifiPhy::ConfigureChannelForStandard
virtual void ConfigureChannelForStandard(enum WifiPhyStandard standard)
Configure the PHY-level parameters for different Wi-Fi standard.
Definition: wifi-phy.cc:975
ns3::WifiPhy::IsStateSleep
virtual bool IsStateSleep(void)
Definition: wifi-phy.cc:2936
ns3::WifiPhy::m_state
Ptr< WifiPhyStateHelper > m_state
Pointer to WifiPhyStateHelper.
Definition: wifi-phy.h:1585
ns3::WifiPhy::SetEdThreshold
void SetEdThreshold(double threshold)
Sets the energy detection threshold (dBm).
Definition: wifi-phy.cc:423
ns3::WifiPhy::NotifyRxEnd
void NotifyRxEnd(Ptr< const Packet > packet)
Public method used to fire a PhyRxEnd trace.
Definition: wifi-phy.cc:1972
ns3::WifiPhy::Configure80211n
void Configure80211n(void)
Configure WifiPhy with appropriate channel frequency and supported rates for 802.11n standard...
Definition: wifi-phy.cc:893
ns3::WifiPhy::SetTxPowerStart
void SetTxPowerStart(double start)
Sets the minimum available transmission power level (dBm).
Definition: wifi-phy.cc:468
ns3::WifiPhy::m_txPowerBaseDbm
double m_txPowerBaseDbm
Minimum transmission power (dBm)
Definition: wifi-phy.h:1810
ns3::InterferenceHelper::SetNoiseFigure
void SetNoiseFigure(double value)
Set the noise figure.
Definition: interference-helper.cc:175
NS_LOG_WARN
#define NS_LOG_WARN(msg)
Use NS_LOG to output a message of level LOG_WARN.
Definition: log.h:228
ns3::WifiPhy::IsStateSwitching
virtual bool IsStateSwitching(void)
Definition: wifi-phy.cc:2930
ns3::WifiPhy::m_frequencyChannelNumberInitialized
bool m_frequencyChannelNumberInitialized
Store initialization state.
Definition: wifi-phy.h:1803
ns3::WifiPhy::GetHtMcs19
static WifiMode GetHtMcs19()
Return MCS 19 from HT MCS values.
Definition: wifi-phy.cc:2601
ns3::WifiPhy::m_interference
InterferenceHelper m_interference
Pointer to InterferenceHelper.
Definition: wifi-phy.h:1583
ns3::WifiPhy::m_standard
enum WifiPhyStandard m_standard
WifiPhyStandard.
Definition: wifi-phy.h:1799
ns3::WifiPhy::GetSupportedTxSpatialStreams
virtual uint8_t GetSupportedTxSpatialStreams(void) const
Definition: wifi-phy.cc:1194
ns3::WifiPhy::GetHtMcs6
static WifiMode GetHtMcs6()
Return MCS 6 from HT MCS values.
Definition: wifi-phy.cc:2497
ns3::WifiPhy::m_isConstructed
bool m_isConstructed
true when ready to set frequency
Definition: wifi-phy.h:1800
ns3::WifiPhy::GetNumberOfTransmitAntennas
virtual uint32_t GetNumberOfTransmitAntennas(void) const
Definition: wifi-phy.cc:1176
NS_LOG_DEBUG
#define NS_LOG_DEBUG(msg)
Use NS_LOG to output a message of level LOG_DEBUG.
Definition: log.h:236
ns3::WifiPhy::ConfigureHtDeviceMcsSet
void ConfigureHtDeviceMcsSet(void)
Configure the device Mcs set with the appropriate HtMcs modes for the number of available transmit sp...
Definition: wifi-phy.cc:824
ns3::WIFI_MOD_CLASS_OFDM
OFDM PHY (Clause 17)
Definition: wifi-mode.h:60
ns3::WifiPhy::m_totalAmpduNumSymbols
double m_totalAmpduNumSymbols
Number of symbols previously transmitted for the MPDUs in an A-MPDU, used for the computation of the ...
Definition: wifi-phy.h:1832
ns3::WifiPhy::GetHtMcs28
static WifiMode GetHtMcs28()
Return MCS 28 from HT MCS values.
Definition: wifi-phy.cc:2673
ns3::WifiPhy::GetFrequencyWidthForChannelNumberStandard
FrequencyWidthPair GetFrequencyWidthForChannelNumberStandard(uint16_t channelNumber, enum WifiPhyStandard standard) const
Lookup frequency/width pair for channelNumber/standard pair.
Definition: wifi-phy.cc:1267
ns3::WifiPhy::GetHtMcs9
static WifiMode GetHtMcs9()
Return MCS 9 from HT MCS values.
Definition: wifi-phy.cc:2521
ns3::WifiPhy::SetFrequency
virtual void SetFrequency(uint32_t freq)
Definition: wifi-phy.cc:1086
ns3::WifiPhy::GetPlcpHeaderDuration
static Time GetPlcpHeaderDuration(WifiTxVector txVector, WifiPreamble preamble)
Definition: wifi-phy.cc:1507
ns3::WifiPhy::m_channelCenterFrequency
uint32_t m_channelCenterFrequency
Center frequency in MHz.
Definition: wifi-phy.h:1801
ns3::WifiPhy::GetChannelSwitchDelay
virtual Time GetChannelSwitchDelay(void) const
Definition: wifi-phy.cc:659
ns3::WifiPhy::GetHtMcs4
static WifiMode GetHtMcs4()
Return MCS 4 from HT MCS values.
Definition: wifi-phy.cc:2481
ns3::WifiPhy::GetHtMcs25
static WifiMode GetHtMcs25()
Return MCS 25 from HT MCS values.
Definition: wifi-phy.cc:2649
ns3::WifiPhy::m_initialFrequency
uint32_t m_initialFrequency
Store frequency until initialization.
Definition: wifi-phy.h:1802
ns3::WifiPhy::Configure80211g
void Configure80211g(void)
Configure WifiPhy with appropriate channel frequency and supported rates for 802.11g standard...
Definition: wifi-phy.cc:766
ns3::WifiPhy::WToDbm
double WToDbm(double w) const
Convert from Watts to dBm.
Definition: wifi-phy.cc:2888
ns3::WifiPhy::m_channelWidth
uint32_t m_channelWidth
Channel width.
Definition: wifi-phy.h:1804
ns3::WifiPhy::m_totalAmpduSize
uint32_t m_totalAmpduSize
Total size of the previously transmitted MPDUs in an A-MPDU, used for the computation of the number o...
Definition: wifi-phy.h:1831
ns3::WifiPhy::GetSupportedRxSpatialStreams
virtual uint8_t GetSupportedRxSpatialStreams(void) const
Definition: wifi-phy.cc:1188
ns3::MicroSeconds
Time MicroSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:911
ns3::WifiPhy::m_deviceRateSet
WifiModeList m_deviceRateSet
This vector holds the set of transmission modes that this WifiPhy(-derived class) can support...
Definition: wifi-phy.h:1794
ns3::WifiPhy::DbmToW
double DbmToW(double dbm) const
Convert from dBm to Watts.
Definition: wifi-phy.cc:2881
ns3::WifiPhy::GetHtMcs1
static WifiMode GetHtMcs1()
Return MCS 1 from HT MCS values.
Definition: wifi-phy.cc:2457
ns3::WifiPhy::GetHtMcs23
static WifiMode GetHtMcs23()
Return MCS 23 from HT MCS values.
Definition: wifi-phy.cc:2633
ns3::Object
A base class which provides memory management and object aggregation.
Definition: object.h:87
ns3::FemtoSeconds
Time FemtoSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:935
ns3::WifiPhy::GetStandard
virtual enum WifiPhyStandard GetStandard(void) const
Get the configured Wi-Fi standard.
Definition: wifi-phy.cc:1080
ns3::WifiPhy::GetDsssRate2Mbps
static WifiMode GetDsssRate2Mbps()
Return a WifiMode for DSSS at 2Mbps.
Definition: wifi-phy.cc:2011
ns3::WifiPhy::GetVhtMcs9
static WifiMode GetVhtMcs9()
Return MCS 9 from VHT MCS values.
Definition: wifi-phy.cc:2780
HT_PHY
#define HT_PHY
Definition: wifi-phy.h:49
ns3::WifiPhy::GetOfdmRate6MbpsBW10MHz
static WifiMode GetOfdmRate6MbpsBW10MHz()
Return a WifiMode for OFDM at 6Mbps with 10MHz channel spacing.
Definition: wifi-phy.cc:2275
ns3::WifiPhy::GetEdThresholdW
double GetEdThresholdW(void) const
Return the energy detection threshold.
Definition: wifi-phy.cc:430
ns3::WifiTxVector::GetMode
WifiMode GetMode(void) const
Definition: wifi-tx-vector.cc:58
ns3::WifiPhy::m_txPowerEndDbm
double m_txPowerEndDbm
Maximum transmission power (dBm)
Definition: wifi-phy.h:1811
VHT_PHY
#define VHT_PHY
Definition: wifi-phy.h:48
ns3::WifiPhy::GetShortPlcpPreambleSupported
virtual bool GetShortPlcpPreambleSupported(void) const
Return whether short PLCP preamble is supported.
Definition: wifi-phy.cc:592
ns3::WifiPhy::State
State
The state of the PHY layer.
Definition: wifi-phy.h:168
ns3::InterferenceHelper::GetNoiseFigure
double GetNoiseFigure(void) const
Return the noise figure.
Definition: interference-helper.cc:181
ns3::WIFI_PREAMBLE_SHORT
Definition: wifi-preamble.h:33
ns3::WifiPhy::GetPlcpHtTrainingSymbolDuration
static Time GetPlcpHtTrainingSymbolDuration(WifiPreamble preamble, WifiTxVector txVector)
Definition: wifi-phy.cc:1359
ns3::DoubleValue
This class can be used to hold variables of floating point type such as 'double' or 'float'...
Definition: double.h:41
ns3::WifiPhy::GetOfdmRate24MbpsBW10MHz
static WifiMode GetOfdmRate24MbpsBW10MHz()
Return a WifiMode for OFDM at 24Mbps with 10MHz channel spacing.
Definition: wifi-phy.cc:2323
ns3::WifiPhy::m_channelSwitchDelay
Time m_channelSwitchDelay
Time required to switch between channel.
Definition: wifi-phy.h:1830
ns3::WifiPhy::GetPlcpVhtSigBDuration
static Time GetPlcpVhtSigBDuration(WifiPreamble preamble)
Definition: wifi-phy.cc:1448
ns3::WifiPhy::IsStateRx
virtual bool IsStateRx(void)
Definition: wifi-phy.cc:2918
ns3::WifiPhy::m_numberOfTransmitters
uint32_t m_numberOfTransmitters
Number of transmitters.
Definition: wifi-phy.h:1820
ns3::WifiPhy::GetOfdmRate13_5MbpsBW5MHz
static WifiMode GetOfdmRate13_5MbpsBW5MHz()
Return a WifiMode for OFDM at 13.5Mbps with 5MHz channel spacing.
Definition: wifi-phy.cc:2434
ns3::WifiPhy::m_ccaMode1ThresholdW
double m_ccaMode1ThresholdW
Clear channel assessment (CCA) threshold in watts.
Definition: wifi-phy.h:1807
ns3::WifiPhy::GetCcaMode1Threshold
double GetCcaMode1Threshold(void) const
Return the CCA threshold (dBm).
Definition: wifi-phy.cc:449
ns3::MakeUintegerAccessor
Ptr< const AttributeAccessor > MakeUintegerAccessor(T1 a1)
Create an AttributeAccessor for a class data member, or a lone class get functor or set method...
Definition: uinteger.h:45
ns3::TypeId
a unique identifier for an interface.
Definition: type-id.h:58
ns3::WifiPhy::GetHtMcs15
static WifiMode GetHtMcs15()
Return MCS 15 from HT MCS values.
Definition: wifi-phy.cc:2569
ns3::WifiPhy::GetPlcpPreambleDuration
static Time GetPlcpPreambleDuration(WifiTxVector txVector, WifiPreamble preamble)
Definition: wifi-phy.cc:1571
ns3::TypeId::SetParent
TypeId SetParent(TypeId tid)
Set the parent TypeId.
Definition: type-id.cc:904
ns3::WifiPhy::GetHtMcs3
static WifiMode GetHtMcs3()
Return MCS 3 from HT MCS values.
Definition: wifi-phy.cc:2473
ns3::WifiPhy::m_initialChannelNumber
uint16_t m_initialChannelNumber
Initial channel number.
Definition: wifi-phy.h:1828
ns3::WifiPhy::DbToRatio
double DbToRatio(double db) const
Convert from dB to ratio.
Definition: wifi-phy.cc:2874
ns3::WifiPhy::GetOfdmRate6Mbps
static WifiMode GetOfdmRate6Mbps()
Return a WifiMode for OFDM at 6Mbps.
Definition: wifi-phy.cc:2152
ns3::WifiPhy::GetRxGain
double GetRxGain(void) const
Return the reception gain (dB).
Definition: wifi-phy.cc:527
ns3::WifiPhy::AssignStreams
virtual int64_t AssignStreams(int64_t stream)
Assign a fixed random variable stream number to the random variables used by this model...
Definition: wifi-phy.cc:2960
ns3::WIFI_MOD_CLASS_DSSS
DSSS PHY (Clause 15)
Definition: wifi-mode.h:50
ns3::WifiPhy::GetTxPowerStart
virtual double GetTxPowerStart(void) const
Return the minimum available transmission power level (dBm).
Definition: wifi-phy.cc:475
ns3::WifiPhy::GetPlcpVhtSigA2Duration
static Time GetPlcpVhtSigA2Duration(WifiPreamble preamble)
Definition: wifi-phy.cc:1434
ns3::WifiPhy::GetOfdmRate4_5MbpsBW5MHz
static WifiMode GetOfdmRate4_5MbpsBW5MHz()
Return a WifiMode for OFDM at 4.5Mbps with 5MHz channel spacing.
Definition: wifi-phy.cc:2386
ns3::WifiPhy::m_nTxPower
uint32_t m_nTxPower
Number of available transmission power levels.
Definition: wifi-phy.h:1812
ns3::WifiPhy::m_stbc
bool m_stbc
Flag if STBC is used.
Definition: wifi-phy.h:1815
ns3::WifiPhy::Configure80211a
void Configure80211a(void)
Configure WifiPhy with appropriate channel frequency and supported rates for 802.11a standard...
Definition: wifi-phy.cc:740
ns3::mpduType
mpduType
This enumeration defines the type of an MPDU.
Definition: wifi-phy.h:56
ns3::WifiPhy::SetErrorRateModel
void SetErrorRateModel(Ptr< ErrorRateModel > rate)
Sets the error rate model.
Definition: wifi-phy.cc:629
ns3::WifiPhy::ChannelToFrequencyWidthMap
std::map< ChannelNumberStandardPair, FrequencyWidthPair > ChannelToFrequencyWidthMap
Definition: wifi-phy.h:1823
ns3::WifiPhy::GetOfdmRate3MbpsBW10MHz
static WifiMode GetOfdmRate3MbpsBW10MHz()
Return a WifiMode for OFDM at 3Mbps with 10MHz channel spacing.
Definition: wifi-phy.cc:2251
ns3::WifiPhy::m_phyTxEndTrace
TracedCallback< Ptr< const Packet > > m_phyTxEndTrace
The trace source fired when a packet ends the transmission process on the medium. ...
Definition: wifi-phy.h:1695
ns3::WifiPhy::m_guardInterval
bool m_guardInterval
Flag if short guard interval is used.
Definition: wifi-phy.h:1817
ns3::WifiPhy::GetMode
virtual WifiMode GetMode(uint32_t mode) const
The WifiPhy::GetNModes() and WifiPhy::GetMode() methods are used (e.g., by a WifiRemoteStationManager...
Definition: wifi-phy.cc:2856
ns3::WIFI_PREAMBLE_HT_MF
Definition: wifi-preamble.h:34
ns3::LAST_MPDU_IN_AGGREGATE
The MPDU is the last aggregate in an A-MPDU.
Definition: wifi-phy.h:63