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 
44 {
45 }
46 
47 /****************************************************************
48  * The actual WifiPhy class
49  ****************************************************************/
50 
52  ;
53 
54 TypeId
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",
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.",
65  .AddTraceSource ("PhyTxDrop",
66  "Trace source indicating a packet has been dropped by the device during transmission",
68  .AddTraceSource ("PhyRxBegin",
69  "Trace source indicating a packet has begun being received from the channel medium by the device",
71  .AddTraceSource ("PhyRxEnd",
72  "Trace source indicating a packet has been completely received from the channel medium by the device",
74  .AddTraceSource ("PhyRxDrop",
75  "Trace source indicating a packet has been dropped by the device during reception",
77  .AddTraceSource ("MonitorSnifferRx",
78  "Trace source simulating a wifi device in monitor mode sniffing all received frames",
80  .AddTraceSource ("MonitorSnifferTx",
81  "Trace source simulating the capability of a wifi device in monitor mode to sniff all frames being transmitted",
83  ;
84  return tid;
85 }
86 
88 {
89  NS_LOG_FUNCTION (this);
90 }
91 
93 {
94  NS_LOG_FUNCTION (this);
95 }
96 
97 //Added by Ghada to support 11n
98 
99 //return the L-SIG
100 WifiMode
102 {
103  switch (payloadMode.GetBandwidth ())
104  {
105  case 20000000:
107  case 40000000:
109  default:
111  }
112 }
113 uint32_t
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
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
150 {
151  switch (payloadMode.GetModulationClass ())
152  {
153  case WIFI_MOD_CLASS_OFDM:
154  {
155  switch (payloadMode.GetBandwidth ())
156  {
157  case 5000000:
159  case 10000000:
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:
180  case 40000000:
182  default:
184  }
185  case WIFI_PREAMBLE_HT_GF:
186  switch (payloadMode.GetBandwidth ())
187  {
188  case 20000000:
190  case 40000000:
192  default:
194  }
195  default:
196  return WifiPhy::GetOfdmRate6Mbps ();
197  }
198  }
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
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  }
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
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  }
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
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:
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
455 {
456  m_phyTxBeginTrace (packet);
457 }
458 
459 void
461 {
462  m_phyTxEndTrace (packet);
463 }
464 
465 void
467 {
468  m_phyTxDropTrace (packet);
469 }
470 
471 void
473 {
474  m_phyRxBeginTrace (packet);
475 }
476 
477 void
479 {
480  m_phyRxEndTrace (packet);
481 }
482 
483 void
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
506 {
507  static WifiMode mode =
508  WifiModeFactory::CreateWifiMode ("DsssRate1Mbps",
510  true,
511  22000000, 1000000,
513  2);
514  return mode;
515 }
516 
517 WifiMode
519 {
520  static WifiMode mode =
521  WifiModeFactory::CreateWifiMode ("DsssRate2Mbps",
523  true,
524  22000000, 2000000,
526  4);
527  return mode;
528 }
529 
530 
531 // Clause 18 rates (HR/DSSS)
532 
533 WifiMode
535 {
536  static WifiMode mode =
537  WifiModeFactory::CreateWifiMode ("DsssRate5_5Mbps",
539  true,
540  22000000, 5500000,
542  4);
543  return mode;
544 }
545 
546 WifiMode
548 {
549  static WifiMode mode =
550  WifiModeFactory::CreateWifiMode ("DsssRate11Mbps",
552  true,
553  22000000, 11000000,
555  4);
556  return mode;
557 }
558 
559 
560 // Clause 19.5 rates (ERP-OFDM)
561 
562 WifiMode
564 {
565  static WifiMode mode =
566  WifiModeFactory::CreateWifiMode ("ErpOfdmRate6Mbps",
568  true,
569  20000000, 6000000,
571  2);
572  return mode;
573 }
574 
575 WifiMode
577 {
578  static WifiMode mode =
579  WifiModeFactory::CreateWifiMode ("ErpOfdmRate9Mbps",
581  false,
582  20000000, 9000000,
584  2);
585  return mode;
586 }
587 
588 WifiMode
590 {
591  static WifiMode mode =
592  WifiModeFactory::CreateWifiMode ("ErpOfdmRate12Mbps",
594  true,
595  20000000, 12000000,
597  4);
598  return mode;
599 }
600 
601 WifiMode
603 {
604  static WifiMode mode =
605  WifiModeFactory::CreateWifiMode ("ErpOfdmRate18Mbps",
607  false,
608  20000000, 18000000,
610  4);
611  return mode;
612 }
613 
614 WifiMode
616 {
617  static WifiMode mode =
618  WifiModeFactory::CreateWifiMode ("ErpOfdmRate24Mbps",
620  true,
621  20000000, 24000000,
623  16);
624  return mode;
625 }
626 
627 WifiMode
629 {
630  static WifiMode mode =
631  WifiModeFactory::CreateWifiMode ("ErpOfdmRate36Mbps",
633  false,
634  20000000, 36000000,
636  16);
637  return mode;
638 }
639 
640 WifiMode
642 {
643  static WifiMode mode =
644  WifiModeFactory::CreateWifiMode ("ErpOfdmRate48Mbps",
646  false,
647  20000000, 48000000,
649  64);
650  return mode;
651 }
652 
653 WifiMode
655 {
656  static WifiMode mode =
657  WifiModeFactory::CreateWifiMode ("ErpOfdmRate54Mbps",
659  false,
660  20000000, 54000000,
662  64);
663  return mode;
664 }
665 
666 
667 // Clause 17 rates (OFDM)
668 
669 WifiMode
671 {
672  static WifiMode mode =
673  WifiModeFactory::CreateWifiMode ("OfdmRate6Mbps",
675  true,
676  20000000, 6000000,
678  2);
679  return mode;
680 }
681 
682 WifiMode
684 {
685  static WifiMode mode =
686  WifiModeFactory::CreateWifiMode ("OfdmRate9Mbps",
688  false,
689  20000000, 9000000,
691  2);
692  return mode;
693 }
694 
695 WifiMode
697 {
698  static WifiMode mode =
699  WifiModeFactory::CreateWifiMode ("OfdmRate12Mbps",
701  true,
702  20000000, 12000000,
704  4);
705  return mode;
706 }
707 
708 WifiMode
710 {
711  static WifiMode mode =
712  WifiModeFactory::CreateWifiMode ("OfdmRate18Mbps",
714  false,
715  20000000, 18000000,
717  4);
718  return mode;
719 }
720 
721 WifiMode
723 {
724  static WifiMode mode =
725  WifiModeFactory::CreateWifiMode ("OfdmRate24Mbps",
727  true,
728  20000000, 24000000,
730  16);
731  return mode;
732 }
733 
734 WifiMode
736 {
737  static WifiMode mode =
738  WifiModeFactory::CreateWifiMode ("OfdmRate36Mbps",
740  false,
741  20000000, 36000000,
743  16);
744  return mode;
745 }
746 
747 WifiMode
749 {
750  static WifiMode mode =
751  WifiModeFactory::CreateWifiMode ("OfdmRate48Mbps",
753  false,
754  20000000, 48000000,
756  64);
757  return mode;
758 }
759 
760 WifiMode
762 {
763  static WifiMode mode =
764  WifiModeFactory::CreateWifiMode ("OfdmRate54Mbps",
766  false,
767  20000000, 54000000,
769  64);
770  return mode;
771 }
772 
773 // 10 MHz channel rates
774 
775 WifiMode
777 {
778  static WifiMode mode =
779  WifiModeFactory::CreateWifiMode ("OfdmRate3MbpsBW10MHz",
781  true,
782  10000000, 3000000,
784  2);
785  return mode;
786 }
787 
788 WifiMode
790 {
791  static WifiMode mode =
792  WifiModeFactory::CreateWifiMode ("OfdmRate4_5MbpsBW10MHz",
794  false,
795  10000000, 4500000,
797  2);
798  return mode;
799 }
800 
801 WifiMode
803 {
804  static WifiMode mode =
805  WifiModeFactory::CreateWifiMode ("OfdmRate6MbpsBW10MHz",
807  true,
808  10000000, 6000000,
810  4);
811  return mode;
812 }
813 
814 WifiMode
816 {
817  static WifiMode mode =
818  WifiModeFactory::CreateWifiMode ("OfdmRate9MbpsBW10MHz",
820  false,
821  10000000, 9000000,
823  4);
824  return mode;
825 }
826 
827 WifiMode
829 {
830  static WifiMode mode =
831  WifiModeFactory::CreateWifiMode ("OfdmRate12MbpsBW10MHz",
833  true,
834  10000000, 12000000,
836  16);
837  return mode;
838 }
839 
840 WifiMode
842 {
843  static WifiMode mode =
844  WifiModeFactory::CreateWifiMode ("OfdmRate18MbpsBW10MHz",
846  false,
847  10000000, 18000000,
849  16);
850  return mode;
851 }
852 
853 WifiMode
855 {
856  static WifiMode mode =
857  WifiModeFactory::CreateWifiMode ("OfdmRate24MbpsBW10MHz",
859  false,
860  10000000, 24000000,
862  64);
863  return mode;
864 }
865 
866 WifiMode
868 {
869  static WifiMode mode =
870  WifiModeFactory::CreateWifiMode ("OfdmRate27MbpsBW10MHz",
872  false,
873  10000000, 27000000,
875  64);
876  return mode;
877 }
878 
879 // 5 MHz channel rates
880 
881 WifiMode
883 {
884  static WifiMode mode =
885  WifiModeFactory::CreateWifiMode ("OfdmRate1_5MbpsBW5MHz",
887  true,
888  5000000, 1500000,
890  2);
891  return mode;
892 }
893 
894 WifiMode
896 {
897  static WifiMode mode =
898  WifiModeFactory::CreateWifiMode ("OfdmRate2_25MbpsBW5MHz",
900  false,
901  5000000, 2250000,
903  2);
904  return mode;
905 }
906 
907 WifiMode
909 {
910  static WifiMode mode =
911  WifiModeFactory::CreateWifiMode ("OfdmRate3MbpsBW5MHz",
913  true,
914  5000000, 3000000,
916  4);
917  return mode;
918 }
919 
920 WifiMode
922 {
923  static WifiMode mode =
924  WifiModeFactory::CreateWifiMode ("OfdmRate4_5MbpsBW5MHz",
926  false,
927  5000000, 4500000,
929  4);
930  return mode;
931 }
932 
933 WifiMode
935 {
936  static WifiMode mode =
937  WifiModeFactory::CreateWifiMode ("OfdmRate6MbpsBW5MHz",
939  true,
940  5000000, 6000000,
942  16);
943  return mode;
944 }
945 
946 WifiMode
948 {
949  static WifiMode mode =
950  WifiModeFactory::CreateWifiMode ("OfdmRate9MbpsBW5MHz",
952  false,
953  5000000, 9000000,
955  16);
956  return mode;
957 }
958 
959 WifiMode
961 {
962  static WifiMode mode =
963  WifiModeFactory::CreateWifiMode ("OfdmRate12MbpsBW5MHz",
965  false,
966  5000000, 12000000,
968  64);
969  return mode;
970 }
971 
972 WifiMode
974 {
975  static WifiMode mode =
976  WifiModeFactory::CreateWifiMode ("OfdmRate13_5MbpsBW5MHz",
978  false,
979  5000000, 13500000,
981  64);
982  return mode;
983 }
984 
985 // Clause 20
986 
987 WifiMode
989 {
990  static WifiMode mode =
991  WifiModeFactory::CreateWifiMode ("OfdmRate6_5MbpsBW20MHz",
993  true,
994  20000000, 6500000,
996  2);
997  return mode;
998 }
999 WifiMode
1001 {
1002  static WifiMode mode =
1003  WifiModeFactory::CreateWifiMode ("OfdmRate7_2MbpsBW20MHz",
1005  false,
1006  20000000, 7200000,
1008  2);
1009  return mode;
1010 }
1011 
1012 WifiMode
1014 {
1015  static WifiMode mode =
1016  WifiModeFactory::CreateWifiMode ("OfdmRate13MbpsBW20MHz",
1018  true,
1019  20000000, 13000000,
1021  4);
1022  return mode;
1023 }
1024 
1025 WifiMode
1027 {
1028  static WifiMode mode =
1029  WifiModeFactory::CreateWifiMode ("OfdmRate14_4MbpsBW20MHz",
1031  false,
1032  20000000, 14400000,
1034  4);
1035  return mode;
1036 }
1037 WifiMode
1039 {
1040  static WifiMode mode =
1041  WifiModeFactory::CreateWifiMode ("OfdmRate19_5MbpsBW20MHz",
1043  true,
1044  20000000, 19500000,
1046  4);
1047  return mode;
1048 }
1049 
1050 WifiMode
1052 {
1053  static WifiMode mode =
1054  WifiModeFactory::CreateWifiMode ("OfdmRate21_7MbpsBW20MHz",
1056  false,
1057  20000000, 21700000,
1059  4);
1060  return mode;
1061 }
1062 
1063 
1064 WifiMode
1066 {
1067  static WifiMode mode =
1068  WifiModeFactory::CreateWifiMode ("OfdmRate26MbpsBW20MHz",
1070  true,
1071  20000000, 26000000,
1073  16);
1074  return mode;
1075 }
1076 
1077 WifiMode
1079 {
1080  static WifiMode mode =
1081  WifiModeFactory::CreateWifiMode ("OfdmRate28_9MbpsBW20MHz",
1083  false,
1084  20000000, 28900000,
1086  16);
1087  return mode;
1088 }
1089 
1090 WifiMode
1092 {
1093  static WifiMode mode =
1094  WifiModeFactory::CreateWifiMode ("OfdmRate39MbpsBW20MHz",
1096  true,
1097  20000000, 39000000,
1099  16);
1100  return mode;
1101 }
1102 
1103 WifiMode
1105 {
1106  static WifiMode mode =
1107  WifiModeFactory::CreateWifiMode ("OfdmRate43_3MbpsBW20MHz",
1109  false,
1110  20000000, 43300000,
1112  16);
1113  return mode;
1114 }
1115 
1116 WifiMode
1118 {
1119  static WifiMode mode =
1120  WifiModeFactory::CreateWifiMode ("OfdmRate52MbpsBW20MHz",
1122  true,
1123  20000000, 52000000,
1125  64);
1126  return mode;
1127 }
1128 
1129 WifiMode
1131 {
1132  static WifiMode mode =
1133  WifiModeFactory::CreateWifiMode ("OfdmRate57_8MbpsBW20MHz",
1135  false,
1136  20000000, 57800000,
1138  64);
1139  return mode;
1140 }
1141 
1142 
1143 WifiMode
1145 {
1146  static WifiMode mode =
1147  WifiModeFactory::CreateWifiMode ("OfdmRate58_5MbpsBW20MHz",
1149  true,
1150  20000000, 58500000,
1152  64);
1153  return mode;
1154 }
1155 
1156 WifiMode
1158 {
1159  static WifiMode mode =
1160  WifiModeFactory::CreateWifiMode ("OfdmRate65MbpsBW20MHzShGi",
1162  false,
1163  20000000, 65000000,
1165  64);
1166  return mode;
1167 }
1168 
1169 WifiMode
1171 {
1172  static WifiMode mode =
1173  WifiModeFactory::CreateWifiMode ("OfdmRate65MbpsBW20MHz",
1175  true,
1176  20000000, 65000000,
1178  64);
1179  return mode;
1180 }
1181 
1182 WifiMode
1184 {
1185  static WifiMode mode =
1186  WifiModeFactory::CreateWifiMode ("OfdmRate72_2MbpsBW20MHz",
1188  false,
1189  20000000, 72200000,
1191  64);
1192  return mode;
1193 }
1194 
1195 WifiMode
1197 {
1198  static WifiMode mode =
1199  WifiModeFactory::CreateWifiMode ("OfdmRate13_5MbpsBW40MHz",
1201  false,
1202  40000000, 13500000,
1204  2);
1205  return mode;
1206 }
1207 
1208 WifiMode
1210 {
1211  static WifiMode mode =
1212  WifiModeFactory::CreateWifiMode ("OfdmRate15MbpsBW40MHz",
1214  false,
1215  40000000, 15000000,
1217  2);
1218  return mode;
1219 }
1220 
1221 WifiMode
1223 {
1224  static WifiMode mode =
1225  WifiModeFactory::CreateWifiMode ("OfdmRate27MbpsBW40MHz",
1227  false,
1228  40000000, 27000000,
1230  4);
1231  return mode;
1232 }
1233 WifiMode
1235 {
1236  static WifiMode mode =
1237  WifiModeFactory::CreateWifiMode ("OfdmRate30MbpsBW40MHz",
1239  false,
1240  40000000, 30000000,
1242  4);
1243  return mode;
1244 }
1245 
1246 WifiMode
1248 {
1249  static WifiMode mode =
1250  WifiModeFactory::CreateWifiMode ("OfdmRate40_5MbpsBW40MHz",
1252  false,
1253  40000000, 40500000,
1255  4);
1256  return mode;
1257 }
1258 WifiMode
1260 {
1261  static WifiMode mode =
1262  WifiModeFactory::CreateWifiMode ("OfdmRate45MbpsBW40MHz",
1264  false,
1265  40000000, 45000000,
1267  4);
1268  return mode;
1269 }
1270 
1271 WifiMode
1273 {
1274  static WifiMode mode =
1275  WifiModeFactory::CreateWifiMode ("OfdmRate54MbpsBW40MHz",
1277  false,
1278  40000000, 54000000,
1280  16);
1281  return mode;
1282 }
1283 
1284 WifiMode
1286 {
1287  static WifiMode mode =
1288  WifiModeFactory::CreateWifiMode ("OfdmRate60MbpsBW40MHz",
1290  false,
1291  40000000, 60000000,
1293  16);
1294  return mode;
1295 }
1296 
1297 WifiMode
1299 {
1300  static WifiMode mode =
1301  WifiModeFactory::CreateWifiMode ("OfdmRate81MbpsBW40MHz",
1303  false,
1304  40000000, 81000000,
1306  16);
1307  return mode;
1308 }
1309 WifiMode
1311 {
1312  static WifiMode mode =
1313  WifiModeFactory::CreateWifiMode ("OfdmRate90MbpsBW40MHz",
1315  false,
1316  40000000, 90000000,
1318  16);
1319  return mode;
1320 }
1321 
1322 WifiMode
1324 {
1325  static WifiMode mode =
1326  WifiModeFactory::CreateWifiMode ("OfdmRate108MbpsBW40MHz",
1328  false,
1329  40000000, 108000000,
1331  64);
1332  return mode;
1333 }
1334 WifiMode
1336 {
1337  static WifiMode mode =
1338  WifiModeFactory::CreateWifiMode ("OfdmRate120MbpsBW40MHz",
1340  false,
1341  40000000, 120000000,
1343  64);
1344  return mode;
1345 }
1346 WifiMode
1348 {
1349  static WifiMode mode =
1350  WifiModeFactory::CreateWifiMode ("OfdmRate121_5MbpsBW40MHz",
1352  false,
1353  40000000, 121500000,
1355  64);
1356  return mode;
1357 }
1358 WifiMode
1360 {
1361  static WifiMode mode =
1362  WifiModeFactory::CreateWifiMode ("OfdmRate135MbpsBW40MHzShGi",
1364  false,
1365  40000000, 135000000,
1367  64);
1368  return mode;
1369 }
1370 WifiMode
1372 {
1373  static WifiMode mode =
1374  WifiModeFactory::CreateWifiMode ("OfdmRate135MbpsBW40MHz",
1376  false,
1377  40000000, 135000000,
1379  64);
1380  return mode;
1381 }
1382 
1383 WifiMode
1385 {
1386  static WifiMode mode =
1387  WifiModeFactory::CreateWifiMode ("OfdmRate150MbpsBW40MHz",
1389  false,
1390  40000000, 150000000,
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:
1428  {
1489 
1490  }
1491 } g_constructor;
1492 }
static class anonymous_namespace{wifi-phy.cc}::Constructor g_constructor
static WifiMode GetOfdmRate9MbpsBW5MHz()
Return a WifiMode for ODFM at 9Mbps with 5MHz channel spacing.
Definition: wifi-phy.cc:947
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
static WifiMode GetErpOfdmRate24Mbps()
Return a WifiMode for ERP-ODFM at 24Mbps.
Definition: wifi-phy.cc:615
static WifiMode GetDsssRate11Mbps()
Return a WifiMode for DSSS at 11Mbps.
Definition: wifi-phy.cc:547
static uint32_t GetPlcpHeaderDurationMicroSeconds(WifiMode payloadMode, WifiPreamble preamble)
Definition: wifi-phy.cc:222
keep track of time values and allow control of global simulation resolution
Definition: nstime.h:81
static WifiMode GetErpOfdmRate36Mbps()
Return a WifiMode for ERP-ODFM at 36Mbps.
Definition: wifi-phy.cc:628
#define NS_LOG_FUNCTION(parameters)
Definition: log.h:345
static WifiMode GetOfdmRate26MbpsBW20MHz()
Return a WifiMode for ODFM at 26Mbps with 20MHz channel spacing.
Definition: wifi-phy.cc:1065
ERP-OFDM PHY (19.5)
Definition: wifi-mode.h:52
static WifiMode GetOfdmRate9Mbps()
Return a WifiMode for ODFM at 9Mbps.
Definition: wifi-phy.cc:683
static WifiMode GetOfdmRate7_2MbpsBW20MHz()
Return a WifiMode for ODFM at 7.2Mbps with 20MHz channel spacing.
Definition: wifi-phy.cc:1000
static WifiMode GetOfdmRate18MbpsBW10MHz()
Return a WifiMode for ODFM at 18Mbps with 10MHz channel spacing.
Definition: wifi-phy.cc:841
This class mimics the TXVECTOR which is to be passed to the PHY in order to define the parameters whi...
static WifiMode GetOfdmRate27MbpsBW10MHz()
Return a WifiMode for ODFM at 27Mbps with 10MHz channel spacing.
Definition: wifi-phy.cc:867
static WifiMode GetOfdmRate3MbpsBW5MHz()
Return a WifiMode for ODFM at 3Mbps with 5MHz channel spacing.
Definition: wifi-phy.cc:908
virtual ~WifiPhy()
Definition: wifi-phy.cc:92
static WifiMode GetDsssRate1Mbps()
Return a WifiMode for DSSS at 1Mbps.
Definition: wifi-phy.cc:505
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
static WifiMode GetOfdmRate81MbpsBW40MHz()
Return a WifiMode for ODFM at 81Mbps with 40MHz channel spacing.
Definition: wifi-phy.cc:1298
802.11 PHY layer model
Definition: wifi-phy.h:117
static WifiMode GetErpOfdmRate18Mbps()
Return a WifiMode for ERP-ODFM at 18Mbps.
Definition: wifi-phy.cc:602
State
The state of the PHY layer.
Definition: wifi-phy.h:123
NS_LOG_COMPONENT_DEFINE("WifiPhy")
static WifiMode GetOfdmRate12Mbps()
Return a WifiMode for ODFM at 12Mbps.
Definition: wifi-phy.cc:696
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
enum WifiModulationClass GetModulationClass() const
Definition: wifi-mode.cc:115
static WifiMode GetOfdmRate43_3MbpsBW20MHz()
Return a WifiMode for ODFM at 43.3Mbps with 20MHz channel spacing.
Definition: wifi-phy.cc:1104
NS_OBJECT_ENSURE_REGISTERED(NullMessageSimulatorImpl)
static WifiMode GetOfdmRate60MbpsBW40MHz()
Return a WifiMode for ODFM at 60Mbps with 40MHz channel spacing.
Definition: wifi-phy.cc:1285
static WifiMode GetOfdmRate1_5MbpsBW5MHz()
Return a WifiMode for ODFM at 1.5Mbps with 5MHz channel spacing.
Definition: wifi-phy.cc:882
static WifiMode GetOfdmRate4_5MbpsBW10MHz()
Return a WifiMode for ODFM at 4.5Mbps with 10MHz channel spacing.
Definition: wifi-phy.cc:789
static WifiMode GetMFPlcpHeaderMode(WifiMode payloadMode, WifiPreamble preamble)
Definition: wifi-phy.cc:101
static WifiMode GetOfdmRate54Mbps()
Return a WifiMode for ODFM at 54Mbps.
Definition: wifi-phy.cc:761
void NotifyTxDrop(Ptr< const Packet > packet)
Public method used to fire a PhyTxDrop trace.
Definition: wifi-phy.cc:466
static WifiMode GetOfdmRate108MbpsBW40MHz()
Return a WifiMode for ODFM at 108Mbps with 40MHz channel spacing.
Definition: wifi-phy.cc:1323
static WifiMode GetOfdmRate21_7MbpsBW20MHz()
Return a WifiMode for ODFM at 21.7Mbps with 20MHz channel spacing.
Definition: wifi-phy.cc:1051
void NotifyTxBegin(Ptr< const Packet > packet)
Public method used to fire a PhyTxBegin trace.
Definition: wifi-phy.cc:454
represent a single transmission modeA WifiMode is implemented by a single integer which is used to lo...
Definition: wifi-mode.h:91
static WifiMode GetOfdmRate135MbpsBW40MHz()
Return a WifiMode for ODFM at 135Mbps with 40MHz channel spacing.
Definition: wifi-phy.cc:1371
static WifiMode GetOfdmRate36Mbps()
Return a WifiMode for ODFM at 36Mbps.
Definition: wifi-phy.cc:735
static WifiMode GetOfdmRate6MbpsBW5MHz()
Return a WifiMode for ODFM at 6Mbps with 5MHz channel spacing.
Definition: wifi-phy.cc:934
#define NS_FATAL_ERROR(msg)
fatal error handling
Definition: fatal-error.h:72
The PHY layer is switching to other channel.
Definition: wifi-phy.h:144
static WifiMode GetErpOfdmRate54Mbps()
Return a WifiMode for ERP-ODFM at 54Mbps.
Definition: wifi-phy.cc:654
void NotifyRxDrop(Ptr< const Packet > packet)
Public method used to fire a PhyRxDrop trace.
Definition: wifi-phy.cc:484
WifiPreamble
The type of preamble to be used by an IEEE 802.11 transmission.
Definition: wifi-preamble.h:29
static WifiMode GetOfdmRate6_5MbpsBW20MHz()
Return a WifiMode for ODFM at 6.5Mbps with 20MHz channel spacing.
Definition: wifi-phy.cc:988
static double GetPayloadDurationMicroSeconds(uint32_t size, WifiTxVector txvector)
Definition: wifi-phy.cc:333
static WifiMode GetOfdmRate135MbpsBW40MHzShGi()
Return a WifiMode for ODFM at 135Mbps with 40MHz channel spacing.
Definition: wifi-phy.cc:1359
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
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
static WifiMode GetErpOfdmRate48Mbps()
Return a WifiMode for ERP-ODFM at 48Mbps.
Definition: wifi-phy.cc:641
static WifiMode GetPlcpHeaderMode(WifiMode payloadMode, WifiPreamble preamble)
Definition: wifi-phy.cc:149
uint8_t GetNess(void) const
static WifiMode GetOfdmRate12MbpsBW10MHz()
Return a WifiMode for ODFM at 12Mbps with 10MHz channel spacing.
Definition: wifi-phy.cc:828
HT PHY (Clause 20)
Definition: wifi-mode.h:56
std::string GetUniqueName(void) const
Definition: wifi-mode.cc:97
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
virtual ~WifiPhyListener()
Definition: wifi-phy.cc:43
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
void NotifyRxBegin(Ptr< const Packet > packet)
Public method used to fire a PhyRxBegin trace.
Definition: wifi-phy.cc:472
static WifiMode GetOfdmRate19_5MbpsBW20MHz()
Return a WifiMode for ODFM at 19.5Mbps with 20MHz channel spacing.
Definition: wifi-phy.cc:1038
static WifiMode GetOfdmRate18Mbps()
Return a WifiMode for ODFM at 18Mbps.
Definition: wifi-phy.cc:709
static WifiMode GetOfdmRate9MbpsBW10MHz()
Return a WifiMode for ODFM at 9Mbps with 10MHz channel spacing.
Definition: wifi-phy.cc:815
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
bool IsStbc(void) const
Check if STBC is used or not.
static WifiMode GetOfdmRate12MbpsBW5MHz()
Return a WifiMode for ODFM at 12Mbps with 5MHz channel spacing.
Definition: wifi-phy.cc:960
static WifiMode GetOfdmRate52MbpsBW20MHz()
Return a WifiMode for ODFM at 52Mbps with 20MHz channel spacing.
Definition: wifi-phy.cc:1117
#define NS_LOG_LOGIC(msg)
Definition: log.h:368
static WifiMode GetOfdmRate40_5MbpsBW40MHz()
Return a WifiMode for ODFM at 40.5Mbps with 40MHz channel spacing.
Definition: wifi-phy.cc:1247
uint32_t GetBandwidth(void) const
Definition: wifi-mode.cc:67
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
static WifiMode GetOfdmRate72_2MbpsBW20MHz()
Return a WifiMode for ODFM at 72.2Mbps with 20MHz channel spacing.
Definition: wifi-phy.cc:1183
static WifiMode GetOfdmRate65MbpsBW20MHzShGi()
Return a WifiMode for ODFM at 65Mbps with 20MHz channel spacing.
Definition: wifi-phy.cc:1157
static WifiMode GetOfdmRate48Mbps()
Return a WifiMode for ODFM at 48Mbps.
Definition: wifi-phy.cc:748
std::ostream & operator<<(std::ostream &os, const Angles &a)
print a struct Angles to output
Definition: angles.cc:43
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
The PHY layer is IDLE.
Definition: wifi-phy.h:128
static TypeId GetTypeId(void)
Definition: wifi-phy.cc:55
static WifiMode GetOfdmRate57_8MbpsBW20MHz()
Return a WifiMode for ODFM at 57.8Mbps with 20MHz channel spacing.
Definition: wifi-phy.cc:1130
static WifiMode GetOfdmRate24Mbps()
Return a WifiMode for ODFM at 24Mbps.
Definition: wifi-phy.cc:722
Ptr< const TraceSourceAccessor > MakeTraceSourceAccessor(T a)
static WifiMode GetOfdmRate13MbpsBW20MHz()
Return a WifiMode for ODFM at 13Mbps with 20MHz channel spacing.
Definition: wifi-phy.cc:1013
static WifiMode GetOfdmRate65MbpsBW20MHz()
Return a WifiMode for ODFM at 65Mbps with 20MHz channel spacing.
Definition: wifi-phy.cc:1170
static uint32_t GetPlcpHtTrainingSymbolDurationMicroSeconds(WifiMode payloadMode, WifiPreamble preamble, WifiTxVector txvector)
Definition: wifi-phy.cc:114
static WifiMode GetOfdmRate58_5MbpsBW20MHz()
Return a WifiMode for ODFM at 58.5Mbps with 20MHz channel spacing.
Definition: wifi-phy.cc:1144
static WifiMode GetDsssRate5_5Mbps()
Return a WifiMode for DSSS at 5.5Mbps.
Definition: wifi-phy.cc:534
static WifiMode GetOfdmRate2_25MbpsBW5MHz()
Return a WifiMode for ODFM at 2.25Mbps with 5MHz channel spacing.
Definition: wifi-phy.cc:895
static WifiMode GetErpOfdmRate9Mbps()
Return a WifiMode for ERP-ODFM at 9Mbps.
Definition: wifi-phy.cc:576
void NotifyTxEnd(Ptr< const Packet > packet)
Public method used to fire a PhyTxEnd trace.
Definition: wifi-phy.cc:460
static WifiMode GetOfdmRate15MbpsBW40MHz()
Return a WifiMode for ODFM at 15Mbps with 40MHz channel spacing.
Definition: wifi-phy.cc:1209
static WifiMode GetOfdmRate121_5MbpsBW40MHz()
Return a WifiMode for ODFM at 121.5Mbps with 40MHz channel spacing.
Definition: wifi-phy.cc:1347
static WifiMode GetOfdmRate28_9MbpsBW20MHz()
Return a WifiMode for ODFM at 28.9Mbps with 20MHz channel spacing.
Definition: wifi-phy.cc:1078
No explicit coding (e.g., DSSS rates)
Definition: wifi-mode.h:70
static WifiMode GetErpOfdmRate6Mbps()
Return a WifiMode for ERP-ODFM at 6Mbps.
Definition: wifi-phy.cc:563
static Time CalculateTxDuration(uint32_t size, WifiTxVector txvector, enum WifiPreamble preamble)
Definition: wifi-phy.cc:440
uint8_t GetNss(void) const
static WifiMode GetErpOfdmRate12Mbps()
Return a WifiMode for ERP-ODFM at 12Mbps.
Definition: wifi-phy.cc:589
void NotifyRxEnd(Ptr< const Packet > packet)
Public method used to fire a PhyRxEnd trace.
Definition: wifi-phy.cc:478
static WifiMode GetOfdmRate13_5MbpsBW40MHz()
Return a WifiMode for ODFM at 13.5Mbps with 40MHz channel spacing.
Definition: wifi-phy.cc:1196
static WifiMode GetOfdmRate30MbpsBW40MHz()
Return a WifiMode for ODFM at 30Mbps with 40MHz channel spacing.
Definition: wifi-phy.cc:1234
static WifiMode GetOfdmRate54MbpsBW40MHz()
Return a WifiMode for ODFM at 54Mbps with 40MHz channel spacing.
Definition: wifi-phy.cc:1272
OFDM PHY (Clause 17)
Definition: wifi-mode.h:54
static WifiMode GetOfdmRate90MbpsBW40MHz()
Return a WifiMode for ODFM at 90Mbps with 40MHz channel spacing.
Definition: wifi-phy.cc:1310
static WifiMode GetOfdmRate45MbpsBW40MHz()
Return a WifiMode for ODFM at 45Mbps with 40MHz channel spacing.
Definition: wifi-phy.cc:1259
static WifiMode GetOfdmRate120MbpsBW40MHz()
Return a WifiMode for ODFM at 120Mbps with 40MHz channel spacing.
Definition: wifi-phy.cc:1335
static WifiMode GetOfdmRate39MbpsBW20MHz()
Return a WifiMode for ODFM at 39Mbps with 20MHz channel spacing.
Definition: wifi-phy.cc:1091
a base class which provides memory management and object aggregation
Definition: object.h:63
static WifiMode GetDsssRate2Mbps()
Return a WifiMode for DSSS at 2Mbps.
Definition: wifi-phy.cc:518
static WifiMode GetOfdmRate6MbpsBW10MHz()
Return a WifiMode for ODFM at 6Mbps with 10MHz channel spacing.
Definition: wifi-phy.cc:802
WifiMode GetMode(void) const
The PHY layer is receiving a packet.
Definition: wifi-phy.h:140
static WifiMode GetOfdmRate24MbpsBW10MHz()
Return a WifiMode for ODFM at 24Mbps with 10MHz channel spacing.
Definition: wifi-phy.cc:854
The PHY layer has sense the medium busy through the CCA mechanism.
Definition: wifi-phy.h:132
static WifiMode GetOfdmRate13_5MbpsBW5MHz()
Return a WifiMode for ODFM at 13.5Mbps with 5MHz channel spacing.
Definition: wifi-phy.cc:973
a unique identifier for an interface.
Definition: type-id.h:49
static uint32_t GetPlcpPreambleDurationMicroSeconds(WifiMode payloadMode, WifiPreamble preamble)
Definition: wifi-phy.cc:285
The PHY layer is sending a packet.
Definition: wifi-phy.h:136
uint64_t GetDataRate(void) const
Definition: wifi-mode.cc:79
TypeId SetParent(TypeId tid)
Definition: type-id.cc:611
static WifiMode GetOfdmRate6Mbps()
Return a WifiMode for ODFM at 6Mbps.
Definition: wifi-phy.cc:670
static WifiMode GetOfdmRate27MbpsBW40MHz()
Return a WifiMode for ODFM at 27Mbps with 40MHz channel spacing.
Definition: wifi-phy.cc:1222
DSSS PHY (Clause 15) and HR/DSSS PHY (Clause 18)
Definition: wifi-mode.h:46
static WifiMode GetOfdmRate4_5MbpsBW5MHz()
Return a WifiMode for ODFM at 4.5Mbps with 5MHz channel spacing.
Definition: wifi-phy.cc:921
static WifiMode GetOfdmRate14_4MbpsBW20MHz()
Return a WifiMode for ODFM at 14.4Mbps with 20MHz channel spacing.
Definition: wifi-phy.cc:1026
static uint32_t GetPlcpHtSigHeaderDurationMicroSeconds(WifiMode payloadMode, WifiPreamble preamble)
Definition: wifi-phy.cc:130
static WifiMode GetOfdmRate3MbpsBW10MHz()
Return a WifiMode for ODFM at 3Mbps with 10MHz channel spacing.
Definition: wifi-phy.cc:776
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
static WifiMode GetOfdmRate150MbpsBW40MHz()
Return a WifiMode for ODFM at 150Mbps with 40MHz channel spacing.
Definition: wifi-phy.cc:1384