A Discrete-Event Network Simulator
API
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
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  * Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
19  */
20 
21 #include "wifi-phy.h"
22 #include "wifi-mode.h"
23 #include "wifi-channel.h"
24 #include "wifi-preamble.h"
25 #include "ns3/simulator.h"
26 #include "ns3/packet.h"
27 #include "ns3/assert.h"
28 #include "ns3/log.h"
29 #include "ns3/double.h"
30 #include "ns3/uinteger.h"
31 #include "ns3/enum.h"
32 #include "ns3/trace-source-accessor.h"
33 #include <cmath>
34 
35 NS_LOG_COMPONENT_DEFINE ("WifiPhy");
36 
37 namespace ns3 {
38 
39 /****************************************************************
40  * This destructor is needed.
41  ****************************************************************/
42 
43 WifiPhyListener::~WifiPhyListener ()
44 {
45 }
46 
47 /****************************************************************
48  * The actual WifiPhy class
49  ****************************************************************/
50 
51 NS_OBJECT_ENSURE_REGISTERED (WifiPhy)
52  ;
53 
54 TypeId
55 WifiPhy::GetTypeId (void)
56 {
57  static TypeId tid = TypeId ("ns3::WifiPhy")
58  .SetParent<Object> ()
59  .AddTraceSource ("PhyTxBegin",
60  "Trace source indicating a packet has begun transmitting over the channel medium",
61  MakeTraceSourceAccessor (&WifiPhy::m_phyTxBeginTrace))
62  .AddTraceSource ("PhyTxEnd",
63  "Trace source indicating a packet has been completely transmitted over the channel. NOTE: the only official WifiPhy implementation available to this date (YansWifiPhy) never fires this trace source.",
64  MakeTraceSourceAccessor (&WifiPhy::m_phyTxEndTrace))
65  .AddTraceSource ("PhyTxDrop",
66  "Trace source indicating a packet has been dropped by the device during transmission",
67  MakeTraceSourceAccessor (&WifiPhy::m_phyTxDropTrace))
68  .AddTraceSource ("PhyRxBegin",
69  "Trace source indicating a packet has begun being received from the channel medium by the device",
70  MakeTraceSourceAccessor (&WifiPhy::m_phyRxBeginTrace))
71  .AddTraceSource ("PhyRxEnd",
72  "Trace source indicating a packet has been completely received from the channel medium by the device",
73  MakeTraceSourceAccessor (&WifiPhy::m_phyRxEndTrace))
74  .AddTraceSource ("PhyRxDrop",
75  "Trace source indicating a packet has been dropped by the device during reception",
76  MakeTraceSourceAccessor (&WifiPhy::m_phyRxDropTrace))
77  .AddTraceSource ("MonitorSnifferRx",
78  "Trace source simulating a wifi device in monitor mode sniffing all received frames",
79  MakeTraceSourceAccessor (&WifiPhy::m_phyMonitorSniffRxTrace))
80  .AddTraceSource ("MonitorSnifferTx",
81  "Trace source simulating the capability of a wifi device in monitor mode to sniff all frames being transmitted",
82  MakeTraceSourceAccessor (&WifiPhy::m_phyMonitorSniffTxTrace))
83  ;
84  return tid;
85 }
86 
87 WifiPhy::WifiPhy ()
88 {
89  NS_LOG_FUNCTION (this);
90 }
91 
92 WifiPhy::~WifiPhy ()
93 {
94  NS_LOG_FUNCTION (this);
95 }
96 
97 //Added by Ghada to support 11n
98 
99 //return the L-SIG
100 WifiMode
101 WifiPhy::GetMFPlcpHeaderMode (WifiMode payloadMode, WifiPreamble preamble)
102 {
103  switch (payloadMode.GetBandwidth ())
104  {
105  case 20000000:
106  return WifiPhy::GetOfdmRate6_5MbpsBW20MHz ();
107  case 40000000:
108  return WifiPhy::GetOfdmRate13_5MbpsBW40MHz ();
109  default:
110  return WifiPhy::GetOfdmRate6_5MbpsBW20MHz ();
111  }
112 }
113 uint32_t
114 WifiPhy::GetPlcpHtTrainingSymbolDurationMicroSeconds (WifiMode payloadMode, WifiPreamble preamble, WifiTxVector txvector)
115 {
116  switch (preamble)
117  {
118  case WIFI_PREAMBLE_HT_MF:
119  return 4+ (4* txvector.GetNss());
120  case WIFI_PREAMBLE_HT_GF:
121  return (4*txvector.GetNss())+(4*txvector.GetNess());
122  default:
123  // no training for non HT
124  return 0;
125  }
126 }
127 
128 //return L-SIG
129 uint32_t
130 WifiPhy::GetPlcpHtSigHeaderDurationMicroSeconds (WifiMode payloadMode, WifiPreamble preamble)
131 {
132  switch (preamble)
133  {
134  case WIFI_PREAMBLE_HT_MF:
135  // HT-SIG
136  return 8;
137  case WIFI_PREAMBLE_HT_GF:
138  //HT-SIG
139  return 8;
140  default:
141  // no HT-SIG for non HT
142  return 0;
143  }
144 
145 }
146 //end added by Ghada
147 
148 WifiMode
149 WifiPhy::GetPlcpHeaderMode (WifiMode payloadMode, WifiPreamble preamble)
150 {
151  switch (payloadMode.GetModulationClass ())
152  {
153  case WIFI_MOD_CLASS_OFDM:
154  {
155  switch (payloadMode.GetBandwidth ())
156  {
157  case 5000000:
158  return WifiPhy::GetOfdmRate1_5MbpsBW5MHz ();
159  case 10000000:
160  return WifiPhy::GetOfdmRate3MbpsBW10MHz ();
161  default:
162  // IEEE Std 802.11-2007, 17.3.2
163  // actually this is only the first part of the PlcpHeader,
164  // because the last 16 bits of the PlcpHeader are using the
165  // same mode of the payload
166  return WifiPhy::GetOfdmRate6Mbps ();
167  }
168  }
169  //Added by Ghada to support 11n
170  case WIFI_MOD_CLASS_HT:
171  { //return the HT-SIG
172  // IEEE Std 802.11n, 20.3.23
173  switch (preamble)
174  {
175  case WIFI_PREAMBLE_HT_MF:
176  switch (payloadMode.GetBandwidth ())
177  {
178  case 20000000:
179  return WifiPhy::GetOfdmRate13MbpsBW20MHz ();
180  case 40000000:
181  return WifiPhy::GetOfdmRate27MbpsBW40MHz ();
182  default:
183  return WifiPhy::GetOfdmRate13MbpsBW20MHz ();
184  }
185  case WIFI_PREAMBLE_HT_GF:
186  switch (payloadMode.GetBandwidth ())
187  {
188  case 20000000:
189  return WifiPhy::GetOfdmRate13MbpsBW20MHz ();
190  case 40000000:
191  return WifiPhy::GetOfdmRate27MbpsBW40MHz ();
192  default:
193  return WifiPhy::GetOfdmRate13MbpsBW20MHz ();
194  }
195  default:
196  return WifiPhy::GetOfdmRate6Mbps ();
197  }
198  }
199  case WIFI_MOD_CLASS_ERP_OFDM:
200  return WifiPhy::GetErpOfdmRate6Mbps ();
201 
202  case WIFI_MOD_CLASS_DSSS:
203  if (preamble == WIFI_PREAMBLE_LONG)
204  {
205  // IEEE Std 802.11-2007, sections 15.2.3 and 18.2.2.1
206  return WifiPhy::GetDsssRate1Mbps ();
207  }
208  else // WIFI_PREAMBLE_SHORT
209  {
210  // IEEE Std 802.11-2007, section 18.2.2.2
211  return WifiPhy::GetDsssRate2Mbps ();
212  }
213 
214  default:
215  NS_FATAL_ERROR ("unsupported modulation class");
216  return WifiMode ();
217  }
218 }
219 
220 
221 uint32_t
222 WifiPhy::GetPlcpHeaderDurationMicroSeconds (WifiMode payloadMode, WifiPreamble preamble)
223 {
224  switch (payloadMode.GetModulationClass ())
225  {
226  case WIFI_MOD_CLASS_OFDM:
227  {
228  switch (payloadMode.GetBandwidth ())
229  {
230  case 20000000:
231  default:
232  // IEEE Std 802.11-2007, section 17.3.3 and figure 17-4
233  // also section 17.3.2.3, table 17-4
234  // We return the duration of the SIGNAL field only, since the
235  // SERVICE field (which strictly speaking belongs to the PLCP
236  // header, see section 17.3.2 and figure 17-1) is sent using the
237  // payload mode.
238  return 4;
239  case 10000000:
240  // IEEE Std 802.11-2007, section 17.3.2.3, table 17-4
241  return 8;
242  case 5000000:
243  // IEEE Std 802.11-2007, section 17.3.2.3, table 17-4
244  return 16;
245  }
246  }
247  //Added by Ghada to support 11n
248  case WIFI_MOD_CLASS_HT:
249  { //IEEE 802.11n Figure 20.1
250  switch (preamble)
251  {
252  case WIFI_PREAMBLE_HT_MF:
253  // L-SIG
254  return 4;
255  case WIFI_PREAMBLE_HT_GF:
256  //L-SIG
257  return 0;
258  default:
259  // L-SIG
260  return 4;
261  }
262  }
263  case WIFI_MOD_CLASS_ERP_OFDM:
264  return 4;
265 
266  case WIFI_MOD_CLASS_DSSS:
267  if (preamble == WIFI_PREAMBLE_SHORT)
268  {
269  // IEEE Std 802.11-2007, section 18.2.2.2 and figure 18-2
270  return 24;
271  }
272  else // WIFI_PREAMBLE_LONG
273  {
274  // IEEE Std 802.11-2007, sections 18.2.2.1 and figure 18-1
275  return 48;
276  }
277 
278  default:
279  NS_FATAL_ERROR ("unsupported modulation class");
280  return 0;
281  }
282 }
283 
284 uint32_t
285 WifiPhy::GetPlcpPreambleDurationMicroSeconds (WifiMode payloadMode, WifiPreamble preamble)
286 {
287  switch (payloadMode.GetModulationClass ())
288  {
289  case WIFI_MOD_CLASS_OFDM:
290  {
291  switch (payloadMode.GetBandwidth ())
292  {
293  case 20000000:
294  default:
295  // IEEE Std 802.11-2007, section 17.3.3, figure 17-4
296  // also section 17.3.2.3, table 17-4
297  return 16;
298  case 10000000:
299  // IEEE Std 802.11-2007, section 17.3.3, table 17-4
300  // also section 17.3.2.3, table 17-4
301  return 32;
302  case 5000000:
303  // IEEE Std 802.11-2007, section 17.3.3
304  // also section 17.3.2.3, table 17-4
305  return 64;
306  }
307  }
308  case WIFI_MOD_CLASS_HT:
309  { //IEEE 802.11n Figure 20.1 the training symbols before L_SIG or HT_SIG
310  return 16;
311  }
312  case WIFI_MOD_CLASS_ERP_OFDM:
313  return 16;
314 
315  case WIFI_MOD_CLASS_DSSS:
316  if (preamble == WIFI_PREAMBLE_SHORT)
317  {
318  // IEEE Std 802.11-2007, section 18.2.2.2 and figure 18-2
319  return 72;
320  }
321  else // WIFI_PREAMBLE_LONG
322  {
323  // IEEE Std 802.11-2007, sections 18.2.2.1 and figure 18-1
324  return 144;
325  }
326  default:
327  NS_FATAL_ERROR ("unsupported modulation class");
328  return 0;
329  }
330 }
331 
332 double
333 WifiPhy::GetPayloadDurationMicroSeconds (uint32_t size, WifiTxVector txvector)
334 {
335  WifiMode payloadMode=txvector.GetMode();
336 
337  NS_LOG_FUNCTION (size << payloadMode);
338 
339  switch (payloadMode.GetModulationClass ())
340  {
341  case WIFI_MOD_CLASS_OFDM:
342  case WIFI_MOD_CLASS_ERP_OFDM:
343  {
344  // IEEE Std 802.11-2007, section 17.3.2.3, table 17-4
345  // corresponds to T_{SYM} in the table
346  uint32_t symbolDurationUs;
347 
348  switch (payloadMode.GetBandwidth ())
349  {
350  case 20000000:
351  default:
352  symbolDurationUs = 4;
353  break;
354  case 10000000:
355  symbolDurationUs = 8;
356  break;
357  case 5000000:
358  symbolDurationUs = 16;
359  break;
360  }
361 
362  // IEEE Std 802.11-2007, section 17.3.2.2, table 17-3
363  // corresponds to N_{DBPS} in the table
364  double numDataBitsPerSymbol = payloadMode.GetDataRate () * symbolDurationUs / 1e6;
365 
366  // IEEE Std 802.11-2007, section 17.3.5.3, equation (17-11)
367  uint32_t numSymbols = lrint (ceil ((16 + size * 8.0 + 6.0) / numDataBitsPerSymbol));
368 
369  // Add signal extension for ERP PHY
370  if (payloadMode.GetModulationClass () == WIFI_MOD_CLASS_ERP_OFDM)
371  {
372  return numSymbols * symbolDurationUs + 6;
373  }
374  else
375  {
376  return numSymbols * symbolDurationUs;
377  }
378  }
379  case WIFI_MOD_CLASS_HT:
380  {
381  double symbolDurationUs;
382  double m_Stbc;
383  //if short GI data rate is used then symbol duration is 3.6us else symbol duration is 4us
384  //In the future has to create a stationmanager that only uses these data rates if sender and reciever support GI
385  if (payloadMode.GetUniqueName() == "OfdmRate135MbpsBW40MHzShGi" || payloadMode.GetUniqueName() == "OfdmRate65MbpsBW20MHzShGi" )
386  {
387  symbolDurationUs=3.6;
388  }
389  else
390  {
391  switch (payloadMode.GetDataRate ()/ (txvector.GetNss()))
392  { //shortGi
393  case 7200000:
394  case 14400000:
395  case 21700000:
396  case 28900000:
397  case 43300000:
398  case 57800000:
399  case 72200000:
400  case 15000000:
401  case 30000000:
402  case 45000000:
403  case 60000000:
404  case 90000000:
405  case 120000000:
406  case 150000000:
407  symbolDurationUs=3.6;
408  break;
409  default:
410  symbolDurationUs=4;
411  }
412  }
413  if (txvector.IsStbc())
414  m_Stbc=2;
415  else
416  m_Stbc=1;
417  double numDataBitsPerSymbol = payloadMode.GetDataRate () *txvector.GetNss() * symbolDurationUs / 1e6;
418  //check tables 20-35 and 20-36 in the standard to get cases when nes =2
419  double Nes=1;
420  // IEEE Std 802.11n, section 20.3.11, equation (20-32)
421  uint32_t numSymbols = lrint (m_Stbc*ceil ((16 + size * 8.0 + 6.0*Nes) / (m_Stbc* numDataBitsPerSymbol)));
422 
423  return numSymbols * symbolDurationUs;
424 
425  }
426  case WIFI_MOD_CLASS_DSSS:
427  // IEEE Std 802.11-2007, section 18.2.3.5
428  NS_LOG_LOGIC (" size=" << size
429  << " mode=" << payloadMode
430  << " rate=" << payloadMode.GetDataRate () );
431  return lrint (ceil ((size * 8.0) / (payloadMode.GetDataRate () / 1.0e6)));
432 
433  default:
434  NS_FATAL_ERROR ("unsupported modulation class");
435  return 0;
436  }
437 }
438 
439 Time
440 WifiPhy::CalculateTxDuration (uint32_t size, WifiTxVector txvector, WifiPreamble preamble)
441 {
442  WifiMode payloadMode=txvector.GetMode();
443  double duration = GetPlcpPreambleDurationMicroSeconds (payloadMode, preamble)
444  + GetPlcpHeaderDurationMicroSeconds (payloadMode, preamble)
445  + GetPlcpHtSigHeaderDurationMicroSeconds (payloadMode, preamble)
446  + GetPlcpHtTrainingSymbolDurationMicroSeconds (payloadMode, preamble,txvector)
447  + GetPayloadDurationMicroSeconds (size, txvector);
448  return MicroSeconds (duration);
449 }
450 
451 
452 
453 void
454 WifiPhy::NotifyTxBegin (Ptr<const Packet> packet)
455 {
456  m_phyTxBeginTrace (packet);
457 }
458 
459 void
460 WifiPhy::NotifyTxEnd (Ptr<const Packet> packet)
461 {
462  m_phyTxEndTrace (packet);
463 }
464 
465 void
466 WifiPhy::NotifyTxDrop (Ptr<const Packet> packet)
467 {
468  m_phyTxDropTrace (packet);
469 }
470 
471 void
472 WifiPhy::NotifyRxBegin (Ptr<const Packet> packet)
473 {
474  m_phyRxBeginTrace (packet);
475 }
476 
477 void
478 WifiPhy::NotifyRxEnd (Ptr<const Packet> packet)
479 {
480  m_phyRxEndTrace (packet);
481 }
482 
483 void
484 WifiPhy::NotifyRxDrop (Ptr<const Packet> packet)
485 {
486  m_phyRxDropTrace (packet);
487 }
488 
489 void
490 WifiPhy::NotifyMonitorSniffRx (Ptr<const Packet> packet, uint16_t channelFreqMhz, uint16_t channelNumber, uint32_t rate, bool isShortPreamble, double signalDbm, double noiseDbm)
491 {
492  m_phyMonitorSniffRxTrace (packet, channelFreqMhz, channelNumber, rate, isShortPreamble, signalDbm, noiseDbm);
493 }
494 
495 void
496 WifiPhy::NotifyMonitorSniffTx (Ptr<const Packet> packet, uint16_t channelFreqMhz, uint16_t channelNumber, uint32_t rate, bool isShortPreamble, uint8_t txPower)
497 {
498  m_phyMonitorSniffTxTrace (packet, channelFreqMhz, channelNumber, rate, isShortPreamble, txPower);
499 }
500 
501 
502 // Clause 15 rates (DSSS)
503 
504 WifiMode
505 WifiPhy::GetDsssRate1Mbps ()
506 {
507  static WifiMode mode =
508  WifiModeFactory::CreateWifiMode ("DsssRate1Mbps",
509  WIFI_MOD_CLASS_DSSS,
510  true,
511  22000000, 1000000,
512  WIFI_CODE_RATE_UNDEFINED,
513  2);
514  return mode;
515 }
516 
517 WifiMode
518 WifiPhy::GetDsssRate2Mbps ()
519 {
520  static WifiMode mode =
521  WifiModeFactory::CreateWifiMode ("DsssRate2Mbps",
522  WIFI_MOD_CLASS_DSSS,
523  true,
524  22000000, 2000000,
525  WIFI_CODE_RATE_UNDEFINED,
526  4);
527  return mode;
528 }
529 
530 
531 // Clause 18 rates (HR/DSSS)
532 
533 WifiMode
534 WifiPhy::GetDsssRate5_5Mbps ()
535 {
536  static WifiMode mode =
537  WifiModeFactory::CreateWifiMode ("DsssRate5_5Mbps",
538  WIFI_MOD_CLASS_DSSS,
539  true,
540  22000000, 5500000,
541  WIFI_CODE_RATE_UNDEFINED,
542  4);
543  return mode;
544 }
545 
546 WifiMode
547 WifiPhy::GetDsssRate11Mbps ()
548 {
549  static WifiMode mode =
550  WifiModeFactory::CreateWifiMode ("DsssRate11Mbps",
551  WIFI_MOD_CLASS_DSSS,
552  true,
553  22000000, 11000000,
554  WIFI_CODE_RATE_UNDEFINED,
555  4);
556  return mode;
557 }
558 
559 
560 // Clause 19.5 rates (ERP-OFDM)
561 
562 WifiMode
563 WifiPhy::GetErpOfdmRate6Mbps ()
564 {
565  static WifiMode mode =
566  WifiModeFactory::CreateWifiMode ("ErpOfdmRate6Mbps",
567  WIFI_MOD_CLASS_ERP_OFDM,
568  true,
569  20000000, 6000000,
570  WIFI_CODE_RATE_1_2,
571  2);
572  return mode;
573 }
574 
575 WifiMode
576 WifiPhy::GetErpOfdmRate9Mbps ()
577 {
578  static WifiMode mode =
579  WifiModeFactory::CreateWifiMode ("ErpOfdmRate9Mbps",
580  WIFI_MOD_CLASS_ERP_OFDM,
581  false,
582  20000000, 9000000,
583  WIFI_CODE_RATE_3_4,
584  2);
585  return mode;
586 }
587 
588 WifiMode
589 WifiPhy::GetErpOfdmRate12Mbps ()
590 {
591  static WifiMode mode =
592  WifiModeFactory::CreateWifiMode ("ErpOfdmRate12Mbps",
593  WIFI_MOD_CLASS_ERP_OFDM,
594  true,
595  20000000, 12000000,
596  WIFI_CODE_RATE_1_2,
597  4);
598  return mode;
599 }
600 
601 WifiMode
602 WifiPhy::GetErpOfdmRate18Mbps ()
603 {
604  static WifiMode mode =
605  WifiModeFactory::CreateWifiMode ("ErpOfdmRate18Mbps",
606  WIFI_MOD_CLASS_ERP_OFDM,
607  false,
608  20000000, 18000000,
609  WIFI_CODE_RATE_3_4,
610  4);
611  return mode;
612 }
613 
614 WifiMode
615 WifiPhy::GetErpOfdmRate24Mbps ()
616 {
617  static WifiMode mode =
618  WifiModeFactory::CreateWifiMode ("ErpOfdmRate24Mbps",
619  WIFI_MOD_CLASS_ERP_OFDM,
620  true,
621  20000000, 24000000,
622  WIFI_CODE_RATE_1_2,
623  16);
624  return mode;
625 }
626 
627 WifiMode
628 WifiPhy::GetErpOfdmRate36Mbps ()
629 {
630  static WifiMode mode =
631  WifiModeFactory::CreateWifiMode ("ErpOfdmRate36Mbps",
632  WIFI_MOD_CLASS_ERP_OFDM,
633  false,
634  20000000, 36000000,
635  WIFI_CODE_RATE_3_4,
636  16);
637  return mode;
638 }
639 
640 WifiMode
641 WifiPhy::GetErpOfdmRate48Mbps ()
642 {
643  static WifiMode mode =
644  WifiModeFactory::CreateWifiMode ("ErpOfdmRate48Mbps",
645  WIFI_MOD_CLASS_ERP_OFDM,
646  false,
647  20000000, 48000000,
648  WIFI_CODE_RATE_2_3,
649  64);
650  return mode;
651 }
652 
653 WifiMode
654 WifiPhy::GetErpOfdmRate54Mbps ()
655 {
656  static WifiMode mode =
657  WifiModeFactory::CreateWifiMode ("ErpOfdmRate54Mbps",
658  WIFI_MOD_CLASS_ERP_OFDM,
659  false,
660  20000000, 54000000,
661  WIFI_CODE_RATE_3_4,
662  64);
663  return mode;
664 }
665 
666 
667 // Clause 17 rates (OFDM)
668 
669 WifiMode
670 WifiPhy::GetOfdmRate6Mbps ()
671 {
672  static WifiMode mode =
673  WifiModeFactory::CreateWifiMode ("OfdmRate6Mbps",
674  WIFI_MOD_CLASS_OFDM,
675  true,
676  20000000, 6000000,
677  WIFI_CODE_RATE_1_2,
678  2);
679  return mode;
680 }
681 
682 WifiMode
683 WifiPhy::GetOfdmRate9Mbps ()
684 {
685  static WifiMode mode =
686  WifiModeFactory::CreateWifiMode ("OfdmRate9Mbps",
687  WIFI_MOD_CLASS_OFDM,
688  false,
689  20000000, 9000000,
690  WIFI_CODE_RATE_3_4,
691  2);
692  return mode;
693 }
694 
695 WifiMode
696 WifiPhy::GetOfdmRate12Mbps ()
697 {
698  static WifiMode mode =
699  WifiModeFactory::CreateWifiMode ("OfdmRate12Mbps",
700  WIFI_MOD_CLASS_OFDM,
701  true,
702  20000000, 12000000,
703  WIFI_CODE_RATE_1_2,
704  4);
705  return mode;
706 }
707 
708 WifiMode
709 WifiPhy::GetOfdmRate18Mbps ()
710 {
711  static WifiMode mode =
712  WifiModeFactory::CreateWifiMode ("OfdmRate18Mbps",
713  WIFI_MOD_CLASS_OFDM,
714  false,
715  20000000, 18000000,
716  WIFI_CODE_RATE_3_4,
717  4);
718  return mode;
719 }
720 
721 WifiMode
722 WifiPhy::GetOfdmRate24Mbps ()
723 {
724  static WifiMode mode =
725  WifiModeFactory::CreateWifiMode ("OfdmRate24Mbps",
726  WIFI_MOD_CLASS_OFDM,
727  true,
728  20000000, 24000000,
729  WIFI_CODE_RATE_1_2,
730  16);
731  return mode;
732 }
733 
734 WifiMode
735 WifiPhy::GetOfdmRate36Mbps ()
736 {
737  static WifiMode mode =
738  WifiModeFactory::CreateWifiMode ("OfdmRate36Mbps",
739  WIFI_MOD_CLASS_OFDM,
740  false,
741  20000000, 36000000,
742  WIFI_CODE_RATE_3_4,
743  16);
744  return mode;
745 }
746 
747 WifiMode
748 WifiPhy::GetOfdmRate48Mbps ()
749 {
750  static WifiMode mode =
751  WifiModeFactory::CreateWifiMode ("OfdmRate48Mbps",
752  WIFI_MOD_CLASS_OFDM,
753  false,
754  20000000, 48000000,
755  WIFI_CODE_RATE_2_3,
756  64);
757  return mode;
758 }
759 
760 WifiMode
761 WifiPhy::GetOfdmRate54Mbps ()
762 {
763  static WifiMode mode =
764  WifiModeFactory::CreateWifiMode ("OfdmRate54Mbps",
765  WIFI_MOD_CLASS_OFDM,
766  false,
767  20000000, 54000000,
768  WIFI_CODE_RATE_3_4,
769  64);
770  return mode;
771 }
772 
773 // 10 MHz channel rates
774 
775 WifiMode
776 WifiPhy::GetOfdmRate3MbpsBW10MHz ()
777 {
778  static WifiMode mode =
779  WifiModeFactory::CreateWifiMode ("OfdmRate3MbpsBW10MHz",
780  WIFI_MOD_CLASS_OFDM,
781  true,
782  10000000, 3000000,
783  WIFI_CODE_RATE_1_2,
784  2);
785  return mode;
786 }
787 
788 WifiMode
789 WifiPhy::GetOfdmRate4_5MbpsBW10MHz ()
790 {
791  static WifiMode mode =
792  WifiModeFactory::CreateWifiMode ("OfdmRate4_5MbpsBW10MHz",
793  WIFI_MOD_CLASS_OFDM,
794  false,
795  10000000, 4500000,
796  WIFI_CODE_RATE_3_4,
797  2);
798  return mode;
799 }
800 
801 WifiMode
802 WifiPhy::GetOfdmRate6MbpsBW10MHz ()
803 {
804  static WifiMode mode =
805  WifiModeFactory::CreateWifiMode ("OfdmRate6MbpsBW10MHz",
806  WIFI_MOD_CLASS_OFDM,
807  true,
808  10000000, 6000000,
809  WIFI_CODE_RATE_1_2,
810  4);
811  return mode;
812 }
813 
814 WifiMode
815 WifiPhy::GetOfdmRate9MbpsBW10MHz ()
816 {
817  static WifiMode mode =
818  WifiModeFactory::CreateWifiMode ("OfdmRate9MbpsBW10MHz",
819  WIFI_MOD_CLASS_OFDM,
820  false,
821  10000000, 9000000,
822  WIFI_CODE_RATE_3_4,
823  4);
824  return mode;
825 }
826 
827 WifiMode
828 WifiPhy::GetOfdmRate12MbpsBW10MHz ()
829 {
830  static WifiMode mode =
831  WifiModeFactory::CreateWifiMode ("OfdmRate12MbpsBW10MHz",
832  WIFI_MOD_CLASS_OFDM,
833  true,
834  10000000, 12000000,
835  WIFI_CODE_RATE_1_2,
836  16);
837  return mode;
838 }
839 
840 WifiMode
841 WifiPhy::GetOfdmRate18MbpsBW10MHz ()
842 {
843  static WifiMode mode =
844  WifiModeFactory::CreateWifiMode ("OfdmRate18MbpsBW10MHz",
845  WIFI_MOD_CLASS_OFDM,
846  false,
847  10000000, 18000000,
848  WIFI_CODE_RATE_3_4,
849  16);
850  return mode;
851 }
852 
853 WifiMode
854 WifiPhy::GetOfdmRate24MbpsBW10MHz ()
855 {
856  static WifiMode mode =
857  WifiModeFactory::CreateWifiMode ("OfdmRate24MbpsBW10MHz",
858  WIFI_MOD_CLASS_OFDM,
859  false,
860  10000000, 24000000,
861  WIFI_CODE_RATE_2_3,
862  64);
863  return mode;
864 }
865 
866 WifiMode
867 WifiPhy::GetOfdmRate27MbpsBW10MHz ()
868 {
869  static WifiMode mode =
870  WifiModeFactory::CreateWifiMode ("OfdmRate27MbpsBW10MHz",
871  WIFI_MOD_CLASS_OFDM,
872  false,
873  10000000, 27000000,
874  WIFI_CODE_RATE_3_4,
875  64);
876  return mode;
877 }
878 
879 // 5 MHz channel rates
880 
881 WifiMode
882 WifiPhy::GetOfdmRate1_5MbpsBW5MHz ()
883 {
884  static WifiMode mode =
885  WifiModeFactory::CreateWifiMode ("OfdmRate1_5MbpsBW5MHz",
886  WIFI_MOD_CLASS_OFDM,
887  true,
888  5000000, 1500000,
889  WIFI_CODE_RATE_1_2,
890  2);
891  return mode;
892 }
893 
894 WifiMode
895 WifiPhy::GetOfdmRate2_25MbpsBW5MHz ()
896 {
897  static WifiMode mode =
898  WifiModeFactory::CreateWifiMode ("OfdmRate2_25MbpsBW5MHz",
899  WIFI_MOD_CLASS_OFDM,
900  false,
901  5000000, 2250000,
902  WIFI_CODE_RATE_3_4,
903  2);
904  return mode;
905 }
906 
907 WifiMode
908 WifiPhy::GetOfdmRate3MbpsBW5MHz ()
909 {
910  static WifiMode mode =
911  WifiModeFactory::CreateWifiMode ("OfdmRate3MbpsBW5MHz",
912  WIFI_MOD_CLASS_OFDM,
913  true,
914  5000000, 3000000,
915  WIFI_CODE_RATE_1_2,
916  4);
917  return mode;
918 }
919 
920 WifiMode
921 WifiPhy::GetOfdmRate4_5MbpsBW5MHz ()
922 {
923  static WifiMode mode =
924  WifiModeFactory::CreateWifiMode ("OfdmRate4_5MbpsBW5MHz",
925  WIFI_MOD_CLASS_OFDM,
926  false,
927  5000000, 4500000,
928  WIFI_CODE_RATE_3_4,
929  4);
930  return mode;
931 }
932 
933 WifiMode
934 WifiPhy::GetOfdmRate6MbpsBW5MHz ()
935 {
936  static WifiMode mode =
937  WifiModeFactory::CreateWifiMode ("OfdmRate6MbpsBW5MHz",
938  WIFI_MOD_CLASS_OFDM,
939  true,
940  5000000, 6000000,
941  WIFI_CODE_RATE_1_2,
942  16);
943  return mode;
944 }
945 
946 WifiMode
947 WifiPhy::GetOfdmRate9MbpsBW5MHz ()
948 {
949  static WifiMode mode =
950  WifiModeFactory::CreateWifiMode ("OfdmRate9MbpsBW5MHz",
951  WIFI_MOD_CLASS_OFDM,
952  false,
953  5000000, 9000000,
954  WIFI_CODE_RATE_3_4,
955  16);
956  return mode;
957 }
958 
959 WifiMode
960 WifiPhy::GetOfdmRate12MbpsBW5MHz ()
961 {
962  static WifiMode mode =
963  WifiModeFactory::CreateWifiMode ("OfdmRate12MbpsBW5MHz",
964  WIFI_MOD_CLASS_OFDM,
965  false,
966  5000000, 12000000,
967  WIFI_CODE_RATE_2_3,
968  64);
969  return mode;
970 }
971 
972 WifiMode
973 WifiPhy::GetOfdmRate13_5MbpsBW5MHz ()
974 {
975  static WifiMode mode =
976  WifiModeFactory::CreateWifiMode ("OfdmRate13_5MbpsBW5MHz",
977  WIFI_MOD_CLASS_OFDM,
978  false,
979  5000000, 13500000,
980  WIFI_CODE_RATE_3_4,
981  64);
982  return mode;
983 }
984 
985 // Clause 20
986 
987 WifiMode
988 WifiPhy::GetOfdmRate6_5MbpsBW20MHz ()
989 {
990  static WifiMode mode =
991  WifiModeFactory::CreateWifiMode ("OfdmRate6_5MbpsBW20MHz",
992  WIFI_MOD_CLASS_HT,
993  true,
994  20000000, 6500000,
995  WIFI_CODE_RATE_1_2,
996  2);
997  return mode;
998 }
999 WifiMode
1000 WifiPhy::GetOfdmRate7_2MbpsBW20MHz ()
1001 {
1002  static WifiMode mode =
1003  WifiModeFactory::CreateWifiMode ("OfdmRate7_2MbpsBW20MHz",
1004  WIFI_MOD_CLASS_HT,
1005  false,
1006  20000000, 7200000,
1007  WIFI_CODE_RATE_1_2,
1008  2);
1009  return mode;
1010 }
1011 
1012 WifiMode
1013 WifiPhy::GetOfdmRate13MbpsBW20MHz ()
1014 {
1015  static WifiMode mode =
1016  WifiModeFactory::CreateWifiMode ("OfdmRate13MbpsBW20MHz",
1017  WIFI_MOD_CLASS_HT,
1018  true,
1019  20000000, 13000000,
1020  WIFI_CODE_RATE_1_2,
1021  4);
1022  return mode;
1023 }
1024 
1025 WifiMode
1026 WifiPhy::GetOfdmRate14_4MbpsBW20MHz ()
1027 {
1028  static WifiMode mode =
1029  WifiModeFactory::CreateWifiMode ("OfdmRate14_4MbpsBW20MHz",
1030  WIFI_MOD_CLASS_HT,
1031  false,
1032  20000000, 14400000,
1033  WIFI_CODE_RATE_1_2,
1034  4);
1035  return mode;
1036 }
1037 WifiMode
1038 WifiPhy::GetOfdmRate19_5MbpsBW20MHz ()
1039 {
1040  static WifiMode mode =
1041  WifiModeFactory::CreateWifiMode ("OfdmRate19_5MbpsBW20MHz",
1042  WIFI_MOD_CLASS_HT,
1043  true,
1044  20000000, 19500000,
1045  WIFI_CODE_RATE_3_4,
1046  4);
1047  return mode;
1048 }
1049 
1050 WifiMode
1051 WifiPhy::GetOfdmRate21_7MbpsBW20MHz ()
1052 {
1053  static WifiMode mode =
1054  WifiModeFactory::CreateWifiMode ("OfdmRate21_7MbpsBW20MHz",
1055  WIFI_MOD_CLASS_HT,
1056  false,
1057  20000000, 21700000,
1058  WIFI_CODE_RATE_3_4,
1059  4);
1060  return mode;
1061 }
1062 
1063 
1064 WifiMode
1065 WifiPhy::GetOfdmRate26MbpsBW20MHz ()
1066 {
1067  static WifiMode mode =
1068  WifiModeFactory::CreateWifiMode ("OfdmRate26MbpsBW20MHz",
1069  WIFI_MOD_CLASS_HT,
1070  true,
1071  20000000, 26000000,
1072  WIFI_CODE_RATE_1_2,
1073  16);
1074  return mode;
1075 }
1076 
1077 WifiMode
1078 WifiPhy::GetOfdmRate28_9MbpsBW20MHz ()
1079 {
1080  static WifiMode mode =
1081  WifiModeFactory::CreateWifiMode ("OfdmRate28_9MbpsBW20MHz",
1082  WIFI_MOD_CLASS_HT,
1083  false,
1084  20000000, 28900000,
1085  WIFI_CODE_RATE_1_2,
1086  16);
1087  return mode;
1088 }
1089 
1090 WifiMode
1091 WifiPhy::GetOfdmRate39MbpsBW20MHz ()
1092 {
1093  static WifiMode mode =
1094  WifiModeFactory::CreateWifiMode ("OfdmRate39MbpsBW20MHz",
1095  WIFI_MOD_CLASS_HT,
1096  true,
1097  20000000, 39000000,
1098  WIFI_CODE_RATE_3_4,
1099  16);
1100  return mode;
1101 }
1102 
1103 WifiMode
1104 WifiPhy::GetOfdmRate43_3MbpsBW20MHz ()
1105 {
1106  static WifiMode mode =
1107  WifiModeFactory::CreateWifiMode ("OfdmRate43_3MbpsBW20MHz",
1108  WIFI_MOD_CLASS_HT,
1109  false,
1110  20000000, 43300000,
1111  WIFI_CODE_RATE_3_4,
1112  16);
1113  return mode;
1114 }
1115 
1116 WifiMode
1117 WifiPhy::GetOfdmRate52MbpsBW20MHz ()
1118 {
1119  static WifiMode mode =
1120  WifiModeFactory::CreateWifiMode ("OfdmRate52MbpsBW20MHz",
1121  WIFI_MOD_CLASS_HT,
1122  true,
1123  20000000, 52000000,
1124  WIFI_CODE_RATE_2_3,
1125  64);
1126  return mode;
1127 }
1128 
1129 WifiMode
1130 WifiPhy::GetOfdmRate57_8MbpsBW20MHz ()
1131 {
1132  static WifiMode mode =
1133  WifiModeFactory::CreateWifiMode ("OfdmRate57_8MbpsBW20MHz",
1134  WIFI_MOD_CLASS_HT,
1135  false,
1136  20000000, 57800000,
1137  WIFI_CODE_RATE_2_3,
1138  64);
1139  return mode;
1140 }
1141 
1142 
1143 WifiMode
1144 WifiPhy::GetOfdmRate58_5MbpsBW20MHz ()
1145 {
1146  static WifiMode mode =
1147  WifiModeFactory::CreateWifiMode ("OfdmRate58_5MbpsBW20MHz",
1148  WIFI_MOD_CLASS_HT,
1149  true,
1150  20000000, 58500000,
1151  WIFI_CODE_RATE_3_4,
1152  64);
1153  return mode;
1154 }
1155 
1156 WifiMode
1157 WifiPhy::GetOfdmRate65MbpsBW20MHzShGi ()
1158 {
1159  static WifiMode mode =
1160  WifiModeFactory::CreateWifiMode ("OfdmRate65MbpsBW20MHzShGi",
1161  WIFI_MOD_CLASS_HT,
1162  false,
1163  20000000, 65000000,
1164  WIFI_CODE_RATE_3_4,
1165  64);
1166  return mode;
1167 }
1168 
1169 WifiMode
1170 WifiPhy::GetOfdmRate65MbpsBW20MHz ()
1171 {
1172  static WifiMode mode =
1173  WifiModeFactory::CreateWifiMode ("OfdmRate65MbpsBW20MHz",
1174  WIFI_MOD_CLASS_HT,
1175  true,
1176  20000000, 65000000,
1177  WIFI_CODE_RATE_5_6,
1178  64);
1179  return mode;
1180 }
1181 
1182 WifiMode
1183 WifiPhy::GetOfdmRate72_2MbpsBW20MHz ()
1184 {
1185  static WifiMode mode =
1186  WifiModeFactory::CreateWifiMode ("OfdmRate72_2MbpsBW20MHz",
1187  WIFI_MOD_CLASS_HT,
1188  false,
1189  20000000, 72200000,
1190  WIFI_CODE_RATE_5_6,
1191  64);
1192  return mode;
1193 }
1194 
1195 WifiMode
1196 WifiPhy::GetOfdmRate13_5MbpsBW40MHz ()
1197 {
1198  static WifiMode mode =
1199  WifiModeFactory::CreateWifiMode ("OfdmRate13_5MbpsBW40MHz",
1200  WIFI_MOD_CLASS_HT,
1201  false,
1202  40000000, 13500000,
1203  WIFI_CODE_RATE_1_2,
1204  2);
1205  return mode;
1206 }
1207 
1208 WifiMode
1209 WifiPhy::GetOfdmRate15MbpsBW40MHz ()
1210 {
1211  static WifiMode mode =
1212  WifiModeFactory::CreateWifiMode ("OfdmRate15MbpsBW40MHz",
1213  WIFI_MOD_CLASS_HT,
1214  false,
1215  40000000, 15000000,
1216  WIFI_CODE_RATE_1_2,
1217  2);
1218  return mode;
1219 }
1220 
1221 WifiMode
1222 WifiPhy::GetOfdmRate27MbpsBW40MHz ()
1223 {
1224  static WifiMode mode =
1225  WifiModeFactory::CreateWifiMode ("OfdmRate27MbpsBW40MHz",
1226  WIFI_MOD_CLASS_HT,
1227  false,
1228  40000000, 27000000,
1229  WIFI_CODE_RATE_1_2,
1230  4);
1231  return mode;
1232 }
1233 WifiMode
1234 WifiPhy::GetOfdmRate30MbpsBW40MHz ()
1235 {
1236  static WifiMode mode =
1237  WifiModeFactory::CreateWifiMode ("OfdmRate30MbpsBW40MHz",
1238  WIFI_MOD_CLASS_HT,
1239  false,
1240  40000000, 30000000,
1241  WIFI_CODE_RATE_1_2,
1242  4);
1243  return mode;
1244 }
1245 
1246 WifiMode
1247 WifiPhy::GetOfdmRate40_5MbpsBW40MHz ()
1248 {
1249  static WifiMode mode =
1250  WifiModeFactory::CreateWifiMode ("OfdmRate40_5MbpsBW40MHz",
1251  WIFI_MOD_CLASS_HT,
1252  false,
1253  40000000, 40500000,
1254  WIFI_CODE_RATE_3_4,
1255  4);
1256  return mode;
1257 }
1258 WifiMode
1259 WifiPhy::GetOfdmRate45MbpsBW40MHz ()
1260 {
1261  static WifiMode mode =
1262  WifiModeFactory::CreateWifiMode ("OfdmRate45MbpsBW40MHz",
1263  WIFI_MOD_CLASS_HT,
1264  false,
1265  40000000, 45000000,
1266  WIFI_CODE_RATE_3_4,
1267  4);
1268  return mode;
1269 }
1270 
1271 WifiMode
1272 WifiPhy::GetOfdmRate54MbpsBW40MHz ()
1273 {
1274  static WifiMode mode =
1275  WifiModeFactory::CreateWifiMode ("OfdmRate54MbpsBW40MHz",
1276  WIFI_MOD_CLASS_HT,
1277  false,
1278  40000000, 54000000,
1279  WIFI_CODE_RATE_1_2,
1280  16);
1281  return mode;
1282 }
1283 
1284 WifiMode
1285 WifiPhy::GetOfdmRate60MbpsBW40MHz ()
1286 {
1287  static WifiMode mode =
1288  WifiModeFactory::CreateWifiMode ("OfdmRate60MbpsBW40MHz",
1289  WIFI_MOD_CLASS_HT,
1290  false,
1291  40000000, 60000000,
1292  WIFI_CODE_RATE_1_2,
1293  16);
1294  return mode;
1295 }
1296 
1297 WifiMode
1298 WifiPhy::GetOfdmRate81MbpsBW40MHz ()
1299 {
1300  static WifiMode mode =
1301  WifiModeFactory::CreateWifiMode ("OfdmRate81MbpsBW40MHz",
1302  WIFI_MOD_CLASS_HT,
1303  false,
1304  40000000, 81000000,
1305  WIFI_CODE_RATE_3_4,
1306  16);
1307  return mode;
1308 }
1309 WifiMode
1310 WifiPhy::GetOfdmRate90MbpsBW40MHz ()
1311 {
1312  static WifiMode mode =
1313  WifiModeFactory::CreateWifiMode ("OfdmRate90MbpsBW40MHz",
1314  WIFI_MOD_CLASS_HT,
1315  false,
1316  40000000, 90000000,
1317  WIFI_CODE_RATE_3_4,
1318  16);
1319  return mode;
1320 }
1321 
1322 WifiMode
1323 WifiPhy::GetOfdmRate108MbpsBW40MHz ()
1324 {
1325  static WifiMode mode =
1326  WifiModeFactory::CreateWifiMode ("OfdmRate108MbpsBW40MHz",
1327  WIFI_MOD_CLASS_HT,
1328  false,
1329  40000000, 108000000,
1330  WIFI_CODE_RATE_2_3,
1331  64);
1332  return mode;
1333 }
1334 WifiMode
1335 WifiPhy::GetOfdmRate120MbpsBW40MHz ()
1336 {
1337  static WifiMode mode =
1338  WifiModeFactory::CreateWifiMode ("OfdmRate120MbpsBW40MHz",
1339  WIFI_MOD_CLASS_HT,
1340  false,
1341  40000000, 120000000,
1342  WIFI_CODE_RATE_2_3,
1343  64);
1344  return mode;
1345 }
1346 WifiMode
1347 WifiPhy::GetOfdmRate121_5MbpsBW40MHz ()
1348 {
1349  static WifiMode mode =
1350  WifiModeFactory::CreateWifiMode ("OfdmRate121_5MbpsBW40MHz",
1351  WIFI_MOD_CLASS_HT,
1352  false,
1353  40000000, 121500000,
1354  WIFI_CODE_RATE_3_4,
1355  64);
1356  return mode;
1357 }
1358 WifiMode
1359 WifiPhy::GetOfdmRate135MbpsBW40MHzShGi ()
1360 {
1361  static WifiMode mode =
1362  WifiModeFactory::CreateWifiMode ("OfdmRate135MbpsBW40MHzShGi",
1363  WIFI_MOD_CLASS_HT,
1364  false,
1365  40000000, 135000000,
1366  WIFI_CODE_RATE_3_4,
1367  64);
1368  return mode;
1369 }
1370 WifiMode
1371 WifiPhy::GetOfdmRate135MbpsBW40MHz ()
1372 {
1373  static WifiMode mode =
1374  WifiModeFactory::CreateWifiMode ("OfdmRate135MbpsBW40MHz",
1375  WIFI_MOD_CLASS_HT,
1376  false,
1377  40000000, 135000000,
1378  WIFI_CODE_RATE_5_6,
1379  64);
1380  return mode;
1381 }
1382 
1383 WifiMode
1384 WifiPhy::GetOfdmRate150MbpsBW40MHz ()
1385 {
1386  static WifiMode mode =
1387  WifiModeFactory::CreateWifiMode ("OfdmRate150MbpsBW40MHz",
1388  WIFI_MOD_CLASS_HT,
1389  false,
1390  40000000, 150000000,
1391  WIFI_CODE_RATE_5_6,
1392  64);
1393  return mode;
1394 }
1395 
1396 
1397 
1398 std::ostream& operator<< (std::ostream& os, enum WifiPhy::State state)
1399 {
1400  switch (state)
1401  {
1402  case WifiPhy::IDLE:
1403  return (os << "IDLE");
1404  case WifiPhy::CCA_BUSY:
1405  return (os << "CCA_BUSY");
1406  case WifiPhy::TX:
1407  return (os << "TX");
1408  case WifiPhy::RX:
1409  return (os << "RX");
1410  case WifiPhy::SWITCHING:
1411  return (os << "SWITCHING");
1412  default:
1413  NS_FATAL_ERROR ("Invalid WifiPhy state");
1414  return (os << "INVALID");
1415  }
1416 }
1417 
1418 
1419 
1420 } // namespace ns3
1421 
1422 namespace {
1423 
1424 static class Constructor
1425 {
1426 public:
1427  Constructor ()
1428  {
1429  ns3::WifiPhy::GetDsssRate1Mbps ();
1430  ns3::WifiPhy::GetDsssRate2Mbps ();
1431  ns3::WifiPhy::GetDsssRate5_5Mbps ();
1432  ns3::WifiPhy::GetDsssRate11Mbps ();
1433  ns3::WifiPhy::GetErpOfdmRate6Mbps ();
1434  ns3::WifiPhy::GetErpOfdmRate9Mbps ();
1435  ns3::WifiPhy::GetErpOfdmRate12Mbps ();
1436  ns3::WifiPhy::GetErpOfdmRate18Mbps ();
1437  ns3::WifiPhy::GetErpOfdmRate24Mbps ();
1438  ns3::WifiPhy::GetErpOfdmRate36Mbps ();
1439  ns3::WifiPhy::GetErpOfdmRate48Mbps ();
1440  ns3::WifiPhy::GetErpOfdmRate54Mbps ();
1441  ns3::WifiPhy::GetOfdmRate6Mbps ();
1442  ns3::WifiPhy::GetOfdmRate9Mbps ();
1443  ns3::WifiPhy::GetOfdmRate12Mbps ();
1444  ns3::WifiPhy::GetOfdmRate18Mbps ();
1445  ns3::WifiPhy::GetOfdmRate24Mbps ();
1446  ns3::WifiPhy::GetOfdmRate36Mbps ();
1447  ns3::WifiPhy::GetOfdmRate48Mbps ();
1448  ns3::WifiPhy::GetOfdmRate54Mbps ();
1449  ns3::WifiPhy::GetOfdmRate3MbpsBW10MHz ();
1450  ns3::WifiPhy::GetOfdmRate4_5MbpsBW10MHz ();
1451  ns3::WifiPhy::GetOfdmRate6MbpsBW10MHz ();
1452  ns3::WifiPhy::GetOfdmRate9MbpsBW10MHz ();
1453  ns3::WifiPhy::GetOfdmRate12MbpsBW10MHz ();
1454  ns3::WifiPhy::GetOfdmRate18MbpsBW10MHz ();
1455  ns3::WifiPhy::GetOfdmRate24MbpsBW10MHz ();
1456  ns3::WifiPhy::GetOfdmRate27MbpsBW10MHz ();
1457  ns3::WifiPhy::GetOfdmRate1_5MbpsBW5MHz ();
1458  ns3::WifiPhy::GetOfdmRate2_25MbpsBW5MHz ();
1459  ns3::WifiPhy::GetOfdmRate3MbpsBW5MHz ();
1460  ns3::WifiPhy::GetOfdmRate4_5MbpsBW5MHz ();
1461  ns3::WifiPhy::GetOfdmRate6MbpsBW5MHz ();
1462  ns3::WifiPhy::GetOfdmRate9MbpsBW5MHz ();
1463  ns3::WifiPhy::GetOfdmRate12MbpsBW5MHz ();
1464  ns3::WifiPhy::GetOfdmRate13_5MbpsBW5MHz ();
1465  ns3::WifiPhy::GetOfdmRate6_5MbpsBW20MHz ();
1466  ns3::WifiPhy::GetOfdmRate13MbpsBW20MHz ();
1467  ns3::WifiPhy::GetOfdmRate19_5MbpsBW20MHz ();
1468  ns3::WifiPhy::GetOfdmRate26MbpsBW20MHz ();
1469  ns3::WifiPhy::GetOfdmRate39MbpsBW20MHz ();
1470  ns3::WifiPhy::GetOfdmRate52MbpsBW20MHz ();
1471  ns3::WifiPhy::GetOfdmRate58_5MbpsBW20MHz ();
1472  ns3::WifiPhy::GetOfdmRate65MbpsBW20MHz ();
1473  ns3::WifiPhy::GetOfdmRate13_5MbpsBW40MHz ();
1474  ns3::WifiPhy::GetOfdmRate27MbpsBW40MHz ();
1475  ns3::WifiPhy::GetOfdmRate40_5MbpsBW40MHz ();
1476  ns3::WifiPhy::GetOfdmRate54MbpsBW40MHz ();
1477  ns3::WifiPhy::GetOfdmRate81MbpsBW40MHz ();
1478  ns3::WifiPhy::GetOfdmRate108MbpsBW40MHz ();
1479  ns3::WifiPhy::GetOfdmRate121_5MbpsBW40MHz ();
1480  ns3::WifiPhy::GetOfdmRate135MbpsBW40MHz ();
1481  ns3::WifiPhy::GetOfdmRate7_2MbpsBW20MHz ();
1482  ns3::WifiPhy::GetOfdmRate14_4MbpsBW20MHz ();
1483  ns3::WifiPhy::GetOfdmRate21_7MbpsBW20MHz ();
1484  ns3::WifiPhy::GetOfdmRate28_9MbpsBW20MHz ();
1485  ns3::WifiPhy::GetOfdmRate43_3MbpsBW20MHz ();
1486  ns3::WifiPhy::GetOfdmRate57_8MbpsBW20MHz ();
1487  ns3::WifiPhy::GetOfdmRate65MbpsBW20MHzShGi ();
1488  ns3::WifiPhy::GetOfdmRate72_2MbpsBW20MHz ();
1489 
1490  }
1491 } g_constructor;
1492 }
anonymous_namespace{wifi-phy.cc}::g_constructor
static class anonymous_namespace{wifi-phy.cc}::Constructor g_constructor
ns3::WifiPhy::GetOfdmRate9MbpsBW5MHz
static WifiMode GetOfdmRate9MbpsBW5MHz()
Return a WifiMode for ODFM at 9Mbps with 5MHz channel spacing.
Definition: wifi-phy.cc:947
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:1087
ns3::WifiPhy::GetErpOfdmRate24Mbps
static WifiMode GetErpOfdmRate24Mbps()
Return a WifiMode for ERP-ODFM at 24Mbps.
Definition: wifi-phy.cc:615
ns3::WifiPhy::GetDsssRate11Mbps
static WifiMode GetDsssRate11Mbps()
Return a WifiMode for DSSS at 11Mbps.
Definition: wifi-phy.cc:547
ns3::WifiPhy::GetPlcpHeaderDurationMicroSeconds
static uint32_t GetPlcpHeaderDurationMicroSeconds(WifiMode payloadMode, WifiPreamble preamble)
Definition: wifi-phy.cc:222
ns3::Time
keep track of time values and allow control of global simulation resolution
Definition: nstime.h:81
ns3::WifiPhy::GetErpOfdmRate36Mbps
static WifiMode GetErpOfdmRate36Mbps()
Return a WifiMode for ERP-ODFM at 36Mbps.
Definition: wifi-phy.cc:628
NS_LOG_FUNCTION
#define NS_LOG_FUNCTION(parameters)
Definition: log.h:345
ns3::WifiPhy::GetOfdmRate26MbpsBW20MHz
static WifiMode GetOfdmRate26MbpsBW20MHz()
Return a WifiMode for ODFM at 26Mbps with 20MHz channel spacing.
Definition: wifi-phy.cc:1065
ns3::WIFI_MOD_CLASS_ERP_OFDM
ERP-OFDM PHY (19.5)
Definition: wifi-mode.h:52
ns3::WifiPhy::GetOfdmRate9Mbps
static WifiMode GetOfdmRate9Mbps()
Return a WifiMode for ODFM at 9Mbps.
Definition: wifi-phy.cc:683
ns3::WifiPhy::GetOfdmRate7_2MbpsBW20MHz
static WifiMode GetOfdmRate7_2MbpsBW20MHz()
Return a WifiMode for ODFM at 7.2Mbps with 20MHz channel spacing.
Definition: wifi-phy.cc:1000
ns3::WifiPhy::GetOfdmRate18MbpsBW10MHz
static WifiMode GetOfdmRate18MbpsBW10MHz()
Return a WifiMode for ODFM at 18Mbps with 10MHz channel spacing.
Definition: wifi-phy.cc:841
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:47
ns3::WifiPhy::GetOfdmRate27MbpsBW10MHz
static WifiMode GetOfdmRate27MbpsBW10MHz()
Return a WifiMode for ODFM at 27Mbps with 10MHz channel spacing.
Definition: wifi-phy.cc:867
ns3::WifiPhy::GetOfdmRate3MbpsBW5MHz
static WifiMode GetOfdmRate3MbpsBW5MHz()
Return a WifiMode for ODFM at 3Mbps with 5MHz channel spacing.
Definition: wifi-phy.cc:908
ns3::WifiPhy::~WifiPhy
virtual ~WifiPhy()
Definition: wifi-phy.cc:92
ns3::WifiPhy::GetDsssRate1Mbps
static WifiMode GetDsssRate1Mbps()
Return a WifiMode for DSSS at 1Mbps.
Definition: wifi-phy.cc:505
ns3::WifiPhy::NotifyMonitorSniffTx
void NotifyMonitorSniffTx(Ptr< const Packet > packet, uint16_t channelFreqMhz, uint16_t channelNumber, uint32_t rate, bool isShortPreamble, uint8_t txPower)
Public method used to fire a MonitorSniffer trace for a wifi packet being transmitted.
Definition: wifi-phy.cc:496
ns3::WifiPhy::GetOfdmRate81MbpsBW40MHz
static WifiMode GetOfdmRate81MbpsBW40MHz()
Return a WifiMode for ODFM at 81Mbps with 40MHz channel spacing.
Definition: wifi-phy.cc:1298
ns3::WifiPhy
802.11 PHY layer model
Definition: wifi-phy.h:117
ns3::WifiPhy::GetErpOfdmRate18Mbps
static WifiMode GetErpOfdmRate18Mbps()
Return a WifiMode for ERP-ODFM at 18Mbps.
Definition: wifi-phy.cc:602
ns3::WifiPhy::State
State
The state of the PHY layer.
Definition: wifi-phy.h:123
NS_LOG_COMPONENT_DEFINE
NS_LOG_COMPONENT_DEFINE("WifiPhy")
anonymous_namespace{wifi-phy.cc}::Constructor::Constructor
Constructor()
Definition: wifi-phy.cc:1427
ns3::WifiPhy::GetOfdmRate12Mbps
static WifiMode GetOfdmRate12Mbps()
Return a WifiMode for ODFM at 12Mbps.
Definition: wifi-phy.cc:696
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:1095
ns3::WifiMode::GetModulationClass
enum WifiModulationClass GetModulationClass() const
Definition: wifi-mode.cc:115
ns3::WifiPhy::GetOfdmRate43_3MbpsBW20MHz
static WifiMode GetOfdmRate43_3MbpsBW20MHz()
Return a WifiMode for ODFM at 43.3Mbps with 20MHz channel spacing.
Definition: wifi-phy.cc:1104
ns3::NS_OBJECT_ENSURE_REGISTERED
NS_OBJECT_ENSURE_REGISTERED(NullMessageSimulatorImpl)
ns3::WifiPhy::GetOfdmRate60MbpsBW40MHz
static WifiMode GetOfdmRate60MbpsBW40MHz()
Return a WifiMode for ODFM at 60Mbps with 40MHz channel spacing.
Definition: wifi-phy.cc:1285
ns3::WifiPhy::GetOfdmRate1_5MbpsBW5MHz
static WifiMode GetOfdmRate1_5MbpsBW5MHz()
Return a WifiMode for ODFM at 1.5Mbps with 5MHz channel spacing.
Definition: wifi-phy.cc:882
ns3::WifiPhy::GetOfdmRate4_5MbpsBW10MHz
static WifiMode GetOfdmRate4_5MbpsBW10MHz()
Return a WifiMode for ODFM at 4.5Mbps with 10MHz channel spacing.
Definition: wifi-phy.cc:789
ns3::WifiPhy::GetMFPlcpHeaderMode
static WifiMode GetMFPlcpHeaderMode(WifiMode payloadMode, WifiPreamble preamble)
Definition: wifi-phy.cc:101
ns3::WifiPhy::GetOfdmRate54Mbps
static WifiMode GetOfdmRate54Mbps()
Return a WifiMode for ODFM at 54Mbps.
Definition: wifi-phy.cc:761
ns3::WifiPhy::NotifyTxDrop
void NotifyTxDrop(Ptr< const Packet > packet)
Public method used to fire a PhyTxDrop trace.
Definition: wifi-phy.cc:466
ns3::WifiPhy::GetOfdmRate108MbpsBW40MHz
static WifiMode GetOfdmRate108MbpsBW40MHz()
Return a WifiMode for ODFM at 108Mbps with 40MHz channel spacing.
Definition: wifi-phy.cc:1323
ns3::WifiPhy::GetOfdmRate21_7MbpsBW20MHz
static WifiMode GetOfdmRate21_7MbpsBW20MHz()
Return a WifiMode for ODFM at 21.7Mbps with 20MHz channel spacing.
Definition: wifi-phy.cc:1051
ns3::WifiPhy::NotifyTxBegin
void NotifyTxBegin(Ptr< const Packet > packet)
Public method used to fire a PhyTxBegin trace.
Definition: wifi-phy.cc:454
ns3::WifiMode
represent a single transmission modeA WifiMode is implemented by a single integer which is used to lo...
Definition: wifi-mode.h:91
ns3::WifiPhy::GetOfdmRate135MbpsBW40MHz
static WifiMode GetOfdmRate135MbpsBW40MHz()
Return a WifiMode for ODFM at 135Mbps with 40MHz channel spacing.
Definition: wifi-phy.cc:1371
ns3::WifiPhy::GetOfdmRate36Mbps
static WifiMode GetOfdmRate36Mbps()
Return a WifiMode for ODFM at 36Mbps.
Definition: wifi-phy.cc:735
ns3::WifiPhy::GetOfdmRate6MbpsBW5MHz
static WifiMode GetOfdmRate6MbpsBW5MHz()
Return a WifiMode for ODFM at 6Mbps with 5MHz channel spacing.
Definition: wifi-phy.cc:934
NS_FATAL_ERROR
#define NS_FATAL_ERROR(msg)
fatal error handling
Definition: fatal-error.h:72
ns3::WifiPhy::SWITCHING
The PHY layer is switching to other channel.
Definition: wifi-phy.h:144
ns3::WifiPhy::GetErpOfdmRate54Mbps
static WifiMode GetErpOfdmRate54Mbps()
Return a WifiMode for ERP-ODFM at 54Mbps.
Definition: wifi-phy.cc:654
ns3::WifiPhy::NotifyRxDrop
void NotifyRxDrop(Ptr< const Packet > packet)
Public method used to fire a PhyRxDrop trace.
Definition: wifi-phy.cc:484
ns3::WifiPreamble
WifiPreamble
The type of preamble to be used by an IEEE 802.11 transmission.
Definition: wifi-preamble.h:29
ns3::WifiPhy::GetOfdmRate6_5MbpsBW20MHz
static WifiMode GetOfdmRate6_5MbpsBW20MHz()
Return a WifiMode for ODFM at 6.5Mbps with 20MHz channel spacing.
Definition: wifi-phy.cc:988
ns3::WifiPhy::GetPayloadDurationMicroSeconds
static double GetPayloadDurationMicroSeconds(uint32_t size, WifiTxVector txvector)
Definition: wifi-phy.cc:333
ns3::WifiPhy::GetOfdmRate135MbpsBW40MHzShGi
static WifiMode GetOfdmRate135MbpsBW40MHzShGi()
Return a WifiMode for ODFM at 135Mbps with 40MHz channel spacing.
Definition: wifi-phy.cc:1359
ns3::WifiPhy::m_phyMonitorSniffTxTrace
TracedCallback< Ptr< const Packet >, uint16_t, uint16_t, uint32_t, bool, uint8_t > m_phyMonitorSniffTxTrace
A trace source that emulates a wifi device in monitor mode sniffing a packet being transmitted...
Definition: wifi-phy.h:1126
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:1079
ns3::WifiPhy::GetErpOfdmRate48Mbps
static WifiMode GetErpOfdmRate48Mbps()
Return a WifiMode for ERP-ODFM at 48Mbps.
Definition: wifi-phy.cc:641
ns3::WifiPhy::GetPlcpHeaderMode
static WifiMode GetPlcpHeaderMode(WifiMode payloadMode, WifiPreamble preamble)
Definition: wifi-phy.cc:149
ns3::WifiTxVector::GetNess
uint8_t GetNess(void) const
Definition: wifi-tx-vector.cc:67
ns3::WifiPhy::GetOfdmRate12MbpsBW10MHz
static WifiMode GetOfdmRate12MbpsBW10MHz()
Return a WifiMode for ODFM at 12Mbps with 10MHz channel spacing.
Definition: wifi-phy.cc:828
ns3::WIFI_MOD_CLASS_HT
HT PHY (Clause 20)
Definition: wifi-mode.h:56
ns3::WifiMode::GetUniqueName
std::string GetUniqueName(void) const
Definition: wifi-mode.cc:97
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:1102
ns3::WifiPhyListener::~WifiPhyListener
virtual ~WifiPhyListener()
Definition: wifi-phy.cc:43
ns3::WifiModeFactory::CreateWifiMode
static WifiMode CreateWifiMode(std::string uniqueName, enum WifiModulationClass modClass, bool isMandatory, uint32_t bandwidth, uint32_t dataRate, enum WifiCodeRate codingRate, uint8_t constellationSize)
Definition: wifi-mode.cc:141
ns3::WifiPhy::NotifyRxBegin
void NotifyRxBegin(Ptr< const Packet > packet)
Public method used to fire a PhyRxBegin trace.
Definition: wifi-phy.cc:472
ns3::WifiPhy::GetOfdmRate19_5MbpsBW20MHz
static WifiMode GetOfdmRate19_5MbpsBW20MHz()
Return a WifiMode for ODFM at 19.5Mbps with 20MHz channel spacing.
Definition: wifi-phy.cc:1038
ns3::WifiPhy::GetOfdmRate18Mbps
static WifiMode GetOfdmRate18Mbps()
Return a WifiMode for ODFM at 18Mbps.
Definition: wifi-phy.cc:709
ns3::WifiPhy::GetOfdmRate9MbpsBW10MHz
static WifiMode GetOfdmRate9MbpsBW10MHz()
Return a WifiMode for ODFM at 9Mbps with 10MHz channel spacing.
Definition: wifi-phy.cc:815
ns3::WifiPhy::m_phyMonitorSniffRxTrace
TracedCallback< Ptr< const Packet >, uint16_t, uint16_t, uint32_t, bool, double, double > m_phyMonitorSniffRxTrace
A trace source that emulates a wifi device in monitor mode sniffing a packet being received...
Definition: wifi-phy.h:1114
ns3::WifiTxVector::IsStbc
bool IsStbc(void) const
Check if STBC is used or not.
Definition: wifi-tx-vector.cc:72
ns3::WifiPhy::GetOfdmRate12MbpsBW5MHz
static WifiMode GetOfdmRate12MbpsBW5MHz()
Return a WifiMode for ODFM at 12Mbps with 5MHz channel spacing.
Definition: wifi-phy.cc:960
ns3::WifiPhy::GetOfdmRate52MbpsBW20MHz
static WifiMode GetOfdmRate52MbpsBW20MHz()
Return a WifiMode for ODFM at 52Mbps with 20MHz channel spacing.
Definition: wifi-phy.cc:1117
NS_LOG_LOGIC
#define NS_LOG_LOGIC(msg)
Definition: log.h:368
ns3::WifiPhy::GetOfdmRate40_5MbpsBW40MHz
static WifiMode GetOfdmRate40_5MbpsBW40MHz()
Return a WifiMode for ODFM at 40.5Mbps with 40MHz channel spacing.
Definition: wifi-phy.cc:1247
ns3::WifiMode::GetBandwidth
uint32_t GetBandwidth(void) const
Definition: wifi-mode.cc:67
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:1063
ns3::WifiPhy::GetOfdmRate72_2MbpsBW20MHz
static WifiMode GetOfdmRate72_2MbpsBW20MHz()
Return a WifiMode for ODFM at 72.2Mbps with 20MHz channel spacing.
Definition: wifi-phy.cc:1183
ns3::WifiPhy::GetOfdmRate65MbpsBW20MHzShGi
static WifiMode GetOfdmRate65MbpsBW20MHzShGi()
Return a WifiMode for ODFM at 65Mbps with 20MHz channel spacing.
Definition: wifi-phy.cc:1157
ns3::WifiPhy::GetOfdmRate48Mbps
static WifiMode GetOfdmRate48Mbps()
Return a WifiMode for ODFM at 48Mbps.
Definition: wifi-phy.cc:748
ns3::operator<<
std::ostream & operator<<(std::ostream &os, const Angles &a)
print a struct Angles to output
Definition: angles.cc:43
ns3::WifiPhy::NotifyMonitorSniffRx
void NotifyMonitorSniffRx(Ptr< const Packet > packet, uint16_t channelFreqMhz, uint16_t channelNumber, uint32_t rate, bool isShortPreamble, double signalDbm, double noiseDbm)
Public method used to fire a MonitorSniffer trace for a wifi packet being received.
Definition: wifi-phy.cc:490
ns3::WifiPhy::IDLE
The PHY layer is IDLE.
Definition: wifi-phy.h:128
ns3::WifiPhy::GetTypeId
static TypeId GetTypeId(void)
Definition: wifi-phy.cc:55
ns3::WifiPhy::GetOfdmRate57_8MbpsBW20MHz
static WifiMode GetOfdmRate57_8MbpsBW20MHz()
Return a WifiMode for ODFM at 57.8Mbps with 20MHz channel spacing.
Definition: wifi-phy.cc:1130
ns3::WifiPhy::GetOfdmRate24Mbps
static WifiMode GetOfdmRate24Mbps()
Return a WifiMode for ODFM at 24Mbps.
Definition: wifi-phy.cc:722
ns3::MakeTraceSourceAccessor
Ptr< const TraceSourceAccessor > MakeTraceSourceAccessor(T a)
Definition: trace-source-accessor.h:135
ns3::WifiPhy::GetOfdmRate13MbpsBW20MHz
static WifiMode GetOfdmRate13MbpsBW20MHz()
Return a WifiMode for ODFM at 13Mbps with 20MHz channel spacing.
Definition: wifi-phy.cc:1013
ns3::WifiPhy::GetOfdmRate65MbpsBW20MHz
static WifiMode GetOfdmRate65MbpsBW20MHz()
Return a WifiMode for ODFM at 65Mbps with 20MHz channel spacing.
Definition: wifi-phy.cc:1170
ns3::WIFI_PREAMBLE_LONG
Definition: wifi-preamble.h:31
ns3::WifiPhy::GetPlcpHtTrainingSymbolDurationMicroSeconds
static uint32_t GetPlcpHtTrainingSymbolDurationMicroSeconds(WifiMode payloadMode, WifiPreamble preamble, WifiTxVector txvector)
Definition: wifi-phy.cc:114
ns3::WIFI_PREAMBLE_HT_GF
Definition: wifi-preamble.h:34
ns3::WifiPhy::GetOfdmRate58_5MbpsBW20MHz
static WifiMode GetOfdmRate58_5MbpsBW20MHz()
Return a WifiMode for ODFM at 58.5Mbps with 20MHz channel spacing.
Definition: wifi-phy.cc:1144
ns3::WifiPhy::GetDsssRate5_5Mbps
static WifiMode GetDsssRate5_5Mbps()
Return a WifiMode for DSSS at 5.5Mbps.
Definition: wifi-phy.cc:534
ns3::WifiPhy::GetOfdmRate2_25MbpsBW5MHz
static WifiMode GetOfdmRate2_25MbpsBW5MHz()
Return a WifiMode for ODFM at 2.25Mbps with 5MHz channel spacing.
Definition: wifi-phy.cc:895
anonymous_namespace{wifi-phy.cc}::Constructor
Definition: wifi-phy.cc:1424
ns3::WifiPhy::GetErpOfdmRate9Mbps
static WifiMode GetErpOfdmRate9Mbps()
Return a WifiMode for ERP-ODFM at 9Mbps.
Definition: wifi-phy.cc:576
ns3::WifiPhy::NotifyTxEnd
void NotifyTxEnd(Ptr< const Packet > packet)
Public method used to fire a PhyTxEnd trace.
Definition: wifi-phy.cc:460
ns3::WifiPhy::GetOfdmRate15MbpsBW40MHz
static WifiMode GetOfdmRate15MbpsBW40MHz()
Return a WifiMode for ODFM at 15Mbps with 40MHz channel spacing.
Definition: wifi-phy.cc:1209
ns3::WifiPhy::GetOfdmRate121_5MbpsBW40MHz
static WifiMode GetOfdmRate121_5MbpsBW40MHz()
Return a WifiMode for ODFM at 121.5Mbps with 40MHz channel spacing.
Definition: wifi-phy.cc:1347
ns3::WifiPhy::GetOfdmRate28_9MbpsBW20MHz
static WifiMode GetOfdmRate28_9MbpsBW20MHz()
Return a WifiMode for ODFM at 28.9Mbps with 20MHz channel spacing.
Definition: wifi-phy.cc:1078
ns3::WIFI_CODE_RATE_UNDEFINED
No explicit coding (e.g., DSSS rates)
Definition: wifi-mode.h:70
ns3::WifiPhy::GetErpOfdmRate6Mbps
static WifiMode GetErpOfdmRate6Mbps()
Return a WifiMode for ERP-ODFM at 6Mbps.
Definition: wifi-phy.cc:563
ns3::WifiPhy::CalculateTxDuration
static Time CalculateTxDuration(uint32_t size, WifiTxVector txvector, enum WifiPreamble preamble)
Definition: wifi-phy.cc:440
ns3::WifiTxVector::GetNss
uint8_t GetNss(void) const
Definition: wifi-tx-vector.cc:62
ns3::WifiPhy::GetErpOfdmRate12Mbps
static WifiMode GetErpOfdmRate12Mbps()
Return a WifiMode for ERP-ODFM at 12Mbps.
Definition: wifi-phy.cc:589
ns3::WifiPhy::NotifyRxEnd
void NotifyRxEnd(Ptr< const Packet > packet)
Public method used to fire a PhyRxEnd trace.
Definition: wifi-phy.cc:478
ns3::WifiPhy::GetOfdmRate13_5MbpsBW40MHz
static WifiMode GetOfdmRate13_5MbpsBW40MHz()
Return a WifiMode for ODFM at 13.5Mbps with 40MHz channel spacing.
Definition: wifi-phy.cc:1196
ns3::WifiPhy::GetOfdmRate30MbpsBW40MHz
static WifiMode GetOfdmRate30MbpsBW40MHz()
Return a WifiMode for ODFM at 30Mbps with 40MHz channel spacing.
Definition: wifi-phy.cc:1234
ns3::WifiPhy::GetOfdmRate54MbpsBW40MHz
static WifiMode GetOfdmRate54MbpsBW40MHz()
Return a WifiMode for ODFM at 54Mbps with 40MHz channel spacing.
Definition: wifi-phy.cc:1272
ns3::WIFI_MOD_CLASS_OFDM
OFDM PHY (Clause 17)
Definition: wifi-mode.h:54
ns3::WifiPhy::GetOfdmRate90MbpsBW40MHz
static WifiMode GetOfdmRate90MbpsBW40MHz()
Return a WifiMode for ODFM at 90Mbps with 40MHz channel spacing.
Definition: wifi-phy.cc:1310
ns3::WifiPhy::GetOfdmRate45MbpsBW40MHz
static WifiMode GetOfdmRate45MbpsBW40MHz()
Return a WifiMode for ODFM at 45Mbps with 40MHz channel spacing.
Definition: wifi-phy.cc:1259
ns3::WifiPhy::GetOfdmRate120MbpsBW40MHz
static WifiMode GetOfdmRate120MbpsBW40MHz()
Return a WifiMode for ODFM at 120Mbps with 40MHz channel spacing.
Definition: wifi-phy.cc:1335
ns3::WifiPhy::GetOfdmRate39MbpsBW20MHz
static WifiMode GetOfdmRate39MbpsBW20MHz()
Return a WifiMode for ODFM at 39Mbps with 20MHz channel spacing.
Definition: wifi-phy.cc:1091
ns3::Object
a base class which provides memory management and object aggregation
Definition: object.h:63
ns3::WifiPhy::GetDsssRate2Mbps
static WifiMode GetDsssRate2Mbps()
Return a WifiMode for DSSS at 2Mbps.
Definition: wifi-phy.cc:518
ns3::WifiPhy::GetOfdmRate6MbpsBW10MHz
static WifiMode GetOfdmRate6MbpsBW10MHz()
Return a WifiMode for ODFM at 6Mbps with 10MHz channel spacing.
Definition: wifi-phy.cc:802
ns3::WifiTxVector::GetMode
WifiMode GetMode(void) const
Definition: wifi-tx-vector.cc:42
ns3::WifiPhy::RX
The PHY layer is receiving a packet.
Definition: wifi-phy.h:140
ns3::WIFI_PREAMBLE_SHORT
Definition: wifi-preamble.h:32
ns3::WifiPhy::GetOfdmRate24MbpsBW10MHz
static WifiMode GetOfdmRate24MbpsBW10MHz()
Return a WifiMode for ODFM at 24Mbps with 10MHz channel spacing.
Definition: wifi-phy.cc:854
ns3::WifiPhy::CCA_BUSY
The PHY layer has sense the medium busy through the CCA mechanism.
Definition: wifi-phy.h:132
ns3::WifiPhy::GetOfdmRate13_5MbpsBW5MHz
static WifiMode GetOfdmRate13_5MbpsBW5MHz()
Return a WifiMode for ODFM at 13.5Mbps with 5MHz channel spacing.
Definition: wifi-phy.cc:973
ns3::TypeId
a unique identifier for an interface.
Definition: type-id.h:49
ns3::WifiPhy::GetPlcpPreambleDurationMicroSeconds
static uint32_t GetPlcpPreambleDurationMicroSeconds(WifiMode payloadMode, WifiPreamble preamble)
Definition: wifi-phy.cc:285
ns3::WifiPhy::TX
The PHY layer is sending a packet.
Definition: wifi-phy.h:136
ns3::WifiMode::GetDataRate
uint64_t GetDataRate(void) const
Definition: wifi-mode.cc:79
ns3::TypeId::SetParent
TypeId SetParent(TypeId tid)
Definition: type-id.cc:611
ns3::WifiPhy::GetOfdmRate6Mbps
static WifiMode GetOfdmRate6Mbps()
Return a WifiMode for ODFM at 6Mbps.
Definition: wifi-phy.cc:670
ns3::WifiPhy::GetOfdmRate27MbpsBW40MHz
static WifiMode GetOfdmRate27MbpsBW40MHz()
Return a WifiMode for ODFM at 27Mbps with 40MHz channel spacing.
Definition: wifi-phy.cc:1222
ns3::WIFI_MOD_CLASS_DSSS
DSSS PHY (Clause 15) and HR/DSSS PHY (Clause 18)
Definition: wifi-mode.h:46
ns3::WifiPhy::GetOfdmRate4_5MbpsBW5MHz
static WifiMode GetOfdmRate4_5MbpsBW5MHz()
Return a WifiMode for ODFM at 4.5Mbps with 5MHz channel spacing.
Definition: wifi-phy.cc:921
ns3::WifiPhy::GetOfdmRate14_4MbpsBW20MHz
static WifiMode GetOfdmRate14_4MbpsBW20MHz()
Return a WifiMode for ODFM at 14.4Mbps with 20MHz channel spacing.
Definition: wifi-phy.cc:1026
ns3::WifiPhy::GetPlcpHtSigHeaderDurationMicroSeconds
static uint32_t GetPlcpHtSigHeaderDurationMicroSeconds(WifiMode payloadMode, WifiPreamble preamble)
Definition: wifi-phy.cc:130
ns3::WifiPhy::GetOfdmRate3MbpsBW10MHz
static WifiMode GetOfdmRate3MbpsBW10MHz()
Return a WifiMode for ODFM at 3Mbps with 10MHz channel spacing.
Definition: wifi-phy.cc:776
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:1071
ns3::WIFI_PREAMBLE_HT_MF
Definition: wifi-preamble.h:33
ns3::WifiPhy::GetOfdmRate150MbpsBW40MHz
static WifiMode GetOfdmRate150MbpsBW40MHz()
Return a WifiMode for ODFM at 150Mbps with 40MHz channel spacing.
Definition: wifi-phy.cc:1384