A Discrete-Event Network Simulator
API
wifi-phy-ofdma-test.cc
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2019 University of Washington
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License version 2 as
6  * published by the Free Software Foundation;
7  *
8  * This program is distributed in the hope that it will be useful,
9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11  * GNU General Public License for more details.
12  *
13  * You should have received a copy of the GNU General Public License
14  * along with this program; if not, write to the Free Software
15  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16  *
17  * Author: Sébastien Deronne <sebastien.deronne@gmail.com>
18  */
19 
20 #include "ns3/ap-wifi-mac.h"
21 #include "ns3/boolean.h"
22 #include "ns3/constant-position-mobility-model.h"
23 #include "ns3/ctrl-headers.h"
24 #include "ns3/double.h"
25 #include "ns3/he-configuration.h"
26 #include "ns3/he-phy.h"
27 #include "ns3/he-ppdu.h"
28 #include "ns3/interference-helper.h"
29 #include "ns3/log.h"
30 #include "ns3/mobility-helper.h"
31 #include "ns3/multi-model-spectrum-channel.h"
32 #include "ns3/nist-error-rate-model.h"
33 #include "ns3/node.h"
34 #include "ns3/non-communicating-net-device.h"
35 #include "ns3/pointer.h"
36 #include "ns3/rng-seed-manager.h"
37 #include "ns3/simulator.h"
38 #include "ns3/spectrum-wifi-helper.h"
39 #include "ns3/spectrum-wifi-phy.h"
40 #include "ns3/sta-wifi-mac.h"
41 #include "ns3/string.h"
42 #include "ns3/test.h"
43 #include "ns3/threshold-preamble-detection-model.h"
44 #include "ns3/waveform-generator.h"
45 #include "ns3/wifi-mac-header.h"
46 #include "ns3/wifi-net-device.h"
47 #include "ns3/wifi-phy-listener.h"
48 #include "ns3/wifi-psdu.h"
49 #include "ns3/wifi-spectrum-signal-parameters.h"
50 #include "ns3/wifi-spectrum-value-helper.h"
51 #include "ns3/wifi-utils.h"
52 
53 #include <algorithm>
54 #include <iterator>
55 #include <memory>
56 
57 using namespace ns3;
58 
59 NS_LOG_COMPONENT_DEFINE("WifiPhyOfdmaTest");
60 
61 static const uint8_t DEFAULT_CHANNEL_NUMBER = 36;
62 static const uint32_t DEFAULT_FREQUENCY = 5180; // MHz
63 static const WifiPhyBand DEFAULT_WIFI_BAND = WIFI_PHY_BAND_5GHZ;
64 static const uint16_t DEFAULT_CHANNEL_WIDTH = 20; // MHz
65 static const uint16_t DEFAULT_GUARD_WIDTH =
66  DEFAULT_CHANNEL_WIDTH; // MHz (expanded to channel width to model spectrum mask)
67 
72 class OfdmaTestHePhy : public HePhy
73 {
74  public:
80  OfdmaTestHePhy(uint16_t staId);
81  ~OfdmaTestHePhy() override;
82 
90  uint16_t GetStaId(const Ptr<const WifiPpdu> ppdu) const override;
91 
97  void SetGlobalPpduUid(uint64_t uid);
98 
99  private:
100  uint16_t m_staId;
101 }; // class OfdmaTestHePhy
102 
103 OfdmaTestHePhy::OfdmaTestHePhy(uint16_t staId)
104  : HePhy(),
105  m_staId(staId)
106 {
107 }
108 
109 OfdmaTestHePhy::~OfdmaTestHePhy()
110 {
111 }
112 
113 uint16_t
114 OfdmaTestHePhy::GetStaId(const Ptr<const WifiPpdu> ppdu) const
115 {
116  if (ppdu->GetType() == WIFI_PPDU_TYPE_DL_MU)
117  {
118  return m_staId;
119  }
120  return HePhy::GetStaId(ppdu);
121 }
122 
123 void
124 OfdmaTestHePhy::SetGlobalPpduUid(uint64_t uid)
125 {
126  m_globalPpduUid = uid;
127 }
128 
132 class OfdmaSpectrumWifiPhy : public SpectrumWifiPhy
133 {
134  public:
139  static TypeId GetTypeId();
145  OfdmaSpectrumWifiPhy(uint16_t staId);
146  ~OfdmaSpectrumWifiPhy() override;
147 
148  void DoInitialize() override;
149  void DoDispose() override;
150 
151  using WifiPhy::Reset;
152  void StartTx(Ptr<const WifiPpdu> ppdu) override;
153 
159  typedef void (*TxPpduUidCallback)(uint64_t uid);
160 
166  void SetPpduUid(uint64_t uid);
167 
173  void SetTriggerFrameUid(uint64_t uid);
174 
178  std::map<std::pair<uint64_t, WifiPreamble>, Ptr<Event>>& GetCurrentPreambleEvents();
182  Ptr<Event> GetCurrentEvent();
183 
194  Time GetEnergyDuration(double energyW, WifiSpectrumBand band);
195 
199  Ptr<const HePhy> GetHePhy() const;
200 
201  private:
202  Ptr<OfdmaTestHePhy> m_ofdmTestHePhy;
203  TracedCallback<uint64_t>
204  m_phyTxPpduUidTrace;
205 }; // class OfdmaSpectrumWifiPhy
206 
207 TypeId
208 OfdmaSpectrumWifiPhy::GetTypeId()
209 {
210  static TypeId tid =
211  TypeId("ns3::OfdmaSpectrumWifiPhy")
212  .SetParent<SpectrumWifiPhy>()
213  .SetGroupName("Wifi")
214  .AddTraceSource("TxPpduUid",
215  "UID of the PPDU to be transmitted",
216  MakeTraceSourceAccessor(&OfdmaSpectrumWifiPhy::m_phyTxPpduUidTrace),
217  "ns3::OfdmaSpectrumWifiPhy::TxPpduUidCallback");
218  return tid;
219 }
220 
221 OfdmaSpectrumWifiPhy::OfdmaSpectrumWifiPhy(uint16_t staId)
222  : SpectrumWifiPhy()
223 {
224  m_ofdmTestHePhy = Create<OfdmaTestHePhy>(staId);
225  m_ofdmTestHePhy->SetOwner(this);
226 }
227 
228 OfdmaSpectrumWifiPhy::~OfdmaSpectrumWifiPhy()
229 {
230 }
231 
232 void
233 OfdmaSpectrumWifiPhy::DoInitialize()
234 {
235  // Replace HE PHY instance with test instance
236  m_phyEntities[WIFI_MOD_CLASS_HE] = m_ofdmTestHePhy;
237  SpectrumWifiPhy::DoInitialize();
238 }
239 
240 void
241 OfdmaSpectrumWifiPhy::DoDispose()
242 {
243  m_ofdmTestHePhy = nullptr;
244  SpectrumWifiPhy::DoDispose();
245 }
246 
247 void
248 OfdmaSpectrumWifiPhy::SetPpduUid(uint64_t uid)
249 {
250  m_ofdmTestHePhy->SetGlobalPpduUid(uid);
251  m_previouslyRxPpduUid = uid;
252 }
253 
254 void
255 OfdmaSpectrumWifiPhy::SetTriggerFrameUid(uint64_t uid)
256 {
257  m_previouslyRxPpduUid = uid;
258 }
259 
260 void
261 OfdmaSpectrumWifiPhy::StartTx(Ptr<const WifiPpdu> ppdu)
262 {
263  m_phyTxPpduUidTrace(ppdu->GetUid());
264  SpectrumWifiPhy::StartTx(ppdu);
265 }
266 
267 std::map<std::pair<uint64_t, WifiPreamble>, Ptr<Event>>&
268 OfdmaSpectrumWifiPhy::GetCurrentPreambleEvents()
269 {
270  return m_currentPreambleEvents;
271 }
272 
273 Ptr<Event>
274 OfdmaSpectrumWifiPhy::GetCurrentEvent()
275 {
276  return m_currentEvent;
277 }
278 
279 Time
280 OfdmaSpectrumWifiPhy::GetEnergyDuration(double energyW, WifiSpectrumBand band)
281 {
282  return m_interference->GetEnergyDuration(energyW, band);
283 }
284 
285 Ptr<const HePhy>
286 OfdmaSpectrumWifiPhy::GetHePhy() const
287 {
288  return DynamicCast<const HePhy>(GetLatestPhyEntity());
289 }
290 
297 class TestDlOfdmaPhyTransmission : public TestCase
298 {
299  public:
300  TestDlOfdmaPhyTransmission();
301  ~TestDlOfdmaPhyTransmission() override;
302 
303  private:
304  void DoSetup() override;
305  void DoTeardown() override;
306  void DoRun() override;
307 
315  void RxSuccessSta1(Ptr<const WifiPsdu> psdu,
316  RxSignalInfo rxSignalInfo,
317  WifiTxVector txVector,
318  std::vector<bool> statusPerMpdu);
326  void RxSuccessSta2(Ptr<const WifiPsdu> psdu,
327  RxSignalInfo rxSignalInfo,
328  WifiTxVector txVector,
329  std::vector<bool> statusPerMpdu);
337  void RxSuccessSta3(Ptr<const WifiPsdu> psdu,
338  RxSignalInfo rxSignalInfo,
339  WifiTxVector txVector,
340  std::vector<bool> statusPerMpdu);
341 
346  void RxFailureSta1(Ptr<const WifiPsdu> psdu);
351  void RxFailureSta2(Ptr<const WifiPsdu> psdu);
356  void RxFailureSta3(Ptr<const WifiPsdu> psdu);
357 
364  void CheckResultsSta1(uint32_t expectedRxSuccess,
365  uint32_t expectedRxFailure,
366  uint32_t expectedRxBytes);
373  void CheckResultsSta2(uint32_t expectedRxSuccess,
374  uint32_t expectedRxFailure,
375  uint32_t expectedRxBytes);
382  void CheckResultsSta3(uint32_t expectedRxSuccess,
383  uint32_t expectedRxFailure,
384  uint32_t expectedRxBytes);
385 
389  void ResetResults();
390 
396  void SendMuPpdu(uint16_t rxStaId1, uint16_t rxStaId2);
397 
403  void GenerateInterference(Ptr<SpectrumValue> interferencePsd, Time duration);
407  void StopInterference();
408 
412  void RunOne();
413 
419  void CheckPhyState(Ptr<OfdmaSpectrumWifiPhy> phy, WifiPhyState expectedState);
425  void DoCheckPhyState(Ptr<OfdmaSpectrumWifiPhy> phy, WifiPhyState expectedState);
426 
427  uint32_t m_countRxSuccessSta1;
428  uint32_t m_countRxSuccessSta2;
429  uint32_t m_countRxSuccessSta3;
430  uint32_t m_countRxFailureSta1;
431  uint32_t m_countRxFailureSta2;
432  uint32_t m_countRxFailureSta3;
433  uint32_t m_countRxBytesSta1;
434  uint32_t m_countRxBytesSta2;
435  uint32_t m_countRxBytesSta3;
436 
437  Ptr<SpectrumWifiPhy> m_phyAp;
438  Ptr<OfdmaSpectrumWifiPhy> m_phySta1;
439  Ptr<OfdmaSpectrumWifiPhy> m_phySta2;
440  Ptr<OfdmaSpectrumWifiPhy> m_phySta3;
441  Ptr<WaveformGenerator> m_phyInterferer;
442 
443  uint16_t m_frequency;
444  uint16_t m_channelWidth;
445  Time m_expectedPpduDuration;
446 };
447 
448 TestDlOfdmaPhyTransmission::TestDlOfdmaPhyTransmission()
449  : TestCase("DL-OFDMA PHY test"),
450  m_countRxSuccessSta1(0),
451  m_countRxSuccessSta2(0),
452  m_countRxSuccessSta3(0),
453  m_countRxFailureSta1(0),
454  m_countRxFailureSta2(0),
455  m_countRxFailureSta3(0),
456  m_countRxBytesSta1(0),
457  m_countRxBytesSta2(0),
458  m_countRxBytesSta3(0),
459  m_frequency(DEFAULT_FREQUENCY),
460  m_channelWidth(DEFAULT_CHANNEL_WIDTH),
461  m_expectedPpduDuration(NanoSeconds(306400))
462 {
463 }
464 
465 void
466 TestDlOfdmaPhyTransmission::ResetResults()
467 {
468  m_countRxSuccessSta1 = 0;
469  m_countRxSuccessSta2 = 0;
470  m_countRxSuccessSta3 = 0;
471  m_countRxFailureSta1 = 0;
472  m_countRxFailureSta2 = 0;
473  m_countRxFailureSta3 = 0;
474  m_countRxBytesSta1 = 0;
475  m_countRxBytesSta2 = 0;
476  m_countRxBytesSta3 = 0;
477 }
478 
479 void
480 TestDlOfdmaPhyTransmission::SendMuPpdu(uint16_t rxStaId1, uint16_t rxStaId2)
481 {
482  NS_LOG_FUNCTION(this << rxStaId1 << rxStaId2);
483  WifiConstPsduMap psdus;
484  WifiTxVector txVector = WifiTxVector(HePhy::GetHeMcs7(),
485  0,
486  WIFI_PREAMBLE_HE_MU,
487  800,
488  1,
489  1,
490  0,
491  m_channelWidth,
492  false,
493  false);
494  HeRu::RuType ruType = HeRu::RU_106_TONE;
495  if (m_channelWidth == 20)
496  {
497  ruType = HeRu::RU_106_TONE;
498  txVector.SetRuAllocation({96});
499  }
500  else if (m_channelWidth == 40)
501  {
502  ruType = HeRu::RU_242_TONE;
503  txVector.SetRuAllocation({192, 192});
504  }
505  else if (m_channelWidth == 80)
506  {
507  ruType = HeRu::RU_484_TONE;
508  txVector.SetRuAllocation({200, 200, 200, 200});
509  }
510  else if (m_channelWidth == 160)
511  {
512  ruType = HeRu::RU_996_TONE;
513  txVector.SetRuAllocation({208, 208, 208, 208, 208, 208, 208, 208});
514  }
515  else
516  {
517  NS_ASSERT_MSG(false, "Unsupported channel width");
518  }
519 
520  txVector.SetSigBMode(VhtPhy::GetVhtMcs5());
521 
522  HeRu::RuSpec ru1(ruType, 1, true);
523  txVector.SetRu(ru1, rxStaId1);
524  txVector.SetMode(HePhy::GetHeMcs7(), rxStaId1);
525  txVector.SetNss(1, rxStaId1);
526 
527  HeRu::RuSpec ru2(ruType, (m_channelWidth == 160 ? 1 : 2), m_channelWidth != 160);
528  txVector.SetRu(ru2, rxStaId2);
529  txVector.SetMode(HePhy::GetHeMcs9(), rxStaId2);
530  txVector.SetNss(1, rxStaId2);
531 
532  Ptr<Packet> pkt1 = Create<Packet>(1000);
533  WifiMacHeader hdr1;
534  hdr1.SetType(WIFI_MAC_QOSDATA);
535  hdr1.SetQosTid(0);
536  hdr1.SetAddr1(Mac48Address("00:00:00:00:00:01"));
537  hdr1.SetSequenceNumber(1);
538  Ptr<WifiPsdu> psdu1 = Create<WifiPsdu>(pkt1, hdr1);
539  psdus.insert(std::make_pair(rxStaId1, psdu1));
540 
541  Ptr<Packet> pkt2 = Create<Packet>(1500);
542  WifiMacHeader hdr2;
543  hdr2.SetType(WIFI_MAC_QOSDATA);
544  hdr2.SetQosTid(0);
545  hdr2.SetAddr1(Mac48Address("00:00:00:00:00:02"));
546  hdr2.SetSequenceNumber(2);
547  Ptr<WifiPsdu> psdu2 = Create<WifiPsdu>(pkt2, hdr2);
548  psdus.insert(std::make_pair(rxStaId2, psdu2));
549 
550  m_phyAp->Send(psdus, txVector);
551 }
552 
553 void
554 TestDlOfdmaPhyTransmission::GenerateInterference(Ptr<SpectrumValue> interferencePsd, Time duration)
555 {
556  m_phyInterferer->SetTxPowerSpectralDensity(interferencePsd);
557  m_phyInterferer->SetPeriod(duration);
558  m_phyInterferer->Start();
559  Simulator::Schedule(duration, &TestDlOfdmaPhyTransmission::StopInterference, this);
560 }
561 
562 void
563 TestDlOfdmaPhyTransmission::StopInterference()
564 {
565  m_phyInterferer->Stop();
566 }
567 
568 TestDlOfdmaPhyTransmission::~TestDlOfdmaPhyTransmission()
569 {
570 }
571 
572 void
573 TestDlOfdmaPhyTransmission::RxSuccessSta1(Ptr<const WifiPsdu> psdu,
574  RxSignalInfo rxSignalInfo,
575  WifiTxVector txVector,
576  std::vector<bool> /*statusPerMpdu*/)
577 {
578  NS_LOG_FUNCTION(this << *psdu << rxSignalInfo << txVector);
579  m_countRxSuccessSta1++;
580  m_countRxBytesSta1 += (psdu->GetSize() - 30);
581 }
582 
583 void
584 TestDlOfdmaPhyTransmission::RxSuccessSta2(Ptr<const WifiPsdu> psdu,
585  RxSignalInfo rxSignalInfo,
586  WifiTxVector txVector,
587  std::vector<bool> /*statusPerMpdu*/)
588 {
589  NS_LOG_FUNCTION(this << *psdu << rxSignalInfo << txVector);
590  m_countRxSuccessSta2++;
591  m_countRxBytesSta2 += (psdu->GetSize() - 30);
592 }
593 
594 void
595 TestDlOfdmaPhyTransmission::RxSuccessSta3(Ptr<const WifiPsdu> psdu,
596  RxSignalInfo rxSignalInfo,
597  WifiTxVector txVector,
598  std::vector<bool> /*statusPerMpdu*/)
599 {
600  NS_LOG_FUNCTION(this << *psdu << rxSignalInfo << txVector);
601  m_countRxSuccessSta3++;
602  m_countRxBytesSta3 += (psdu->GetSize() - 30);
603 }
604 
605 void
606 TestDlOfdmaPhyTransmission::RxFailureSta1(Ptr<const WifiPsdu> psdu)
607 {
608  NS_LOG_FUNCTION(this << *psdu);
609  m_countRxFailureSta1++;
610 }
611 
612 void
613 TestDlOfdmaPhyTransmission::RxFailureSta2(Ptr<const WifiPsdu> psdu)
614 {
615  NS_LOG_FUNCTION(this << *psdu);
616  m_countRxFailureSta2++;
617 }
618 
619 void
620 TestDlOfdmaPhyTransmission::RxFailureSta3(Ptr<const WifiPsdu> psdu)
621 {
622  NS_LOG_FUNCTION(this << *psdu);
623  m_countRxFailureSta3++;
624 }
625 
626 void
627 TestDlOfdmaPhyTransmission::CheckResultsSta1(uint32_t expectedRxSuccess,
628  uint32_t expectedRxFailure,
629  uint32_t expectedRxBytes)
630 {
631  NS_TEST_ASSERT_MSG_EQ(m_countRxSuccessSta1,
632  expectedRxSuccess,
633  "The number of successfully received packets by STA 1 is not correct!");
634  NS_TEST_ASSERT_MSG_EQ(m_countRxFailureSta1,
635  expectedRxFailure,
636  "The number of unsuccessfuly received packets by STA 1 is not correct!");
637  NS_TEST_ASSERT_MSG_EQ(m_countRxBytesSta1,
638  expectedRxBytes,
639  "The number of bytes received by STA 1 is not correct!");
640 }
641 
642 void
643 TestDlOfdmaPhyTransmission::CheckResultsSta2(uint32_t expectedRxSuccess,
644  uint32_t expectedRxFailure,
645  uint32_t expectedRxBytes)
646 {
647  NS_TEST_ASSERT_MSG_EQ(m_countRxSuccessSta2,
648  expectedRxSuccess,
649  "The number of successfully received packets by STA 2 is not correct!");
650  NS_TEST_ASSERT_MSG_EQ(m_countRxFailureSta2,
651  expectedRxFailure,
652  "The number of unsuccessfuly received packets by STA 2 is not correct!");
653  NS_TEST_ASSERT_MSG_EQ(m_countRxBytesSta2,
654  expectedRxBytes,
655  "The number of bytes received by STA 2 is not correct!");
656 }
657 
658 void
659 TestDlOfdmaPhyTransmission::CheckResultsSta3(uint32_t expectedRxSuccess,
660  uint32_t expectedRxFailure,
661  uint32_t expectedRxBytes)
662 {
663  NS_TEST_ASSERT_MSG_EQ(m_countRxSuccessSta3,
664  expectedRxSuccess,
665  "The number of successfully received packets by STA 3 is not correct!");
666  NS_TEST_ASSERT_MSG_EQ(m_countRxFailureSta3,
667  expectedRxFailure,
668  "The number of unsuccessfuly received packets by STA 3 is not correct!");
669  NS_TEST_ASSERT_MSG_EQ(m_countRxBytesSta3,
670  expectedRxBytes,
671  "The number of bytes received by STA 3 is not correct!");
672 }
673 
674 void
675 TestDlOfdmaPhyTransmission::CheckPhyState(Ptr<OfdmaSpectrumWifiPhy> phy, WifiPhyState expectedState)
676 {
677  // This is needed to make sure PHY state will be checked as the last event if a state change
678  // occurred at the exact same time as the check
679  Simulator::ScheduleNow(&TestDlOfdmaPhyTransmission::DoCheckPhyState, this, phy, expectedState);
680 }
681 
682 void
683 TestDlOfdmaPhyTransmission::DoCheckPhyState(Ptr<OfdmaSpectrumWifiPhy> phy,
684  WifiPhyState expectedState)
685 {
686  WifiPhyState currentState;
687  PointerValue ptr;
688  phy->GetAttribute("State", ptr);
689  Ptr<WifiPhyStateHelper> state = DynamicCast<WifiPhyStateHelper>(ptr.Get<WifiPhyStateHelper>());
690  currentState = state->GetState();
691  NS_LOG_FUNCTION(this << currentState);
692  NS_TEST_ASSERT_MSG_EQ(currentState,
693  expectedState,
694  "PHY State " << currentState << " does not match expected state "
695  << expectedState << " at " << Simulator::Now());
696 }
697 
698 void
699 TestDlOfdmaPhyTransmission::DoSetup()
700 {
701  Ptr<MultiModelSpectrumChannel> spectrumChannel = CreateObject<MultiModelSpectrumChannel>();
702  Ptr<FriisPropagationLossModel> lossModel = CreateObject<FriisPropagationLossModel>();
703  lossModel->SetFrequency(m_frequency * 1e6);
704  spectrumChannel->AddPropagationLossModel(lossModel);
705  Ptr<ConstantSpeedPropagationDelayModel> delayModel =
706  CreateObject<ConstantSpeedPropagationDelayModel>();
707  spectrumChannel->SetPropagationDelayModel(delayModel);
708 
709  Ptr<Node> apNode = CreateObject<Node>();
710  Ptr<WifiNetDevice> apDev = CreateObject<WifiNetDevice>();
711  m_phyAp = CreateObject<SpectrumWifiPhy>();
712  m_phyAp->CreateWifiSpectrumPhyInterface(apDev);
713  m_phyAp->ConfigureStandard(WIFI_STANDARD_80211ax);
714  Ptr<InterferenceHelper> apInterferenceHelper = CreateObject<InterferenceHelper>();
715  m_phyAp->SetInterferenceHelper(apInterferenceHelper);
716  Ptr<ErrorRateModel> apErrorModel = CreateObject<NistErrorRateModel>();
717  m_phyAp->SetErrorRateModel(apErrorModel);
718  m_phyAp->SetDevice(apDev);
719  m_phyAp->SetChannel(spectrumChannel);
720  Ptr<ConstantPositionMobilityModel> apMobility = CreateObject<ConstantPositionMobilityModel>();
721  m_phyAp->SetMobility(apMobility);
722  apDev->SetPhy(m_phyAp);
723  apNode->AggregateObject(apMobility);
724  apNode->AddDevice(apDev);
725 
726  Ptr<Node> sta1Node = CreateObject<Node>();
727  Ptr<WifiNetDevice> sta1Dev = CreateObject<WifiNetDevice>();
728  m_phySta1 = CreateObject<OfdmaSpectrumWifiPhy>(1);
729  m_phySta1->CreateWifiSpectrumPhyInterface(sta1Dev);
730  m_phySta1->ConfigureStandard(WIFI_STANDARD_80211ax);
731  Ptr<InterferenceHelper> sta1InterferenceHelper = CreateObject<InterferenceHelper>();
732  m_phySta1->SetInterferenceHelper(sta1InterferenceHelper);
733  Ptr<ErrorRateModel> sta1ErrorModel = CreateObject<NistErrorRateModel>();
734  m_phySta1->SetErrorRateModel(sta1ErrorModel);
735  m_phySta1->SetDevice(sta1Dev);
736  m_phySta1->SetChannel(spectrumChannel);
737  m_phySta1->SetReceiveOkCallback(MakeCallback(&TestDlOfdmaPhyTransmission::RxSuccessSta1, this));
738  m_phySta1->SetReceiveErrorCallback(
739  MakeCallback(&TestDlOfdmaPhyTransmission::RxFailureSta1, this));
740  Ptr<ConstantPositionMobilityModel> sta1Mobility = CreateObject<ConstantPositionMobilityModel>();
741  m_phySta1->SetMobility(sta1Mobility);
742  sta1Dev->SetPhy(m_phySta1);
743  sta1Node->AggregateObject(sta1Mobility);
744  sta1Node->AddDevice(sta1Dev);
745 
746  Ptr<Node> sta2Node = CreateObject<Node>();
747  Ptr<WifiNetDevice> sta2Dev = CreateObject<WifiNetDevice>();
748  m_phySta2 = CreateObject<OfdmaSpectrumWifiPhy>(2);
749  m_phySta2->CreateWifiSpectrumPhyInterface(sta2Dev);
750  m_phySta2->ConfigureStandard(WIFI_STANDARD_80211ax);
751  Ptr<InterferenceHelper> sta2InterferenceHelper = CreateObject<InterferenceHelper>();
752  m_phySta2->SetInterferenceHelper(sta2InterferenceHelper);
753  Ptr<ErrorRateModel> sta2ErrorModel = CreateObject<NistErrorRateModel>();
754  m_phySta2->SetErrorRateModel(sta2ErrorModel);
755  m_phySta2->SetDevice(sta2Dev);
756  m_phySta2->SetChannel(spectrumChannel);
757  m_phySta2->SetReceiveOkCallback(MakeCallback(&TestDlOfdmaPhyTransmission::RxSuccessSta2, this));
758  m_phySta2->SetReceiveErrorCallback(
759  MakeCallback(&TestDlOfdmaPhyTransmission::RxFailureSta2, this));
760  Ptr<ConstantPositionMobilityModel> sta2Mobility = CreateObject<ConstantPositionMobilityModel>();
761  m_phySta2->SetMobility(sta2Mobility);
762  sta2Dev->SetPhy(m_phySta2);
763  sta2Node->AggregateObject(sta2Mobility);
764  sta2Node->AddDevice(sta2Dev);
765 
766  Ptr<Node> sta3Node = CreateObject<Node>();
767  Ptr<WifiNetDevice> sta3Dev = CreateObject<WifiNetDevice>();
768  m_phySta3 = CreateObject<OfdmaSpectrumWifiPhy>(3);
769  m_phySta3->CreateWifiSpectrumPhyInterface(sta3Dev);
770  m_phySta3->ConfigureStandard(WIFI_STANDARD_80211ax);
771  Ptr<InterferenceHelper> sta3InterferenceHelper = CreateObject<InterferenceHelper>();
772  m_phySta3->SetInterferenceHelper(sta3InterferenceHelper);
773  Ptr<ErrorRateModel> sta3ErrorModel = CreateObject<NistErrorRateModel>();
774  m_phySta3->SetErrorRateModel(sta3ErrorModel);
775  m_phySta3->SetDevice(sta3Dev);
776  m_phySta3->SetChannel(spectrumChannel);
777  m_phySta3->SetReceiveOkCallback(MakeCallback(&TestDlOfdmaPhyTransmission::RxSuccessSta3, this));
778  m_phySta3->SetReceiveErrorCallback(
779  MakeCallback(&TestDlOfdmaPhyTransmission::RxFailureSta3, this));
780  Ptr<ConstantPositionMobilityModel> sta3Mobility = CreateObject<ConstantPositionMobilityModel>();
781  m_phySta3->SetMobility(sta3Mobility);
782  sta3Dev->SetPhy(m_phySta3);
783  sta3Node->AggregateObject(sta3Mobility);
784  sta3Node->AddDevice(sta3Dev);
785 
786  Ptr<Node> interfererNode = CreateObject<Node>();
787  Ptr<NonCommunicatingNetDevice> interfererDev = CreateObject<NonCommunicatingNetDevice>();
788  m_phyInterferer = CreateObject<WaveformGenerator>();
789  m_phyInterferer->SetDevice(interfererDev);
790  m_phyInterferer->SetChannel(spectrumChannel);
791  m_phyInterferer->SetDutyCycle(1);
792  interfererNode->AddDevice(interfererDev);
793 }
794 
795 void
796 TestDlOfdmaPhyTransmission::DoTeardown()
797 {
798  m_phyAp->Dispose();
799  m_phyAp = nullptr;
800  m_phySta1->Dispose();
801  m_phySta1 = nullptr;
802  m_phySta2->Dispose();
803  m_phySta2 = nullptr;
804  m_phySta3->Dispose();
805  m_phySta3 = nullptr;
806  m_phyInterferer->Dispose();
807  m_phyInterferer = nullptr;
808 }
809 
810 void
811 TestDlOfdmaPhyTransmission::RunOne()
812 {
813  RngSeedManager::SetSeed(1);
814  RngSeedManager::SetRun(1);
815  int64_t streamNumber = 0;
816  m_phyAp->AssignStreams(streamNumber);
817  m_phySta1->AssignStreams(streamNumber);
818  m_phySta2->AssignStreams(streamNumber);
819  m_phySta3->AssignStreams(streamNumber);
820 
821  auto channelNum = std::get<0>(*WifiPhyOperatingChannel::FindFirst(0,
822  m_frequency,
823  m_channelWidth,
824  WIFI_STANDARD_80211ax,
825  WIFI_PHY_BAND_5GHZ));
826 
827  m_phyAp->SetOperatingChannel(
828  WifiPhy::ChannelTuple{channelNum, m_channelWidth, (int)(WIFI_PHY_BAND_5GHZ), 0});
829  m_phySta1->SetOperatingChannel(
830  WifiPhy::ChannelTuple{channelNum, m_channelWidth, (int)(WIFI_PHY_BAND_5GHZ), 0});
831  m_phySta2->SetOperatingChannel(
832  WifiPhy::ChannelTuple{channelNum, m_channelWidth, (int)(WIFI_PHY_BAND_5GHZ), 0});
833  m_phySta3->SetOperatingChannel(
834  WifiPhy::ChannelTuple{channelNum, m_channelWidth, (int)(WIFI_PHY_BAND_5GHZ), 0});
835 
836  Simulator::Schedule(Seconds(0.5), &TestDlOfdmaPhyTransmission::ResetResults, this);
837 
838  // Send MU PPDU with two PSDUs addressed to STA 1 and STA 2:
839  // Each STA should receive its PSDU.
840  Simulator::Schedule(Seconds(1.0), &TestDlOfdmaPhyTransmission::SendMuPpdu, this, 1, 2);
841 
842  // Since it takes m_expectedPpduDuration to transmit the PPDU,
843  // all 3 PHYs should be back to IDLE at the same time,
844  // even the PHY that has no PSDU addressed to it.
845  Simulator::Schedule(Seconds(1.0) + m_expectedPpduDuration - NanoSeconds(1),
846  &TestDlOfdmaPhyTransmission::CheckPhyState,
847  this,
848  m_phySta1,
849  WifiPhyState::RX);
850  Simulator::Schedule(Seconds(1.0) + m_expectedPpduDuration - NanoSeconds(1),
851  &TestDlOfdmaPhyTransmission::CheckPhyState,
852  this,
853  m_phySta2,
854  WifiPhyState::RX);
855  Simulator::Schedule(Seconds(1.0) + m_expectedPpduDuration - NanoSeconds(1),
856  &TestDlOfdmaPhyTransmission::CheckPhyState,
857  this,
858  m_phySta3,
859  WifiPhyState::CCA_BUSY);
860  Simulator::Schedule(Seconds(1.0) + m_expectedPpduDuration,
861  &TestDlOfdmaPhyTransmission::CheckPhyState,
862  this,
863  m_phySta1,
864  WifiPhyState::IDLE);
865  Simulator::Schedule(Seconds(1.0) + m_expectedPpduDuration,
866  &TestDlOfdmaPhyTransmission::CheckPhyState,
867  this,
868  m_phySta2,
869  WifiPhyState::IDLE);
870  Simulator::Schedule(Seconds(1.0) + m_expectedPpduDuration,
871  &TestDlOfdmaPhyTransmission::CheckPhyState,
872  this,
873  m_phySta3,
874  WifiPhyState::IDLE);
875 
876  // One PSDU of 1000 bytes should have been successfully received by STA 1
877  Simulator::Schedule(Seconds(1.1),
878  &TestDlOfdmaPhyTransmission::CheckResultsSta1,
879  this,
880  1,
881  0,
882  1000);
883  // One PSDU of 1500 bytes should have been successfully received by STA 2
884  Simulator::Schedule(Seconds(1.1),
885  &TestDlOfdmaPhyTransmission::CheckResultsSta2,
886  this,
887  1,
888  0,
889  1500);
890  // No PSDU should have been received by STA 3
891  Simulator::Schedule(Seconds(1.1), &TestDlOfdmaPhyTransmission::CheckResultsSta3, this, 0, 0, 0);
892 
893  Simulator::Schedule(Seconds(1.5), &TestDlOfdmaPhyTransmission::ResetResults, this);
894 
895  // Send MU PPDU with two PSDUs addressed to STA 1 and STA 3:
896  // STA 1 should receive its PSDU, whereas STA 2 should not receive any PSDU
897  // but should keep its PHY busy during all PPDU duration.
898  Simulator::Schedule(Seconds(2.0), &TestDlOfdmaPhyTransmission::SendMuPpdu, this, 1, 3);
899 
900  // Since it takes m_expectedPpduDuration to transmit the PPDU,
901  // all 3 PHYs should be back to IDLE at the same time,
902  // even the PHY that has no PSDU addressed to it.
903  Simulator::Schedule(Seconds(2.0) + m_expectedPpduDuration - NanoSeconds(1),
904  &TestDlOfdmaPhyTransmission::CheckPhyState,
905  this,
906  m_phySta1,
907  WifiPhyState::RX);
908  Simulator::Schedule(Seconds(2.0) + m_expectedPpduDuration - NanoSeconds(1),
909  &TestDlOfdmaPhyTransmission::CheckPhyState,
910  this,
911  m_phySta2,
912  WifiPhyState::CCA_BUSY);
913  Simulator::Schedule(Seconds(2.0) + m_expectedPpduDuration - NanoSeconds(1),
914  &TestDlOfdmaPhyTransmission::CheckPhyState,
915  this,
916  m_phySta3,
917  WifiPhyState::RX);
918  Simulator::Schedule(Seconds(2.0) + m_expectedPpduDuration,
919  &TestDlOfdmaPhyTransmission::CheckPhyState,
920  this,
921  m_phySta1,
922  WifiPhyState::IDLE);
923  Simulator::Schedule(Seconds(2.0) + m_expectedPpduDuration,
924  &TestDlOfdmaPhyTransmission::CheckPhyState,
925  this,
926  m_phySta2,
927  WifiPhyState::IDLE);
928  Simulator::Schedule(Seconds(2.0) + m_expectedPpduDuration,
929  &TestDlOfdmaPhyTransmission::CheckPhyState,
930  this,
931  m_phySta3,
932  WifiPhyState::IDLE);
933 
934  // One PSDU of 1000 bytes should have been successfully received by STA 1
935  Simulator::Schedule(Seconds(2.1),
936  &TestDlOfdmaPhyTransmission::CheckResultsSta1,
937  this,
938  1,
939  0,
940  1000);
941  // No PSDU should have been received by STA 2
942  Simulator::Schedule(Seconds(2.1), &TestDlOfdmaPhyTransmission::CheckResultsSta2, this, 0, 0, 0);
943  // One PSDU of 1500 bytes should have been successfully received by STA 3
944  Simulator::Schedule(Seconds(2.1),
945  &TestDlOfdmaPhyTransmission::CheckResultsSta3,
946  this,
947  1,
948  0,
949  1500);
950 
951  Simulator::Schedule(Seconds(2.5), &TestDlOfdmaPhyTransmission::ResetResults, this);
952 
953  // Send MU PPDU with two PSDUs addressed to STA 1 and STA 2:
954  Simulator::Schedule(Seconds(3.0), &TestDlOfdmaPhyTransmission::SendMuPpdu, this, 1, 2);
955 
956  // A strong non-wifi interference is generated on RU 1 during PSDU reception
957  BandInfo bandInfo;
958  bandInfo.fc = (m_frequency - (m_channelWidth / 4)) * 1e6;
959  bandInfo.fl = bandInfo.fc - ((m_channelWidth / 4) * 1e6);
960  bandInfo.fh = bandInfo.fc + ((m_channelWidth / 4) * 1e6);
961  Bands bands;
962  bands.push_back(bandInfo);
963 
964  Ptr<SpectrumModel> SpectrumInterferenceRu1 = Create<SpectrumModel>(bands);
965  Ptr<SpectrumValue> interferencePsdRu1 = Create<SpectrumValue>(SpectrumInterferenceRu1);
966  double interferencePower = 0.1; // watts
967  *interferencePsdRu1 = interferencePower / ((m_channelWidth / 2) * 20e6);
968 
969  Simulator::Schedule(Seconds(3.0) + MicroSeconds(50),
970  &TestDlOfdmaPhyTransmission::GenerateInterference,
971  this,
972  interferencePsdRu1,
973  MilliSeconds(100));
974 
975  // Since it takes m_expectedPpduDuration to transmit the PPDU,
976  // both PHYs should be back to CCA_BUSY (due to the interference) at the same time,
977  // even the PHY that has no PSDU addressed to it.
978  Simulator::Schedule(Seconds(3.0) + m_expectedPpduDuration - NanoSeconds(1),
979  &TestDlOfdmaPhyTransmission::CheckPhyState,
980  this,
981  m_phySta1,
982  WifiPhyState::RX);
983  Simulator::Schedule(Seconds(3.0) + m_expectedPpduDuration - NanoSeconds(1),
984  &TestDlOfdmaPhyTransmission::CheckPhyState,
985  this,
986  m_phySta2,
987  WifiPhyState::RX);
988  Simulator::Schedule(Seconds(3.0) + m_expectedPpduDuration - NanoSeconds(1),
989  &TestDlOfdmaPhyTransmission::CheckPhyState,
990  this,
991  m_phySta3,
992  WifiPhyState::CCA_BUSY);
993  Simulator::Schedule(Seconds(3.0) + m_expectedPpduDuration,
994  &TestDlOfdmaPhyTransmission::CheckPhyState,
995  this,
996  m_phySta1,
997  WifiPhyState::CCA_BUSY);
998  Simulator::Schedule(Seconds(3.0) + m_expectedPpduDuration,
999  &TestDlOfdmaPhyTransmission::CheckPhyState,
1000  this,
1001  m_phySta2,
1002  WifiPhyState::CCA_BUSY);
1003  Simulator::Schedule(Seconds(3.0) + m_expectedPpduDuration,
1004  &TestDlOfdmaPhyTransmission::CheckPhyState,
1005  this,
1006  m_phySta3,
1007  WifiPhyState::CCA_BUSY);
1008 
1009  // One PSDU of 1000 bytes should have been unsuccessfuly received by STA 1 (since interference
1010  // occupies RU 1)
1011  Simulator::Schedule(Seconds(3.1), &TestDlOfdmaPhyTransmission::CheckResultsSta1, this, 0, 1, 0);
1012  // One PSDU of 1500 bytes should have been successfully received by STA 2
1013  Simulator::Schedule(Seconds(3.1),
1014  &TestDlOfdmaPhyTransmission::CheckResultsSta2,
1015  this,
1016  1,
1017  0,
1018  1500);
1019  // No PSDU should have been received by STA3
1020  Simulator::Schedule(Seconds(3.1), &TestDlOfdmaPhyTransmission::CheckResultsSta3, this, 0, 0, 0);
1021 
1022  Simulator::Schedule(Seconds(3.5), &TestDlOfdmaPhyTransmission::ResetResults, this);
1023 
1024  // Send MU PPDU with two PSDUs addressed to STA 1 and STA 2:
1025  Simulator::Schedule(Seconds(4.0), &TestDlOfdmaPhyTransmission::SendMuPpdu, this, 1, 2);
1026 
1027  // A strong non-wifi interference is generated on RU 2 during PSDU reception
1028  bandInfo.fc = (m_frequency + (m_channelWidth / 4)) * 1e6;
1029  bandInfo.fl = bandInfo.fc - ((m_channelWidth / 4) * 1e6);
1030  bandInfo.fh = bandInfo.fc + ((m_channelWidth / 4) * 1e6);
1031  bands.clear();
1032  bands.push_back(bandInfo);
1033 
1034  Ptr<SpectrumModel> SpectrumInterferenceRu2 = Create<SpectrumModel>(bands);
1035  Ptr<SpectrumValue> interferencePsdRu2 = Create<SpectrumValue>(SpectrumInterferenceRu2);
1036  *interferencePsdRu2 = interferencePower / ((m_channelWidth / 2) * 20e6);
1037 
1038  Simulator::Schedule(Seconds(4.0) + MicroSeconds(50),
1039  &TestDlOfdmaPhyTransmission::GenerateInterference,
1040  this,
1041  interferencePsdRu2,
1042  MilliSeconds(100));
1043 
1044  // Since it takes m_expectedPpduDuration to transmit the PPDU,
1045  // both PHYs should be back to IDLE (or CCA_BUSY if interference on the primary 20 MHz) at the
1046  // same time, even the PHY that has no PSDU addressed to it.
1047  Simulator::Schedule(Seconds(4.0) + m_expectedPpduDuration - NanoSeconds(1),
1048  &TestDlOfdmaPhyTransmission::CheckPhyState,
1049  this,
1050  m_phySta1,
1051  WifiPhyState::RX);
1052  Simulator::Schedule(Seconds(4.0) + m_expectedPpduDuration - NanoSeconds(1),
1053  &TestDlOfdmaPhyTransmission::CheckPhyState,
1054  this,
1055  m_phySta2,
1056  WifiPhyState::RX);
1057  Simulator::Schedule(Seconds(4.0) + m_expectedPpduDuration - NanoSeconds(1),
1058  &TestDlOfdmaPhyTransmission::CheckPhyState,
1059  this,
1060  m_phySta3,
1061  WifiPhyState::CCA_BUSY);
1062  Simulator::Schedule(Seconds(4.0) + m_expectedPpduDuration,
1063  &TestDlOfdmaPhyTransmission::CheckPhyState,
1064  this,
1065  m_phySta1,
1066  (m_channelWidth >= 40) ? WifiPhyState::IDLE : WifiPhyState::CCA_BUSY);
1067  Simulator::Schedule(Seconds(4.0) + m_expectedPpduDuration,
1068  &TestDlOfdmaPhyTransmission::CheckPhyState,
1069  this,
1070  m_phySta2,
1071  (m_channelWidth >= 40) ? WifiPhyState::IDLE : WifiPhyState::CCA_BUSY);
1072  Simulator::Schedule(Seconds(4.0) + m_expectedPpduDuration,
1073  &TestDlOfdmaPhyTransmission::CheckPhyState,
1074  this,
1075  m_phySta3,
1076  (m_channelWidth >= 40) ? WifiPhyState::IDLE : WifiPhyState::CCA_BUSY);
1077 
1078  // One PSDU of 1000 bytes should have been successfully received by STA 1
1079  Simulator::Schedule(Seconds(4.1),
1080  &TestDlOfdmaPhyTransmission::CheckResultsSta1,
1081  this,
1082  1,
1083  0,
1084  1000);
1085  // One PSDU of 1500 bytes should have been unsuccessfuly received by STA 2 (since interference
1086  // occupies RU 2)
1087  Simulator::Schedule(Seconds(4.1), &TestDlOfdmaPhyTransmission::CheckResultsSta2, this, 0, 1, 0);
1088  // No PSDU should have been received by STA3
1089  Simulator::Schedule(Seconds(4.1), &TestDlOfdmaPhyTransmission::CheckResultsSta3, this, 0, 0, 0);
1090 
1091  Simulator::Schedule(Seconds(4.5), &TestDlOfdmaPhyTransmission::ResetResults, this);
1092 
1093  // Send MU PPDU with two PSDUs addressed to STA 1 and STA 2:
1094  Simulator::Schedule(Seconds(5.0), &TestDlOfdmaPhyTransmission::SendMuPpdu, this, 1, 2);
1095 
1096  // A strong non-wifi interference is generated on the full band during PSDU reception
1097  bandInfo.fc = m_frequency * 1e6;
1098  bandInfo.fl = bandInfo.fc - ((m_channelWidth / 2) * 1e6);
1099  bandInfo.fh = bandInfo.fc + ((m_channelWidth / 2) * 1e6);
1100  bands.clear();
1101  bands.push_back(bandInfo);
1102 
1103  Ptr<SpectrumModel> SpectrumInterferenceAll = Create<SpectrumModel>(bands);
1104  Ptr<SpectrumValue> interferencePsdAll = Create<SpectrumValue>(SpectrumInterferenceAll);
1105  *interferencePsdAll = interferencePower / (m_channelWidth * 20e6);
1106 
1107  Simulator::Schedule(Seconds(5.0) + MicroSeconds(50),
1108  &TestDlOfdmaPhyTransmission::GenerateInterference,
1109  this,
1110  interferencePsdAll,
1111  MilliSeconds(100));
1112 
1113  // Since it takes m_expectedPpduDuration to transmit the PPDU,
1114  // both PHYs should be back to CCA_BUSY (due to the interference) at the same time,
1115  // even the PHY that has no PSDU addressed to it.
1116  Simulator::Schedule(Seconds(5.0) + m_expectedPpduDuration - NanoSeconds(1),
1117  &TestDlOfdmaPhyTransmission::CheckPhyState,
1118  this,
1119  m_phySta1,
1120  WifiPhyState::RX);
1121  Simulator::Schedule(Seconds(5.0) + m_expectedPpduDuration - NanoSeconds(1),
1122  &TestDlOfdmaPhyTransmission::CheckPhyState,
1123  this,
1124  m_phySta2,
1125  WifiPhyState::RX);
1126  Simulator::Schedule(Seconds(5.0) + m_expectedPpduDuration - NanoSeconds(1),
1127  &TestDlOfdmaPhyTransmission::CheckPhyState,
1128  this,
1129  m_phySta3,
1130  WifiPhyState::CCA_BUSY);
1131  Simulator::Schedule(Seconds(5.0) + m_expectedPpduDuration,
1132  &TestDlOfdmaPhyTransmission::CheckPhyState,
1133  this,
1134  m_phySta1,
1135  WifiPhyState::CCA_BUSY);
1136  Simulator::Schedule(Seconds(5.0) + m_expectedPpduDuration,
1137  &TestDlOfdmaPhyTransmission::CheckPhyState,
1138  this,
1139  m_phySta2,
1140  WifiPhyState::CCA_BUSY);
1141  Simulator::Schedule(Seconds(5.0) + m_expectedPpduDuration,
1142  &TestDlOfdmaPhyTransmission::CheckPhyState,
1143  this,
1144  m_phySta3,
1145  WifiPhyState::CCA_BUSY);
1146 
1147  // One PSDU of 1000 bytes should have been unsuccessfuly received by STA 1 (since interference
1148  // occupies RU 1)
1149  Simulator::Schedule(Seconds(5.1), &TestDlOfdmaPhyTransmission::CheckResultsSta1, this, 0, 1, 0);
1150  // One PSDU of 1500 bytes should have been unsuccessfuly received by STA 2 (since interference
1151  // occupies RU 2)
1152  Simulator::Schedule(Seconds(5.1), &TestDlOfdmaPhyTransmission::CheckResultsSta2, this, 0, 1, 0);
1153  // No PSDU should have been received by STA3
1154  Simulator::Schedule(Seconds(5.1), &TestDlOfdmaPhyTransmission::CheckResultsSta3, this, 0, 0, 0);
1155 
1156  Simulator::Schedule(Seconds(5.5), &TestDlOfdmaPhyTransmission::ResetResults, this);
1157 
1158  Simulator::Run();
1159 }
1160 
1161 void
1162 TestDlOfdmaPhyTransmission::DoRun()
1163 {
1164  m_frequency = 5180;
1165  m_channelWidth = 20;
1166  m_expectedPpduDuration = NanoSeconds(306400);
1167  RunOne();
1168 
1169  m_frequency = 5190;
1170  m_channelWidth = 40;
1171  m_expectedPpduDuration = NanoSeconds(156800);
1172  RunOne();
1173 
1174  m_frequency = 5210;
1175  m_channelWidth = 80;
1176  m_expectedPpduDuration = NanoSeconds(102400);
1177  RunOne();
1178 
1179  m_frequency = 5250;
1180  m_channelWidth = 160;
1181  m_expectedPpduDuration = NanoSeconds(75200);
1182  RunOne();
1183 
1184  Simulator::Destroy();
1185 }
1186 
1193 class TestDlOfdmaPhyPuncturing : public TestCase
1194 {
1195  public:
1196  TestDlOfdmaPhyPuncturing();
1197 
1198  private:
1199  void DoSetup() override;
1200  void DoTeardown() override;
1201  void DoRun() override;
1202 
1210  void RxSuccessSta1(Ptr<const WifiPsdu> psdu,
1211  RxSignalInfo rxSignalInfo,
1212  WifiTxVector txVector,
1213  const std::vector<bool> statusPerMpdu);
1214 
1222  void RxSuccessSta2(Ptr<const WifiPsdu> psdu,
1223  RxSignalInfo rxSignalInfo,
1224  WifiTxVector txVector,
1225  std::vector<bool> statusPerMpdu);
1226 
1231  void RxFailureSta1(Ptr<const WifiPsdu> psdu);
1232 
1237  void RxFailureSta2(Ptr<const WifiPsdu> psdu);
1238 
1245  void CheckResultsSta1(uint32_t expectedRxSuccess,
1246  uint32_t expectedRxFailure,
1247  uint32_t expectedRxBytes);
1248 
1255  void CheckResultsSta2(uint32_t expectedRxSuccess,
1256  uint32_t expectedRxFailure,
1257  uint32_t expectedRxBytes);
1258 
1262  void ResetResults();
1263 
1271  void SendMuPpdu(uint16_t rxStaId1,
1272  uint16_t rxStaId2,
1273  const std::vector<bool>& puncturedSubchannels);
1274 
1280  void GenerateInterference(Ptr<SpectrumValue> interferencePsd, Time duration);
1281 
1285  void StopInterference();
1286 
1290  void RunOne();
1291 
1297  void CheckPhyState(Ptr<OfdmaSpectrumWifiPhy> phy, WifiPhyState expectedState);
1298 
1304  void DoCheckPhyState(Ptr<OfdmaSpectrumWifiPhy> phy, WifiPhyState expectedState);
1305 
1306  uint32_t m_countRxSuccessSta1;
1307  uint32_t m_countRxSuccessSta2;
1308  uint32_t m_countRxFailureSta1;
1309  uint32_t m_countRxFailureSta2;
1310  uint32_t m_countRxBytesSta1;
1311  uint32_t m_countRxBytesSta2;
1312 
1313  Ptr<SpectrumWifiPhy> m_phyAp;
1314  Ptr<OfdmaSpectrumWifiPhy> m_phySta1;
1315  Ptr<OfdmaSpectrumWifiPhy> m_phySta2;
1316  Ptr<WaveformGenerator> m_phyInterferer;
1317 
1318  uint16_t m_frequency;
1319  uint16_t m_channelWidth;
1320 
1321  uint8_t m_indexSubchannel;
1323 
1324  Time m_expectedPpduDuration20Mhz;
1325  Time m_expectedPpduDuration40Mhz;
1326 };
1327 
1328 TestDlOfdmaPhyPuncturing::TestDlOfdmaPhyPuncturing()
1329  : TestCase("DL-OFDMA PHY puncturing test"),
1330  m_countRxSuccessSta1(0),
1331  m_countRxSuccessSta2(0),
1332  m_countRxFailureSta1(0),
1333  m_countRxFailureSta2(0),
1334  m_countRxBytesSta1(0),
1335  m_countRxBytesSta2(0),
1336  m_frequency(5210),
1337  m_channelWidth(80),
1338  m_indexSubchannel(0),
1339  m_expectedPpduDuration20Mhz(NanoSeconds(156800)),
1340  m_expectedPpduDuration40Mhz(NanoSeconds(102400))
1341 {
1342 }
1343 
1344 void
1345 TestDlOfdmaPhyPuncturing::ResetResults()
1346 {
1347  m_countRxSuccessSta1 = 0;
1348  m_countRxSuccessSta2 = 0;
1349  m_countRxFailureSta1 = 0;
1350  m_countRxFailureSta2 = 0;
1351  m_countRxBytesSta1 = 0;
1352  m_countRxBytesSta2 = 0;
1353 }
1354 
1355 void
1356 TestDlOfdmaPhyPuncturing::SendMuPpdu(uint16_t rxStaId1,
1357  uint16_t rxStaId2,
1358  const std::vector<bool>& puncturedSubchannels)
1359 {
1360  NS_LOG_FUNCTION(this << rxStaId1 << rxStaId2);
1361  WifiConstPsduMap psdus;
1362  WifiTxVector txVector = WifiTxVector(HePhy::GetHeMcs7(),
1363  0,
1364  WIFI_PREAMBLE_HE_MU,
1365  800,
1366  1,
1367  1,
1368  0,
1369  m_channelWidth,
1370  false,
1371  false);
1372 
1373  HeRu::RuType ruType =
1374  puncturedSubchannels.empty()
1375  ? HeRu::RU_484_TONE
1376  : (puncturedSubchannels.at(1) ? HeRu::RU_242_TONE : HeRu::RU_484_TONE);
1377  HeRu::RuSpec ru1(ruType, 1, true);
1378  txVector.SetRu(ru1, rxStaId1);
1379  txVector.SetMode(HePhy::GetHeMcs7(), rxStaId1);
1380  txVector.SetNss(1, rxStaId1);
1381 
1382  ruType = puncturedSubchannels.empty()
1383  ? HeRu::RU_484_TONE
1384  : (puncturedSubchannels.at(1) ? HeRu::RU_484_TONE : HeRu::RU_242_TONE);
1385  HeRu::RuSpec ru2(ruType,
1386  ruType == HeRu::RU_484_TONE ? 2 : (puncturedSubchannels.at(3) ? 3 : 4),
1387  true);
1388  txVector.SetRu(ru2, rxStaId2);
1389  txVector.SetMode(HePhy::GetHeMcs9(), rxStaId2);
1390  txVector.SetNss(1, rxStaId2);
1391 
1392  std::vector<uint8_t> ruAlloc;
1393  if (puncturedSubchannels.empty())
1394  {
1395  std::fill_n(std::back_inserter(ruAlloc), 4, 200);
1396  }
1397  else
1398  {
1399  ruAlloc.push_back(puncturedSubchannels.at(1) ? 192 : 200);
1400  ruAlloc.push_back(puncturedSubchannels.at(1) ? 113 : 200);
1401  ruAlloc.push_back(puncturedSubchannels.at(2) ? 113
1402  : (puncturedSubchannels.at(3) ? 192 : 200));
1403  ruAlloc.push_back(puncturedSubchannels.at(2) ? 192
1404  : (puncturedSubchannels.at(3) ? 113 : 200));
1405  }
1406 
1407  txVector.SetRuAllocation(ruAlloc);
1408  txVector.SetSigBMode(VhtPhy::GetVhtMcs5());
1409 
1410  Ptr<Packet> pkt1 = Create<Packet>(1000);
1411  WifiMacHeader hdr1;
1412  hdr1.SetType(WIFI_MAC_QOSDATA);
1413  hdr1.SetQosTid(0);
1414  hdr1.SetAddr1(Mac48Address("00:00:00:00:00:01"));
1415  hdr1.SetSequenceNumber(1);
1416  Ptr<WifiPsdu> psdu1 = Create<WifiPsdu>(pkt1, hdr1);
1417  psdus.insert(std::make_pair(rxStaId1, psdu1));
1418 
1419  Ptr<Packet> pkt2 = Create<Packet>(1500);
1420  WifiMacHeader hdr2;
1421  hdr2.SetType(WIFI_MAC_QOSDATA);
1422  hdr2.SetQosTid(0);
1423  hdr2.SetAddr1(Mac48Address("00:00:00:00:00:02"));
1424  hdr2.SetSequenceNumber(2);
1425  Ptr<WifiPsdu> psdu2 = Create<WifiPsdu>(pkt2, hdr2);
1426  psdus.insert(std::make_pair(rxStaId2, psdu2));
1427 
1428  if (!puncturedSubchannels.empty())
1429  {
1430  txVector.SetInactiveSubchannels(puncturedSubchannels);
1431  }
1432 
1433  m_phyAp->Send(psdus, txVector);
1434 }
1435 
1436 void
1437 TestDlOfdmaPhyPuncturing::GenerateInterference(Ptr<SpectrumValue> interferencePsd, Time duration)
1438 {
1439  NS_LOG_FUNCTION(this << duration);
1440  m_phyInterferer->SetTxPowerSpectralDensity(interferencePsd);
1441  m_phyInterferer->SetPeriod(duration);
1442  m_phyInterferer->Start();
1443  Simulator::Schedule(duration, &TestDlOfdmaPhyPuncturing::StopInterference, this);
1444 }
1445 
1446 void
1447 TestDlOfdmaPhyPuncturing::StopInterference()
1448 {
1449  NS_LOG_FUNCTION(this);
1450  m_phyInterferer->Stop();
1451 }
1452 
1453 void
1454 TestDlOfdmaPhyPuncturing::RxSuccessSta1(Ptr<const WifiPsdu> psdu,
1455  RxSignalInfo rxSignalInfo,
1456  WifiTxVector txVector,
1457  std::vector<bool> /*statusPerMpdu*/)
1458 {
1459  NS_LOG_FUNCTION(this << *psdu << rxSignalInfo << txVector);
1460  m_countRxSuccessSta1++;
1461  m_countRxBytesSta1 += (psdu->GetSize() - 30);
1462 }
1463 
1464 void
1465 TestDlOfdmaPhyPuncturing::RxSuccessSta2(Ptr<const WifiPsdu> psdu,
1466  RxSignalInfo rxSignalInfo,
1467  WifiTxVector txVector,
1468  std::vector<bool> /*statusPerMpdu*/)
1469 {
1470  NS_LOG_FUNCTION(this << *psdu << rxSignalInfo << txVector);
1471  m_countRxSuccessSta2++;
1472  m_countRxBytesSta2 += (psdu->GetSize() - 30);
1473 }
1474 
1475 void
1476 TestDlOfdmaPhyPuncturing::RxFailureSta1(Ptr<const WifiPsdu> psdu)
1477 {
1478  NS_LOG_FUNCTION(this << *psdu);
1479  m_countRxFailureSta1++;
1480 }
1481 
1482 void
1483 TestDlOfdmaPhyPuncturing::RxFailureSta2(Ptr<const WifiPsdu> psdu)
1484 {
1485  NS_LOG_FUNCTION(this << *psdu);
1486  m_countRxFailureSta2++;
1487 }
1488 
1489 void
1490 TestDlOfdmaPhyPuncturing::CheckResultsSta1(uint32_t expectedRxSuccess,
1491  uint32_t expectedRxFailure,
1492  uint32_t expectedRxBytes)
1493 {
1494  NS_TEST_ASSERT_MSG_EQ(m_countRxSuccessSta1,
1495  expectedRxSuccess,
1496  "The number of successfully received packets by STA 1 is not correct!");
1497  NS_TEST_ASSERT_MSG_EQ(m_countRxFailureSta1,
1498  expectedRxFailure,
1499  "The number of unsuccessfuly received packets by STA 1 is not correct!");
1500  NS_TEST_ASSERT_MSG_EQ(m_countRxBytesSta1,
1501  expectedRxBytes,
1502  "The number of bytes received by STA 1 is not correct!");
1503 }
1504 
1505 void
1506 TestDlOfdmaPhyPuncturing::CheckResultsSta2(uint32_t expectedRxSuccess,
1507  uint32_t expectedRxFailure,
1508  uint32_t expectedRxBytes)
1509 {
1510  NS_TEST_ASSERT_MSG_EQ(m_countRxSuccessSta2,
1511  expectedRxSuccess,
1512  "The number of successfully received packets by STA 2 is not correct!");
1513  NS_TEST_ASSERT_MSG_EQ(m_countRxFailureSta2,
1514  expectedRxFailure,
1515  "The number of unsuccessfuly received packets by STA 2 is not correct!");
1516  NS_TEST_ASSERT_MSG_EQ(m_countRxBytesSta2,
1517  expectedRxBytes,
1518  "The number of bytes received by STA 2 is not correct!");
1519 }
1520 
1521 void
1522 TestDlOfdmaPhyPuncturing::CheckPhyState(Ptr<OfdmaSpectrumWifiPhy> phy, WifiPhyState expectedState)
1523 {
1524  // This is needed to make sure PHY state will be checked as the last event if a state change
1525  // occurred at the exact same time as the check
1526  Simulator::ScheduleNow(&TestDlOfdmaPhyPuncturing::DoCheckPhyState, this, phy, expectedState);
1527 }
1528 
1529 void
1530 TestDlOfdmaPhyPuncturing::DoCheckPhyState(Ptr<OfdmaSpectrumWifiPhy> phy, WifiPhyState expectedState)
1531 {
1532  WifiPhyState currentState;
1533  PointerValue ptr;
1534  phy->GetAttribute("State", ptr);
1535  Ptr<WifiPhyStateHelper> state = DynamicCast<WifiPhyStateHelper>(ptr.Get<WifiPhyStateHelper>());
1536  currentState = state->GetState();
1537  NS_LOG_FUNCTION(this << currentState);
1538  NS_TEST_ASSERT_MSG_EQ(currentState,
1539  expectedState,
1540  "PHY State " << currentState << " does not match expected state "
1541  << expectedState << " at " << Simulator::Now());
1542 }
1543 
1544 void
1545 TestDlOfdmaPhyPuncturing::DoSetup()
1546 {
1547  Ptr<MultiModelSpectrumChannel> spectrumChannel = CreateObject<MultiModelSpectrumChannel>();
1548  Ptr<FriisPropagationLossModel> lossModel = CreateObject<FriisPropagationLossModel>();
1549  lossModel->SetFrequency(m_frequency * 1e6);
1550  spectrumChannel->AddPropagationLossModel(lossModel);
1551  Ptr<ConstantSpeedPropagationDelayModel> delayModel =
1552  CreateObject<ConstantSpeedPropagationDelayModel>();
1553  spectrumChannel->SetPropagationDelayModel(delayModel);
1554 
1555  Ptr<Node> apNode = CreateObject<Node>();
1556  Ptr<WifiNetDevice> apDev = CreateObject<WifiNetDevice>();
1557  m_phyAp = CreateObject<SpectrumWifiPhy>();
1558  m_phyAp->CreateWifiSpectrumPhyInterface(apDev);
1559  m_phyAp->ConfigureStandard(WIFI_STANDARD_80211ax);
1560  Ptr<InterferenceHelper> apInterferenceHelper = CreateObject<InterferenceHelper>();
1561  m_phyAp->SetInterferenceHelper(apInterferenceHelper);
1562  Ptr<ErrorRateModel> apErrorModel = CreateObject<NistErrorRateModel>();
1563  m_phyAp->SetErrorRateModel(apErrorModel);
1564  m_phyAp->SetDevice(apDev);
1565  m_phyAp->SetChannel(spectrumChannel);
1566  Ptr<ConstantPositionMobilityModel> apMobility = CreateObject<ConstantPositionMobilityModel>();
1567  m_phyAp->SetMobility(apMobility);
1568  apDev->SetPhy(m_phyAp);
1569  apNode->AggregateObject(apMobility);
1570  apNode->AddDevice(apDev);
1571 
1572  Ptr<Node> sta1Node = CreateObject<Node>();
1573  Ptr<WifiNetDevice> sta1Dev = CreateObject<WifiNetDevice>();
1574  m_phySta1 = CreateObject<OfdmaSpectrumWifiPhy>(1);
1575  m_phySta1->CreateWifiSpectrumPhyInterface(sta1Dev);
1576  m_phySta1->ConfigureStandard(WIFI_STANDARD_80211ax);
1577  Ptr<InterferenceHelper> sta1InterferenceHelper = CreateObject<InterferenceHelper>();
1578  m_phySta1->SetInterferenceHelper(sta1InterferenceHelper);
1579  Ptr<ErrorRateModel> sta1ErrorModel = CreateObject<NistErrorRateModel>();
1580  m_phySta1->SetErrorRateModel(sta1ErrorModel);
1581  m_phySta1->SetDevice(sta1Dev);
1582  m_phySta1->SetChannel(spectrumChannel);
1583  m_phySta1->SetReceiveOkCallback(MakeCallback(&TestDlOfdmaPhyPuncturing::RxSuccessSta1, this));
1584  m_phySta1->SetReceiveErrorCallback(
1585  MakeCallback(&TestDlOfdmaPhyPuncturing::RxFailureSta1, this));
1586  Ptr<ConstantPositionMobilityModel> sta1Mobility = CreateObject<ConstantPositionMobilityModel>();
1587  m_phySta1->SetMobility(sta1Mobility);
1588  sta1Dev->SetPhy(m_phySta1);
1589  sta1Node->AggregateObject(sta1Mobility);
1590  sta1Node->AddDevice(sta1Dev);
1591 
1592  Ptr<Node> sta2Node = CreateObject<Node>();
1593  Ptr<WifiNetDevice> sta2Dev = CreateObject<WifiNetDevice>();
1594  m_phySta2 = CreateObject<OfdmaSpectrumWifiPhy>(2);
1595  m_phySta2->CreateWifiSpectrumPhyInterface(sta2Dev);
1596  m_phySta2->ConfigureStandard(WIFI_STANDARD_80211ax);
1597  Ptr<InterferenceHelper> sta2InterferenceHelper = CreateObject<InterferenceHelper>();
1598  m_phySta2->SetInterferenceHelper(sta2InterferenceHelper);
1599  Ptr<ErrorRateModel> sta2ErrorModel = CreateObject<NistErrorRateModel>();
1600  m_phySta2->SetErrorRateModel(sta2ErrorModel);
1601  m_phySta2->SetDevice(sta2Dev);
1602  m_phySta2->SetChannel(spectrumChannel);
1603  m_phySta2->SetReceiveOkCallback(MakeCallback(&TestDlOfdmaPhyPuncturing::RxSuccessSta2, this));
1604  m_phySta2->SetReceiveErrorCallback(
1605  MakeCallback(&TestDlOfdmaPhyPuncturing::RxFailureSta2, this));
1606  Ptr<ConstantPositionMobilityModel> sta2Mobility = CreateObject<ConstantPositionMobilityModel>();
1607  m_phySta2->SetMobility(sta2Mobility);
1608  sta2Dev->SetPhy(m_phySta2);
1609  sta2Node->AggregateObject(sta2Mobility);
1610  sta2Node->AddDevice(sta2Dev);
1611 
1612  Ptr<Node> interfererNode = CreateObject<Node>();
1613  Ptr<NonCommunicatingNetDevice> interfererDev = CreateObject<NonCommunicatingNetDevice>();
1614  m_phyInterferer = CreateObject<WaveformGenerator>();
1615  m_phyInterferer->SetDevice(interfererDev);
1616  m_phyInterferer->SetChannel(spectrumChannel);
1617  m_phyInterferer->SetDutyCycle(1);
1618  interfererNode->AddDevice(interfererDev);
1619 }
1620 
1621 void
1622 TestDlOfdmaPhyPuncturing::DoTeardown()
1623 {
1624  m_phyAp->Dispose();
1625  m_phyAp = nullptr;
1626  m_phySta1->Dispose();
1627  m_phySta1 = nullptr;
1628  m_phySta2->Dispose();
1629  m_phySta2 = nullptr;
1630  m_phyInterferer->Dispose();
1631  m_phyInterferer = nullptr;
1632 }
1633 
1634 void
1635 TestDlOfdmaPhyPuncturing::RunOne()
1636 {
1637  RngSeedManager::SetSeed(1);
1638  RngSeedManager::SetRun(1);
1639  int64_t streamNumber = 0;
1640  m_phyAp->AssignStreams(streamNumber);
1641  m_phySta1->AssignStreams(streamNumber);
1642  m_phySta2->AssignStreams(streamNumber);
1643 
1644  auto channelNum = std::get<0>(*WifiPhyOperatingChannel::FindFirst(0,
1645  m_frequency,
1646  m_channelWidth,
1647  WIFI_STANDARD_80211ax,
1648  WIFI_PHY_BAND_5GHZ));
1649 
1650  m_phyAp->SetOperatingChannel(
1651  WifiPhy::ChannelTuple{channelNum, m_channelWidth, WIFI_PHY_BAND_5GHZ, 0});
1652  m_phySta1->SetOperatingChannel(
1653  WifiPhy::ChannelTuple{channelNum, m_channelWidth, WIFI_PHY_BAND_5GHZ, 0});
1654  m_phySta2->SetOperatingChannel(
1655  WifiPhy::ChannelTuple{channelNum, m_channelWidth, WIFI_PHY_BAND_5GHZ, 0});
1656 
1657  // A strong non-wifi interference is generated on selected 20 MHz subchannel for the whole
1658  // duration of the test run
1659  BandInfo bandInfo;
1660  bandInfo.fc = (m_frequency - (m_channelWidth / 2) + 10 + (m_indexSubchannel * 20)) * 1e6;
1661  // Occupy half of the RU to make sure we do not have some power allocated to the subcarriers on
1662  // the border of another RU
1663  bandInfo.fl = bandInfo.fc - (5 * 1e6);
1664  bandInfo.fh = bandInfo.fc + (5 * 1e6);
1665  Bands bands;
1666  bands.push_back(bandInfo);
1667 
1668  Ptr<SpectrumModel> spectrumInterference = Create<SpectrumModel>(bands);
1669  Ptr<SpectrumValue> interferencePsd = Create<SpectrumValue>(spectrumInterference);
1670  double interferencePower = 0.1; // watts
1671  *interferencePsd = interferencePower / 10e6;
1672 
1673  Simulator::Schedule(Seconds(0.0),
1674  &TestDlOfdmaPhyPuncturing::GenerateInterference,
1675  this,
1676  interferencePsd,
1677  Seconds(3));
1678 
1679  //---------------------------------------------------------------------------
1680  // Send MU PPDU with two PSDUs addressed to STA 1 and STA 2 without preamble puncturing:
1681  Simulator::Schedule(Seconds(1.0),
1682  &TestDlOfdmaPhyPuncturing::SendMuPpdu,
1683  this,
1684  1,
1685  2,
1686  std::vector<bool>{});
1687 
1688  // Since it takes m_expectedPpduDuration to transmit the PPDU,
1689  // both PHYs should be back to IDLE at the same time.
1690  Simulator::Schedule(Seconds(1.0) + m_expectedPpduDuration40Mhz - NanoSeconds(1),
1691  &TestDlOfdmaPhyPuncturing::CheckPhyState,
1692  this,
1693  m_phySta1,
1694  WifiPhyState::RX);
1695  Simulator::Schedule(Seconds(1.0) + m_expectedPpduDuration40Mhz - NanoSeconds(1),
1696  &TestDlOfdmaPhyPuncturing::CheckPhyState,
1697  this,
1698  m_phySta2,
1699  WifiPhyState::RX);
1700  Simulator::Schedule(Seconds(1.0) + m_expectedPpduDuration40Mhz,
1701  &TestDlOfdmaPhyPuncturing::CheckPhyState,
1702  this,
1703  m_phySta1,
1704  WifiPhyState::IDLE);
1705  Simulator::Schedule(Seconds(1.0) + m_expectedPpduDuration40Mhz,
1706  &TestDlOfdmaPhyPuncturing::CheckPhyState,
1707  this,
1708  m_phySta2,
1709  WifiPhyState::IDLE);
1710 
1711  if (m_indexSubchannel < 2) // interference in RU 1
1712  {
1713  // One PSDU of 1000 bytes should have been unsuccessfuly received by STA 1
1714  Simulator::Schedule(Seconds(1.1),
1715  &TestDlOfdmaPhyPuncturing::CheckResultsSta1,
1716  this,
1717  0,
1718  1,
1719  0);
1720  // One PSDU of 1500 bytes should have been successfully received by STA 2
1721  Simulator::Schedule(Seconds(1.1),
1722  &TestDlOfdmaPhyPuncturing::CheckResultsSta2,
1723  this,
1724  1,
1725  0,
1726  1500);
1727  }
1728  else // interference in RU 2
1729  {
1730  // One PSDU of 1000 bytes should have been successfully received by STA 1
1731  Simulator::Schedule(Seconds(1.1),
1732  &TestDlOfdmaPhyPuncturing::CheckResultsSta1,
1733  this,
1734  1,
1735  0,
1736  1000);
1737  // One PSDU of 1500 bytes should have been unsuccessfuly received by STA 2
1738  Simulator::Schedule(Seconds(1.1),
1739  &TestDlOfdmaPhyPuncturing::CheckResultsSta2,
1740  this,
1741  0,
1742  1,
1743  0);
1744  }
1745 
1746  Simulator::Schedule(Seconds(1.5), &TestDlOfdmaPhyPuncturing::ResetResults, this);
1747 
1748  //---------------------------------------------------------------------------
1749  // Send MU PPDU with two PSDUs addressed to STA 1 and STA 2 with preamble puncturing:
1750  // the punctured 20 MHz subchannel is the one that has interference
1751  std::vector<bool> puncturedSubchannels;
1752  for (std::size_t i = 0; i < (m_channelWidth / 20); ++i)
1753  {
1754  if (i == m_indexSubchannel)
1755  {
1756  puncturedSubchannels.push_back(true);
1757  }
1758  else
1759  {
1760  puncturedSubchannels.push_back(false);
1761  }
1762  }
1763  Simulator::Schedule(Seconds(2.0),
1764  &TestDlOfdmaPhyPuncturing::SendMuPpdu,
1765  this,
1766  1,
1767  2,
1768  puncturedSubchannels);
1769 
1770  // Since it takes m_expectedPpduDuration to transmit the PPDU,
1771  // both PHYs should be back to IDLE at the same time.
1772  Simulator::Schedule(Seconds(2.0) + m_expectedPpduDuration20Mhz - NanoSeconds(1),
1773  &TestDlOfdmaPhyPuncturing::CheckPhyState,
1774  this,
1775  m_phySta1,
1776  WifiPhyState::RX);
1777  Simulator::Schedule(Seconds(2.0) + m_expectedPpduDuration20Mhz - NanoSeconds(1),
1778  &TestDlOfdmaPhyPuncturing::CheckPhyState,
1779  this,
1780  m_phySta2,
1781  WifiPhyState::RX);
1782  Simulator::Schedule(Seconds(2.0) + m_expectedPpduDuration20Mhz,
1783  &TestDlOfdmaPhyPuncturing::CheckPhyState,
1784  this,
1785  m_phySta1,
1786  WifiPhyState::IDLE);
1787  Simulator::Schedule(Seconds(2.0) + m_expectedPpduDuration20Mhz,
1788  &TestDlOfdmaPhyPuncturing::CheckPhyState,
1789  this,
1790  m_phySta2,
1791  WifiPhyState::IDLE);
1792 
1793  // One PSDU of 1000 bytes should have been successfully received by STA 1
1794  Simulator::Schedule(Seconds(2.1),
1795  &TestDlOfdmaPhyPuncturing::CheckResultsSta1,
1796  this,
1797  1,
1798  0,
1799  1000);
1800  // One PSDU of 1500 bytes should have been successfully received by STA 2
1801  Simulator::Schedule(Seconds(2.1),
1802  &TestDlOfdmaPhyPuncturing::CheckResultsSta2,
1803  this,
1804  1,
1805  0,
1806  1500);
1807 
1808  Simulator::Schedule(Seconds(2.5), &TestDlOfdmaPhyPuncturing::ResetResults, this);
1809 
1810  Simulator::Run();
1811 }
1812 
1813 void
1814 TestDlOfdmaPhyPuncturing::DoRun()
1815 {
1816  // test all 20 MHz subchannels in the 80 MHz operation channel except the primary one which
1817  // cannot be punctured
1818  for (auto index : {1, 2, 3})
1819  {
1820  m_indexSubchannel = index;
1821  RunOne();
1822  }
1823  Simulator::Destroy();
1824 }
1825 
1832 class TestUlOfdmaPpduUid : public TestCase
1833 {
1834  public:
1835  TestUlOfdmaPpduUid();
1836  ~TestUlOfdmaPpduUid() override;
1837 
1838  private:
1839  void DoSetup() override;
1840  void DoTeardown() override;
1841  void DoRun() override;
1842 
1847  void TxPpduAp(uint64_t uid);
1852  void TxPpduSta1(uint64_t uid);
1857  void TxPpduSta2(uint64_t uid);
1861  void ResetPpduUid();
1862 
1866  void SendMuPpdu();
1870  void SendTbPpdu();
1875  void SendSuPpdu(uint16_t txStaId);
1876 
1882  void CheckUid(uint16_t staId, uint64_t expectedUid);
1883 
1884  Ptr<OfdmaSpectrumWifiPhy> m_phyAp;
1885  Ptr<OfdmaSpectrumWifiPhy> m_phySta1;
1886  Ptr<OfdmaSpectrumWifiPhy> m_phySta2;
1887 
1888  uint64_t m_ppduUidAp;
1889  uint64_t m_ppduUidSta1;
1890  uint64_t m_ppduUidSta2;
1891 };
1892 
1893 TestUlOfdmaPpduUid::TestUlOfdmaPpduUid()
1894  : TestCase("UL-OFDMA PPDU UID attribution test"),
1895  m_ppduUidAp(UINT64_MAX),
1896  m_ppduUidSta1(UINT64_MAX),
1897  m_ppduUidSta2(UINT64_MAX)
1898 {
1899 }
1900 
1901 TestUlOfdmaPpduUid::~TestUlOfdmaPpduUid()
1902 {
1903 }
1904 
1905 void
1906 TestUlOfdmaPpduUid::DoSetup()
1907 {
1908  Ptr<MultiModelSpectrumChannel> spectrumChannel = CreateObject<MultiModelSpectrumChannel>();
1909  Ptr<FriisPropagationLossModel> lossModel = CreateObject<FriisPropagationLossModel>();
1910  lossModel->SetFrequency(DEFAULT_FREQUENCY);
1911  spectrumChannel->AddPropagationLossModel(lossModel);
1912  Ptr<ConstantSpeedPropagationDelayModel> delayModel =
1913  CreateObject<ConstantSpeedPropagationDelayModel>();
1914  spectrumChannel->SetPropagationDelayModel(delayModel);
1915 
1916  Ptr<Node> apNode = CreateObject<Node>();
1917  Ptr<WifiNetDevice> apDev = CreateObject<WifiNetDevice>();
1918  m_phyAp = CreateObject<OfdmaSpectrumWifiPhy>(0);
1919  m_phyAp->CreateWifiSpectrumPhyInterface(apDev);
1920  m_phyAp->ConfigureStandard(WIFI_STANDARD_80211ax);
1921  Ptr<InterferenceHelper> apInterferenceHelper = CreateObject<InterferenceHelper>();
1922  m_phyAp->SetInterferenceHelper(apInterferenceHelper);
1923  Ptr<ErrorRateModel> apErrorModel = CreateObject<NistErrorRateModel>();
1924  m_phyAp->SetErrorRateModel(apErrorModel);
1925  auto channelNum = std::get<0>(*WifiPhyOperatingChannel::FindFirst(0,
1926  DEFAULT_FREQUENCY,
1927  DEFAULT_CHANNEL_WIDTH,
1928  WIFI_STANDARD_80211ax,
1929  WIFI_PHY_BAND_5GHZ));
1930  m_phyAp->SetOperatingChannel(
1931  WifiPhy::ChannelTuple{channelNum, DEFAULT_CHANNEL_WIDTH, (int)(WIFI_PHY_BAND_5GHZ), 0});
1932  m_phyAp->SetDevice(apDev);
1933  m_phyAp->SetChannel(spectrumChannel);
1934  m_phyAp->TraceConnectWithoutContext("TxPpduUid",
1935  MakeCallback(&TestUlOfdmaPpduUid::TxPpduAp, this));
1936  Ptr<ConstantPositionMobilityModel> apMobility = CreateObject<ConstantPositionMobilityModel>();
1937  m_phyAp->SetMobility(apMobility);
1938  apDev->SetPhy(m_phyAp);
1939  apNode->AggregateObject(apMobility);
1940  apNode->AddDevice(apDev);
1941  apDev->SetStandard(WIFI_STANDARD_80211ax);
1942  apDev->SetHeConfiguration(CreateObject<HeConfiguration>());
1943 
1944  Ptr<Node> sta1Node = CreateObject<Node>();
1945  Ptr<WifiNetDevice> sta1Dev = CreateObject<WifiNetDevice>();
1946  m_phySta1 = CreateObject<OfdmaSpectrumWifiPhy>(1);
1947  m_phySta1->CreateWifiSpectrumPhyInterface(sta1Dev);
1948  m_phySta1->ConfigureStandard(WIFI_STANDARD_80211ax);
1949  Ptr<InterferenceHelper> sta1InterferenceHelper = CreateObject<InterferenceHelper>();
1950  m_phySta1->SetInterferenceHelper(sta1InterferenceHelper);
1951  Ptr<ErrorRateModel> sta1ErrorModel = CreateObject<NistErrorRateModel>();
1952  m_phySta1->SetErrorRateModel(sta1ErrorModel);
1953  m_phySta1->SetOperatingChannel(
1954  WifiPhy::ChannelTuple{channelNum, DEFAULT_CHANNEL_WIDTH, (int)(WIFI_PHY_BAND_5GHZ), 0});
1955  m_phySta1->SetDevice(sta1Dev);
1956  m_phySta1->SetChannel(spectrumChannel);
1957  m_phySta1->TraceConnectWithoutContext("TxPpduUid",
1958  MakeCallback(&TestUlOfdmaPpduUid::TxPpduSta1, this));
1959  Ptr<ConstantPositionMobilityModel> sta1Mobility = CreateObject<ConstantPositionMobilityModel>();
1960  m_phySta1->SetMobility(sta1Mobility);
1961  sta1Dev->SetPhy(m_phySta1);
1962  sta1Node->AggregateObject(sta1Mobility);
1963  sta1Node->AddDevice(sta1Dev);
1964 
1965  Ptr<Node> sta2Node = CreateObject<Node>();
1966  Ptr<WifiNetDevice> sta2Dev = CreateObject<WifiNetDevice>();
1967  m_phySta2 = CreateObject<OfdmaSpectrumWifiPhy>(2);
1968  m_phySta2->CreateWifiSpectrumPhyInterface(sta2Dev);
1969  m_phySta2->ConfigureStandard(WIFI_STANDARD_80211ax);
1970  Ptr<InterferenceHelper> sta2InterferenceHelper = CreateObject<InterferenceHelper>();
1971  m_phySta2->SetInterferenceHelper(sta2InterferenceHelper);
1972  Ptr<ErrorRateModel> sta2ErrorModel = CreateObject<NistErrorRateModel>();
1973  m_phySta2->SetErrorRateModel(sta2ErrorModel);
1974  m_phySta2->SetOperatingChannel(
1975  WifiPhy::ChannelTuple{channelNum, DEFAULT_CHANNEL_WIDTH, (int)(WIFI_PHY_BAND_5GHZ), 0});
1976  m_phySta2->SetDevice(sta2Dev);
1977  m_phySta2->SetChannel(spectrumChannel);
1978  m_phySta2->TraceConnectWithoutContext("TxPpduUid",
1979  MakeCallback(&TestUlOfdmaPpduUid::TxPpduSta2, this));
1980  Ptr<ConstantPositionMobilityModel> sta2Mobility = CreateObject<ConstantPositionMobilityModel>();
1981  m_phySta2->SetMobility(sta2Mobility);
1982  sta2Dev->SetPhy(m_phySta2);
1983  sta2Node->AggregateObject(sta2Mobility);
1984  sta2Node->AddDevice(sta2Dev);
1985 }
1986 
1987 void
1988 TestUlOfdmaPpduUid::DoTeardown()
1989 {
1990  m_phyAp->Dispose();
1991  m_phyAp = nullptr;
1992  m_phySta1->Dispose();
1993  m_phySta1 = nullptr;
1994  m_phySta2->Dispose();
1995  m_phySta2 = nullptr;
1996 }
1997 
1998 void
1999 TestUlOfdmaPpduUid::CheckUid(uint16_t staId, uint64_t expectedUid)
2000 {
2001  uint64_t uid;
2002  std::string device;
2003  switch (staId)
2004  {
2005  case 0:
2006  uid = m_ppduUidAp;
2007  device = "AP";
2008  break;
2009  case 1:
2010  uid = m_ppduUidSta1;
2011  device = "STA1";
2012  break;
2013  case 2:
2014  uid = m_ppduUidSta2;
2015  device = "STA2";
2016  break;
2017  default:
2018  NS_ABORT_MSG("Unexpected STA-ID");
2019  }
2020  NS_TEST_ASSERT_MSG_EQ(uid,
2021  expectedUid,
2022  "UID " << uid << " does not match expected one " << expectedUid << " for "
2023  << device << " at " << Simulator::Now());
2024 }
2025 
2026 void
2027 TestUlOfdmaPpduUid::TxPpduAp(uint64_t uid)
2028 {
2029  NS_LOG_FUNCTION(this << uid);
2030  m_ppduUidAp = uid;
2031 }
2032 
2033 void
2034 TestUlOfdmaPpduUid::TxPpduSta1(uint64_t uid)
2035 {
2036  NS_LOG_FUNCTION(this << uid);
2037  m_ppduUidSta1 = uid;
2038 }
2039 
2040 void
2041 TestUlOfdmaPpduUid::TxPpduSta2(uint64_t uid)
2042 {
2043  NS_LOG_FUNCTION(this << uid);
2044  m_ppduUidSta2 = uid;
2045 }
2046 
2047 void
2048 TestUlOfdmaPpduUid::ResetPpduUid()
2049 {
2050  NS_LOG_FUNCTION(this);
2051  m_phyAp->SetPpduUid(0); // one is enough since it's a global attribute
2052 }
2053 
2054 void
2055 TestUlOfdmaPpduUid::SendMuPpdu()
2056 {
2057  WifiConstPsduMap psdus;
2058  WifiTxVector txVector = WifiTxVector(HePhy::GetHeMcs7(),
2059  0,
2060  WIFI_PREAMBLE_HE_MU,
2061  800,
2062  1,
2063  1,
2064  0,
2065  DEFAULT_CHANNEL_WIDTH,
2066  false,
2067  false);
2068 
2069  uint16_t rxStaId1 = 1;
2070  HeRu::RuSpec ru1(HeRu::RU_106_TONE, 1, true);
2071  txVector.SetRu(ru1, rxStaId1);
2072  txVector.SetMode(HePhy::GetHeMcs7(), rxStaId1);
2073  txVector.SetNss(1, rxStaId1);
2074 
2075  uint16_t rxStaId2 = 2;
2076  HeRu::RuSpec ru2(HeRu::RU_106_TONE, 2, true);
2077  txVector.SetRu(ru2, rxStaId2);
2078  txVector.SetMode(HePhy::GetHeMcs9(), rxStaId2);
2079  txVector.SetNss(1, rxStaId2);
2080  txVector.SetSigBMode(VhtPhy::GetVhtMcs5());
2081  txVector.SetRuAllocation({96});
2082 
2083  Ptr<Packet> pkt1 = Create<Packet>(1000);
2084  WifiMacHeader hdr1;
2085  hdr1.SetType(WIFI_MAC_QOSDATA);
2086  hdr1.SetQosTid(0);
2087  hdr1.SetAddr1(Mac48Address("00:00:00:00:00:01"));
2088  hdr1.SetSequenceNumber(1);
2089  Ptr<WifiPsdu> psdu1 = Create<WifiPsdu>(pkt1, hdr1);
2090  psdus.insert(std::make_pair(rxStaId1, psdu1));
2091 
2092  Ptr<Packet> pkt2 = Create<Packet>(1500);
2093  WifiMacHeader hdr2;
2094  hdr2.SetType(WIFI_MAC_QOSDATA);
2095  hdr2.SetQosTid(0);
2096  hdr2.SetAddr1(Mac48Address("00:00:00:00:00:02"));
2097  hdr2.SetSequenceNumber(2);
2098  Ptr<WifiPsdu> psdu2 = Create<WifiPsdu>(pkt2, hdr2);
2099  psdus.insert(std::make_pair(rxStaId2, psdu2));
2100 
2101  m_phyAp->Send(psdus, txVector);
2102 }
2103 
2104 void
2105 TestUlOfdmaPpduUid::SendTbPpdu()
2106 {
2107  WifiConstPsduMap psdus1;
2108  WifiConstPsduMap psdus2;
2109 
2110  WifiTxVector txVector1 = WifiTxVector(HePhy::GetHeMcs7(),
2111  0,
2112  WIFI_PREAMBLE_HE_TB,
2113  1600,
2114  1,
2115  1,
2116  0,
2117  DEFAULT_CHANNEL_WIDTH,
2118  false,
2119  false);
2120  WifiTxVector txVector2 = txVector1;
2121  WifiTxVector trigVector = txVector2;
2122 
2123  uint16_t rxStaId1 = 1;
2124  HeRu::RuSpec ru1(HeRu::RU_106_TONE, 1, false);
2125  txVector1.SetRu(ru1, rxStaId1);
2126  txVector1.SetMode(HePhy::GetHeMcs7(), rxStaId1);
2127  txVector1.SetNss(1, rxStaId1);
2128  trigVector.SetRu(ru1, rxStaId1);
2129  trigVector.SetMode(HePhy::GetHeMcs7(), rxStaId1);
2130  trigVector.SetNss(1, rxStaId1);
2131 
2132  Ptr<Packet> pkt1 = Create<Packet>(1000);
2133  WifiMacHeader hdr1;
2134  hdr1.SetType(WIFI_MAC_QOSDATA);
2135  hdr1.SetQosTid(0);
2136  hdr1.SetAddr1(Mac48Address("00:00:00:00:00:00"));
2137  hdr1.SetSequenceNumber(1);
2138  Ptr<WifiPsdu> psdu1 = Create<WifiPsdu>(pkt1, hdr1);
2139  psdus1.insert(std::make_pair(rxStaId1, psdu1));
2140 
2141  uint16_t rxStaId2 = 2;
2142  HeRu::RuSpec ru2(HeRu::RU_106_TONE, 2, false);
2143  txVector2.SetRu(ru2, rxStaId2);
2144  txVector2.SetMode(HePhy::GetHeMcs9(), rxStaId2);
2145  txVector2.SetNss(1, rxStaId2);
2146  trigVector.SetRu(ru2, rxStaId2);
2147  trigVector.SetMode(HePhy::GetHeMcs9(), rxStaId2);
2148  trigVector.SetNss(1, rxStaId2);
2149 
2150  Ptr<Packet> pkt2 = Create<Packet>(1500);
2151  WifiMacHeader hdr2;
2152  hdr2.SetType(WIFI_MAC_QOSDATA);
2153  hdr2.SetQosTid(0);
2154  hdr2.SetAddr1(Mac48Address("00:00:00:00:00:00"));
2155  hdr2.SetSequenceNumber(2);
2156  Ptr<WifiPsdu> psdu2 = Create<WifiPsdu>(pkt2, hdr2);
2157  psdus2.insert(std::make_pair(rxStaId2, psdu2));
2158 
2159  Time txDuration1 = m_phySta1->CalculateTxDuration(psdu1->GetSize(),
2160  txVector1,
2161  m_phySta1->GetPhyBand(),
2162  rxStaId1);
2163  Time txDuration2 = m_phySta2->CalculateTxDuration(psdu2->GetSize(),
2164  txVector2,
2165  m_phySta1->GetPhyBand(),
2166  rxStaId2);
2167  Time txDuration = std::max(txDuration1, txDuration2);
2168 
2169  txVector1.SetLength(
2170  HePhy::ConvertHeTbPpduDurationToLSigLength(txDuration, txVector1, m_phySta1->GetPhyBand())
2171  .first);
2172  txVector2.SetLength(
2173  HePhy::ConvertHeTbPpduDurationToLSigLength(txDuration, txVector2, m_phySta2->GetPhyBand())
2174  .first);
2175 
2176  auto hePhyAp = DynamicCast<HePhy>(m_phyAp->GetPhyEntity(WIFI_MOD_CLASS_HE));
2177  hePhyAp->SetTrigVector(trigVector, txDuration);
2178 
2179  m_phySta1->Send(psdus1, txVector1);
2180  m_phySta2->Send(psdus2, txVector2);
2181 }
2182 
2183 void
2184 TestUlOfdmaPpduUid::SendSuPpdu(uint16_t txStaId)
2185 {
2186  WifiConstPsduMap psdus;
2187  WifiTxVector txVector = WifiTxVector(HePhy::GetHeMcs7(),
2188  0,
2189  WIFI_PREAMBLE_HE_SU,
2190  800,
2191  1,
2192  1,
2193  0,
2194  DEFAULT_CHANNEL_WIDTH,
2195  false,
2196  false);
2197 
2198  Ptr<Packet> pkt = Create<Packet>(1000);
2199  WifiMacHeader hdr;
2200  hdr.SetType(WIFI_MAC_QOSDATA);
2201  hdr.SetQosTid(0);
2202  hdr.SetAddr1(Mac48Address::GetBroadcast());
2203  hdr.SetSequenceNumber(1);
2204  Ptr<WifiPsdu> psdu = Create<WifiPsdu>(pkt, hdr);
2205  psdus.insert(std::make_pair(SU_STA_ID, psdu));
2206 
2207  switch (txStaId)
2208  {
2209  case 0:
2210  m_phyAp->Send(psdus, txVector);
2211  break;
2212  case 1:
2213  m_phySta1->Send(psdus, txVector);
2214  break;
2215  case 2:
2216  m_phySta2->Send(psdus, txVector);
2217  break;
2218  default:
2219  NS_ABORT_MSG("Unexpected STA-ID");
2220  }
2221 }
2222 
2223 void
2224 TestUlOfdmaPpduUid::DoRun()
2225 {
2226  RngSeedManager::SetSeed(1);
2227  RngSeedManager::SetRun(1);
2228  int64_t streamNumber = 0;
2229  m_phyAp->AssignStreams(streamNumber);
2230  m_phySta1->AssignStreams(streamNumber);
2231  m_phySta2->AssignStreams(streamNumber);
2232 
2233  // Reset PPDU UID so as not to be dependent on previously executed test cases,
2234  // since global attribute will be changed).
2235  ResetPpduUid();
2236 
2237  // Send HE MU PPDU with two PSDUs addressed to STA 1 and STA 2.
2238  // PPDU UID should be equal to 0 (the first counter value).
2239  Simulator::Schedule(Seconds(1.0), &TestUlOfdmaPpduUid::SendMuPpdu, this);
2240  Simulator::Schedule(Seconds(1.0), &TestUlOfdmaPpduUid::CheckUid, this, 0, 0);
2241 
2242  // Send HE SU PPDU from AP.
2243  // PPDU UID should be incremented since this is a new PPDU.
2244  Simulator::Schedule(Seconds(1.1), &TestUlOfdmaPpduUid::SendSuPpdu, this, 0);
2245  Simulator::Schedule(Seconds(1.1), &TestUlOfdmaPpduUid::CheckUid, this, 0, 1);
2246 
2247  // Send HE TB PPDU from STAs to AP.
2248  // PPDU UID should NOT be incremented since HE TB PPDUs reuse the UID of the immediately
2249  // preceding correctly received PPDU (which normally contains the trigger frame).
2250  Simulator::Schedule(Seconds(1.15), &TestUlOfdmaPpduUid::SendTbPpdu, this);
2251  Simulator::Schedule(Seconds(1.15), &TestUlOfdmaPpduUid::CheckUid, this, 1, 1);
2252  Simulator::Schedule(Seconds(1.15), &TestUlOfdmaPpduUid::CheckUid, this, 2, 1);
2253 
2254  // Send HE SU PPDU from STA1.
2255  // PPDU UID should be incremented since this is a new PPDU.
2256  Simulator::Schedule(Seconds(1.2), &TestUlOfdmaPpduUid::SendSuPpdu, this, 1);
2257  Simulator::Schedule(Seconds(1.2), &TestUlOfdmaPpduUid::CheckUid, this, 1, 2);
2258 
2259  Simulator::Run();
2260  Simulator::Destroy();
2261 }
2262 
2269 class TestMultipleHeTbPreambles : public TestCase
2270 {
2271  public:
2272  TestMultipleHeTbPreambles();
2273  ~TestMultipleHeTbPreambles() override;
2274 
2275  private:
2276  void DoSetup() override;
2277  void DoTeardown() override;
2278  void DoRun() override;
2279 
2289  void RxHeTbPpdu(uint64_t uid, uint16_t staId, double txPowerWatts, size_t payloadSize);
2290 
2297  void RxHeTbPpduOfdmaPart(Ptr<WifiSpectrumSignalParameters> rxParamsOfdma);
2304  void DoRxHeTbPpduOfdmaPart(Ptr<WifiSpectrumSignalParameters> rxParamsOfdma);
2305 
2311  void RxDropped(Ptr<const Packet> p, WifiPhyRxfailureReason reason);
2312 
2316  void Reset();
2317 
2323  void CheckHeTbPreambles(size_t nEvents, std::vector<uint64_t> uids);
2324 
2329  void CheckBytesDropped(size_t expectedBytesDropped);
2330 
2331  Ptr<OfdmaSpectrumWifiPhy> m_phy;
2332 
2333  uint64_t m_totalBytesDropped;
2334  WifiTxVector m_trigVector;
2335 };
2336 
2337 TestMultipleHeTbPreambles::TestMultipleHeTbPreambles()
2338  : TestCase("UL-OFDMA multiple RX events test"),
2339  m_totalBytesDropped(0),
2340  m_trigVector(HePhy::GetHeMcs7(),
2341  0,
2342  WIFI_PREAMBLE_HE_TB,
2343  1600,
2344  1,
2345  1,
2346  0,
2347  DEFAULT_CHANNEL_WIDTH,
2348  false,
2349  false)
2350 {
2351 }
2352 
2353 TestMultipleHeTbPreambles::~TestMultipleHeTbPreambles()
2354 {
2355 }
2356 
2357 void
2358 TestMultipleHeTbPreambles::Reset()
2359 {
2360  NS_LOG_FUNCTION(this);
2361  m_totalBytesDropped = 0;
2362  // We have to reset PHY here since we do not trigger OFDMA payload RX event in this test
2363  m_phy->Reset();
2364  m_trigVector.GetHeMuUserInfoMap().clear();
2365 }
2366 
2367 void
2368 TestMultipleHeTbPreambles::RxDropped(Ptr<const Packet> p, WifiPhyRxfailureReason reason)
2369 {
2370  NS_LOG_FUNCTION(this << p << reason);
2371  m_totalBytesDropped += (p->GetSize() - 30);
2372 }
2373 
2374 void
2375 TestMultipleHeTbPreambles::CheckHeTbPreambles(size_t nEvents, std::vector<uint64_t> uids)
2376 {
2377  auto events = m_phy->GetCurrentPreambleEvents();
2378  NS_TEST_ASSERT_MSG_EQ(events.size(), nEvents, "The number of UL MU events is not correct!");
2379  for (const auto& uid : uids)
2380  {
2381  auto pair = std::make_pair(uid, WIFI_PREAMBLE_HE_TB);
2382  auto it = events.find(pair);
2383  bool found = (it != events.end());
2384  NS_TEST_ASSERT_MSG_EQ(found,
2385  true,
2386  "HE TB PPDU with UID " << uid << " has not been received!");
2387  }
2388 }
2389 
2390 void
2391 TestMultipleHeTbPreambles::CheckBytesDropped(size_t expectedBytesDropped)
2392 {
2393  NS_TEST_ASSERT_MSG_EQ(m_totalBytesDropped,
2394  expectedBytesDropped,
2395  "The number of dropped bytes is not correct!");
2396 }
2397 
2398 void
2399 TestMultipleHeTbPreambles::RxHeTbPpdu(uint64_t uid,
2400  uint16_t staId,
2401  double txPowerWatts,
2402  size_t payloadSize)
2403 {
2404  WifiConstPsduMap psdus;
2405  WifiTxVector txVector = WifiTxVector(HePhy::GetHeMcs7(),
2406  0,
2407  WIFI_PREAMBLE_HE_TB,
2408  1600,
2409  1,
2410  1,
2411  0,
2412  DEFAULT_CHANNEL_WIDTH,
2413  false,
2414  false);
2415 
2416  HeRu::RuSpec ru(HeRu::RU_106_TONE, staId, false);
2417  txVector.SetRu(ru, staId);
2418  txVector.SetMode(HePhy::GetHeMcs7(), staId);
2419  txVector.SetNss(1, staId);
2420 
2421  m_trigVector.SetHeMuUserInfo(staId, {ru, 7, 1});
2422 
2423  Ptr<Packet> pkt = Create<Packet>(payloadSize);
2424  WifiMacHeader hdr;
2425  hdr.SetType(WIFI_MAC_QOSDATA);
2426  hdr.SetQosTid(0);
2427  hdr.SetAddr1(Mac48Address("00:00:00:00:00:00"));
2428  hdr.SetSequenceNumber(1);
2429  Ptr<WifiPsdu> psdu = Create<WifiPsdu>(pkt, hdr);
2430  psdus.insert(std::make_pair(staId, psdu));
2431 
2432  Time ppduDuration =
2433  m_phy->CalculateTxDuration(psdu->GetSize(), txVector, m_phy->GetPhyBand(), staId);
2434  Ptr<HePpdu> ppdu = Create<HePpdu>(psdus,
2435  txVector,
2436  DEFAULT_FREQUENCY,
2437  ppduDuration,
2438  WIFI_PHY_BAND_5GHZ,
2439  uid,
2440  HePpdu::PSD_NON_HE_PORTION);
2441 
2442  // Send non-OFDMA part
2443  Time nonOfdmaDuration = m_phy->GetHePhy()->CalculateNonOfdmaDurationForHeTb(txVector);
2444  uint32_t centerFrequency =
2445  m_phy->GetHePhy()->GetCenterFrequencyForNonOfdmaPart(txVector, staId);
2446  uint16_t ruWidth = HeRu::GetBandwidth(txVector.GetRu(staId).GetRuType());
2447  uint16_t channelWidth = ruWidth < 20 ? 20 : ruWidth;
2448  Ptr<SpectrumValue> rxPsd = WifiSpectrumValueHelper::CreateHeOfdmTxPowerSpectralDensity(
2449  centerFrequency,
2450  channelWidth,
2451  txPowerWatts,
2452  m_phy->GetGuardBandwidth(channelWidth));
2453  Ptr<WifiSpectrumSignalParameters> rxParams = Create<WifiSpectrumSignalParameters>();
2454  rxParams->psd = rxPsd;
2455  rxParams->txPhy = nullptr;
2456  rxParams->duration = nonOfdmaDuration;
2457  rxParams->ppdu = ppdu;
2458  rxParams->txWidth = channelWidth;
2459 
2460  uint16_t length;
2461  std::tie(length, ppduDuration) =
2462  HePhy::ConvertHeTbPpduDurationToLSigLength(ppduDuration, txVector, m_phy->GetPhyBand());
2463  txVector.SetLength(length);
2464  m_trigVector.SetLength(length);
2465  auto hePhy = DynamicCast<HePhy>(m_phy->GetLatestPhyEntity());
2466  hePhy->SetTrigVector(m_trigVector, ppduDuration);
2467  ppdu->ResetTxVector();
2468  m_phy->StartRx(rxParams);
2469 
2470  // Schedule OFDMA part
2471  Ptr<HePpdu> ppduOfdma = DynamicCast<HePpdu>(ppdu->Copy()); // since flag will be modified
2472  ppduOfdma->SetTxPsdFlag(HePpdu::PSD_HE_PORTION);
2473  WifiSpectrumBand band = m_phy->GetHePhy()->GetRuBandForRx(txVector, staId);
2474  Ptr<SpectrumValue> rxPsdOfdma =
2475  WifiSpectrumValueHelper::CreateHeMuOfdmTxPowerSpectralDensity(DEFAULT_FREQUENCY,
2476  DEFAULT_CHANNEL_WIDTH,
2477  txPowerWatts,
2478  DEFAULT_GUARD_WIDTH,
2479  band);
2480  Ptr<WifiSpectrumSignalParameters> rxParamsOfdma = Create<WifiSpectrumSignalParameters>();
2481  rxParamsOfdma->psd = rxPsd;
2482  rxParamsOfdma->txPhy = nullptr;
2483  rxParamsOfdma->duration = ppduDuration - nonOfdmaDuration;
2484  rxParamsOfdma->ppdu = ppduOfdma;
2485  rxParamsOfdma->txWidth = DEFAULT_CHANNEL_WIDTH;
2486  Simulator::Schedule(nonOfdmaDuration,
2487  &TestMultipleHeTbPreambles::RxHeTbPpduOfdmaPart,
2488  this,
2489  rxParamsOfdma);
2490 }
2491 
2492 void
2493 TestMultipleHeTbPreambles::RxHeTbPpduOfdmaPart(Ptr<WifiSpectrumSignalParameters> rxParamsOfdma)
2494 {
2495  Simulator::ScheduleNow(&TestMultipleHeTbPreambles::DoRxHeTbPpduOfdmaPart, this, rxParamsOfdma);
2496 }
2497 
2498 void
2499 TestMultipleHeTbPreambles::DoRxHeTbPpduOfdmaPart(Ptr<WifiSpectrumSignalParameters> rxParamsOfdma)
2500 {
2501  // This is needed to make sure the OFDMA part is started as the last event since HE-SIG-A should
2502  // end at the exact same time as the start For normal WifiNetDevices, this the reception of the
2503  // OFDMA part is scheduled after end of HE-SIG-A decoding.
2504  m_phy->StartRx(rxParamsOfdma);
2505 }
2506 
2507 void
2508 TestMultipleHeTbPreambles::DoSetup()
2509 {
2510  Ptr<WifiNetDevice> dev = CreateObject<WifiNetDevice>();
2511  dev->SetStandard(WIFI_STANDARD_80211ax);
2512  m_phy = CreateObject<OfdmaSpectrumWifiPhy>(0);
2513  m_phy->ConfigureStandard(WIFI_STANDARD_80211ax);
2514  Ptr<InterferenceHelper> interferenceHelper = CreateObject<InterferenceHelper>();
2515  Ptr<ErrorRateModel> error = CreateObject<NistErrorRateModel>();
2516  Ptr<ApWifiMac> mac = CreateObject<ApWifiMac>();
2517  mac->SetAttribute("BeaconGeneration", BooleanValue(false));
2518  dev->SetMac(mac);
2519  m_phy->SetInterferenceHelper(interferenceHelper);
2520  m_phy->SetErrorRateModel(error);
2521  m_phy->SetOperatingChannel(WifiPhy::ChannelTuple{DEFAULT_CHANNEL_NUMBER,
2522  DEFAULT_CHANNEL_WIDTH,
2523  (int)(WIFI_PHY_BAND_5GHZ),
2524  0});
2525  m_phy->TraceConnectWithoutContext("PhyRxDrop",
2526  MakeCallback(&TestMultipleHeTbPreambles::RxDropped, this));
2527  m_phy->SetDevice(dev);
2528  Ptr<ThresholdPreambleDetectionModel> preambleDetectionModel =
2529  CreateObject<ThresholdPreambleDetectionModel>();
2530  preambleDetectionModel->SetAttribute("Threshold", DoubleValue(4));
2531  preambleDetectionModel->SetAttribute("MinimumRssi", DoubleValue(-82));
2532  m_phy->SetPreambleDetectionModel(preambleDetectionModel);
2533  Ptr<HeConfiguration> heConfiguration = CreateObject<HeConfiguration>();
2534  heConfiguration->SetMaxTbPpduDelay(NanoSeconds(400));
2535  dev->SetHeConfiguration(heConfiguration);
2536 }
2537 
2538 void
2539 TestMultipleHeTbPreambles::DoTeardown()
2540 {
2541  m_phy->Dispose();
2542  m_phy = nullptr;
2543 }
2544 
2545 void
2546 TestMultipleHeTbPreambles::DoRun()
2547 {
2548  RngSeedManager::SetSeed(1);
2549  RngSeedManager::SetRun(1);
2550  int64_t streamNumber = 0;
2551  m_phy->AssignStreams(streamNumber);
2552 
2553  double txPowerWatts = 0.01;
2554 
2555  {
2556  // Verify a single UL MU transmission with two stations belonging to the same BSS
2557  std::vector<uint64_t> uids{0};
2558  Simulator::Schedule(Seconds(1),
2559  &TestMultipleHeTbPreambles::RxHeTbPpdu,
2560  this,
2561  uids[0],
2562  1,
2563  txPowerWatts,
2564  1001);
2565  Simulator::Schedule(Seconds(1) + NanoSeconds(100),
2566  &TestMultipleHeTbPreambles::RxHeTbPpdu,
2567  this,
2568  uids[0],
2569  2,
2570  txPowerWatts,
2571  1002);
2572  // Check that we received a single UL MU transmission with the corresponding UID
2573  Simulator::Schedule(Seconds(1.0) + MicroSeconds(1),
2574  &TestMultipleHeTbPreambles::CheckHeTbPreambles,
2575  this,
2576  1,
2577  uids);
2578  Simulator::Schedule(Seconds(1.5), &TestMultipleHeTbPreambles::Reset, this);
2579  }
2580 
2581  {
2582  // Verify the correct reception of 2 UL MU transmissions with two stations per BSS, where
2583  // the second transmission arrives during the preamble detection window and with half the
2584  // power of the first transmission.
2585  std::vector<uint64_t> uids{1, 2};
2586  Simulator::Schedule(Seconds(2),
2587  &TestMultipleHeTbPreambles::RxHeTbPpdu,
2588  this,
2589  uids[0],
2590  1,
2591  txPowerWatts,
2592  1001);
2593  Simulator::Schedule(Seconds(2) + NanoSeconds(100),
2594  &TestMultipleHeTbPreambles::RxHeTbPpdu,
2595  this,
2596  uids[0],
2597  2,
2598  txPowerWatts,
2599  1002);
2600  Simulator::Schedule(Seconds(2) + NanoSeconds(200),
2601  &TestMultipleHeTbPreambles::RxHeTbPpdu,
2602  this,
2603  uids[1],
2604  1,
2605  txPowerWatts / 2,
2606  1003);
2607  Simulator::Schedule(Seconds(2) + NanoSeconds(300),
2608  &TestMultipleHeTbPreambles::RxHeTbPpdu,
2609  this,
2610  uids[1],
2611  2,
2612  txPowerWatts / 2,
2613  1004);
2614  // Check that we received the correct reception of 2 UL MU transmissions with the
2615  // corresponding UIDs
2616  Simulator::Schedule(Seconds(2.0) + MicroSeconds(1),
2617  &TestMultipleHeTbPreambles::CheckHeTbPreambles,
2618  this,
2619  2,
2620  uids);
2621  Simulator::Schedule(Seconds(2.5), &TestMultipleHeTbPreambles::Reset, this);
2622  // TODO: verify PPDUs from second UL MU transmission are dropped
2623  }
2624 
2625  {
2626  // Verify the correct reception of 2 UL MU transmissions with two stations per BSS, where
2627  // the second transmission arrives during the preamble detection window and with twice the
2628  // power of the first transmission.
2629  std::vector<uint64_t> uids{3, 4};
2630  Simulator::Schedule(Seconds(3),
2631  &TestMultipleHeTbPreambles::RxHeTbPpdu,
2632  this,
2633  uids[0],
2634  1,
2635  txPowerWatts / 2,
2636  1001);
2637  Simulator::Schedule(Seconds(3) + NanoSeconds(100),
2638  &TestMultipleHeTbPreambles::RxHeTbPpdu,
2639  this,
2640  uids[0],
2641  2,
2642  txPowerWatts / 2,
2643  1002);
2644  Simulator::Schedule(Seconds(3) + NanoSeconds(200),
2645  &TestMultipleHeTbPreambles::RxHeTbPpdu,
2646  this,
2647  uids[1],
2648  1,
2649  txPowerWatts,
2650  1003);
2651  Simulator::Schedule(Seconds(3) + NanoSeconds(300),
2652  &TestMultipleHeTbPreambles::RxHeTbPpdu,
2653  this,
2654  uids[1],
2655  2,
2656  txPowerWatts,
2657  1004);
2658  // Check that we received the correct reception of 2 UL MU transmissions with the
2659  // corresponding UIDs
2660  Simulator::Schedule(Seconds(3.0) + MicroSeconds(1),
2661  &TestMultipleHeTbPreambles::CheckHeTbPreambles,
2662  this,
2663  2,
2664  uids);
2665  Simulator::Schedule(Seconds(3.5), &TestMultipleHeTbPreambles::Reset, this);
2666  // TODO: verify PPDUs from first UL MU transmission are dropped
2667  }
2668 
2669  {
2670  // Verify the correct reception of 2 UL MU transmissions with two stations per BSS, where
2671  // the second transmission arrives during PHY header reception and with the same power as
2672  // the first transmission.
2673  std::vector<uint64_t> uids{5, 6};
2674  Simulator::Schedule(Seconds(4),
2675  &TestMultipleHeTbPreambles::RxHeTbPpdu,
2676  this,
2677  uids[0],
2678  1,
2679  txPowerWatts,
2680  1001);
2681  Simulator::Schedule(Seconds(4) + NanoSeconds(100),
2682  &TestMultipleHeTbPreambles::RxHeTbPpdu,
2683  this,
2684  uids[0],
2685  2,
2686  txPowerWatts,
2687  1002);
2688  Simulator::Schedule(Seconds(4) + MicroSeconds(5),
2689  &TestMultipleHeTbPreambles::RxHeTbPpdu,
2690  this,
2691  uids[1],
2692  1,
2693  txPowerWatts,
2694  1003);
2695  Simulator::Schedule(Seconds(4) + MicroSeconds(5) + NanoSeconds(100),
2696  &TestMultipleHeTbPreambles::RxHeTbPpdu,
2697  this,
2698  uids[1],
2699  2,
2700  txPowerWatts,
2701  1004);
2702  // Check that we received the correct reception of the first UL MU transmission with the
2703  // corresponding UID (second one dropped)
2704  Simulator::Schedule(Seconds(4.0) + MicroSeconds(10),
2705  &TestMultipleHeTbPreambles::CheckHeTbPreambles,
2706  this,
2707  1,
2708  std::vector<uint64_t>{uids[0]});
2709  // The packets of the second UL MU transmission should have been dropped
2710  Simulator::Schedule(Seconds(4.0) + MicroSeconds(10),
2711  &TestMultipleHeTbPreambles::CheckBytesDropped,
2712  this,
2713  1003 + 1004);
2714  Simulator::Schedule(Seconds(4.5), &TestMultipleHeTbPreambles::Reset, this);
2715  }
2716 
2717  {
2718  // Verify the correct reception of one UL MU transmission out of 2 with two stations per
2719  // BSS, where the second transmission arrives during payload reception and with the same
2720  // power as the first transmission.
2721  std::vector<uint64_t> uids{7, 8};
2722  Simulator::Schedule(Seconds(5),
2723  &TestMultipleHeTbPreambles::RxHeTbPpdu,
2724  this,
2725  uids[0],
2726  1,
2727  txPowerWatts,
2728  1001);
2729  Simulator::Schedule(Seconds(5) + NanoSeconds(100),
2730  &TestMultipleHeTbPreambles::RxHeTbPpdu,
2731  this,
2732  uids[0],
2733  2,
2734  txPowerWatts,
2735  1002);
2736  Simulator::Schedule(Seconds(5) + MicroSeconds(50),
2737  &TestMultipleHeTbPreambles::RxHeTbPpdu,
2738  this,
2739  uids[1],
2740  1,
2741  txPowerWatts,
2742  1003);
2743  Simulator::Schedule(Seconds(5) + MicroSeconds(50) + NanoSeconds(100),
2744  &TestMultipleHeTbPreambles::RxHeTbPpdu,
2745  this,
2746  uids[1],
2747  2,
2748  txPowerWatts,
2749  1004);
2750  // Check that we received the correct reception of the first UL MU transmission with the
2751  // corresponding UID (second one dropped)
2752  Simulator::Schedule(Seconds(5.0) + MicroSeconds(100),
2753  &TestMultipleHeTbPreambles::CheckHeTbPreambles,
2754  this,
2755  1,
2756  std::vector<uint64_t>{uids[0]});
2757  // The packets of the second UL MU transmission should have been dropped
2758  Simulator::Schedule(Seconds(5.0) + MicroSeconds(100),
2759  &TestMultipleHeTbPreambles::CheckBytesDropped,
2760  this,
2761  1003 + 1004);
2762  Simulator::Schedule(Seconds(5.5), &TestMultipleHeTbPreambles::Reset, this);
2763  }
2764 
2765  {
2766  // Verify the correct reception of a single UL MU transmission with two stations belonging
2767  // to the same BSS, and the second PPDU arrives 500ns after the first PPDU, i.e. it exceeds
2768  // the configured delay spread of 400ns
2769  std::vector<uint64_t> uids{9};
2770  Simulator::Schedule(Seconds(6),
2771  &TestMultipleHeTbPreambles::RxHeTbPpdu,
2772  this,
2773  uids[0],
2774  1,
2775  txPowerWatts,
2776  1001);
2777  Simulator::Schedule(Seconds(6) + NanoSeconds(500),
2778  &TestMultipleHeTbPreambles::RxHeTbPpdu,
2779  this,
2780  uids[0],
2781  2,
2782  txPowerWatts,
2783  1002);
2784  // Check that we received a single UL MU transmission with the corresponding UID
2785  Simulator::Schedule(Seconds(6.0) + MicroSeconds(1),
2786  &TestMultipleHeTbPreambles::CheckHeTbPreambles,
2787  this,
2788  1,
2789  uids);
2790  // The first packet of 1001 bytes should be dropped because preamble is not detected after
2791  // 4us (because the PPDU that arrived at 500ns is interfering): the second HE TB PPDU is
2792  // acting as interference since it arrived after the maximum allowed 400ns. Obviously, that
2793  // second packet of 1002 bytes is dropped as well.
2794  Simulator::Schedule(Seconds(6.0) + MicroSeconds(5),
2795  &TestMultipleHeTbPreambles::CheckBytesDropped,
2796  this,
2797  1001 + 1002);
2798  Simulator::Schedule(Seconds(6.5), &TestMultipleHeTbPreambles::Reset, this);
2799  }
2800 
2801  Simulator::Run();
2802  Simulator::Destroy();
2803 }
2804 
2811 class OfdmaTestPhyListener : public ns3::WifiPhyListener
2812 {
2813  public:
2814  OfdmaTestPhyListener() = default;
2815 
2816  void NotifyRxStart(Time duration) override
2817  {
2818  NS_LOG_FUNCTION(this << duration);
2819  m_lastRxStart = Simulator::Now();
2820  ++m_notifyRxStart;
2821  m_lastRxSuccess = false;
2822  }
2823 
2824  void NotifyRxEndOk() override
2825  {
2826  NS_LOG_FUNCTION(this);
2827  m_lastRxEnd = Simulator::Now();
2828  ++m_notifyRxEnd;
2829  m_lastRxSuccess = true;
2830  }
2831 
2832  void NotifyRxEndError() override
2833  {
2834  NS_LOG_FUNCTION(this);
2835  m_lastRxEnd = Simulator::Now();
2836  ++m_notifyRxEnd;
2837  m_lastRxSuccess = false;
2838  }
2839 
2840  void NotifyTxStart(Time duration, double txPowerDbm) override
2841  {
2842  NS_LOG_FUNCTION(this << duration << txPowerDbm);
2843  }
2844 
2845  void NotifyCcaBusyStart(Time duration,
2846  WifiChannelListType channelType,
2847  const std::vector<Time>& /*per20MhzDurations*/) override
2848  {
2849  NS_LOG_FUNCTION(this << duration << channelType);
2850  }
2851 
2852  void NotifySwitchingStart(Time duration) override
2853  {
2854  }
2855 
2856  void NotifySleep() override
2857  {
2858  }
2859 
2860  void NotifyOff() override
2861  {
2862  }
2863 
2864  void NotifyWakeup() override
2865  {
2866  }
2867 
2868  void NotifyOn() override
2869  {
2870  }
2871 
2875  void Reset()
2876  {
2877  m_notifyRxStart = 0;
2878  m_notifyRxEnd = 0;
2879  m_lastRxStart = Seconds(0);
2880  m_lastRxEnd = Seconds(0);
2881  m_lastRxSuccess = false;
2882  }
2883 
2888  uint32_t GetNumRxStartNotifications() const
2889  {
2890  return m_notifyRxStart;
2891  }
2892 
2897  uint32_t GetNumRxEndNotifications() const
2898  {
2899  return m_notifyRxEnd;
2900  }
2901 
2906  Time GetLastRxStartNotification() const
2907  {
2908  return m_lastRxStart;
2909  }
2910 
2915  Time GetLastRxEndNotification() const
2916  {
2917  return m_lastRxEnd;
2918  }
2919 
2924  bool IsLastRxSuccess() const
2925  {
2926  return m_lastRxSuccess;
2927  }
2928 
2929  private:
2930  uint32_t m_notifyRxStart{0};
2931  uint32_t m_notifyRxEnd{0};
2932  Time m_lastRxStart{Seconds(0)};
2933  Time m_lastRxEnd{Seconds(0)};
2934  bool m_lastRxSuccess{false};
2935 };
2936 
2943 class TestUlOfdmaPhyTransmission : public TestCase
2944 {
2945  public:
2949  enum TrigVectorInfo
2950  {
2951  NONE = 0,
2952  CHANNEL_WIDTH,
2953  UL_LENGTH,
2954  AID,
2955  };
2956 
2957  TestUlOfdmaPhyTransmission();
2958  ~TestUlOfdmaPhyTransmission() override;
2959 
2960  private:
2961  void DoSetup() override;
2962  void DoTeardown() override;
2963  void DoRun() override;
2964 
2972  WifiTxVector GetTxVectorForHeTbPpdu(uint16_t txStaId,
2973  std::size_t index,
2974  uint8_t bssColor) const;
2981  void SetTrigVector(uint8_t bssColor, TrigVectorInfo error);
2991  void SendHeTbPpdu(uint16_t txStaId,
2992  std::size_t index,
2993  std::size_t payloadSize,
2994  uint64_t uid,
2995  uint8_t bssColor,
2996  bool incrementUid);
2997 
3005  void SendHeSuPpdu(uint16_t txStaId, std::size_t payloadSize, uint64_t uid, uint8_t bssColor);
3006 
3012  void SetBssColor(Ptr<WifiPhy> phy, uint8_t bssColor);
3013 
3019  void SetPsdLimit(Ptr<WifiPhy> phy, double psdLimit);
3020 
3026  void GenerateInterference(Ptr<SpectrumValue> interferencePsd, Time duration);
3030  void StopInterference();
3031 
3035  void RunOne();
3036 
3043  void CheckRxFromSta1(uint32_t expectedSuccess,
3044  uint32_t expectedFailures,
3045  uint32_t expectedBytes);
3046 
3053  void CheckRxFromSta2(uint32_t expectedSuccess,
3054  uint32_t expectedFailures,
3055  uint32_t expectedBytes);
3056 
3063  void CheckNonOfdmaRxPower(Ptr<OfdmaSpectrumWifiPhy> phy,
3064  WifiSpectrumBand band,
3065  double expectedRxPower);
3072  void CheckOfdmaRxPower(Ptr<OfdmaSpectrumWifiPhy> phy,
3073  WifiSpectrumBand band,
3074  double expectedRxPower);
3075 
3079  void VerifyEventsCleared();
3080 
3086  void CheckPhyState(Ptr<OfdmaSpectrumWifiPhy> phy, WifiPhyState expectedState);
3088  void DoCheckPhyState(Ptr<OfdmaSpectrumWifiPhy> phy, WifiPhyState expectedState);
3089 
3096  void CheckApRxStart(uint32_t expectedNotifications, Time expectedLastNotification);
3104  void CheckApRxEnd(uint32_t expectedNotifications,
3105  Time expectedLastNotification,
3106  bool expectedSuccess);
3107 
3111  void Reset();
3112 
3120  void RxSuccess(Ptr<const WifiPsdu> psdu,
3121  RxSignalInfo rxSignalInfo,
3122  WifiTxVector txVector,
3123  std::vector<bool> statusPerMpdu);
3124 
3129  void RxFailure(Ptr<const WifiPsdu> psdu);
3130 
3151  void ScheduleTest(Time delay,
3152  bool solicited,
3153  WifiPhyState expectedStateAtEnd,
3154  uint32_t expectedSuccessFromSta1,
3155  uint32_t expectedFailuresFromSta1,
3156  uint32_t expectedBytesFromSta1,
3157  uint32_t expectedSuccessFromSta2,
3158  uint32_t expectedFailuresFromSta2,
3159  uint32_t expectedBytesFromSta2,
3160  bool scheduleTxSta1 = true,
3161  Time ulTimeDifference = Seconds(0),
3162  WifiPhyState expectedStateBeforeEnd = WifiPhyState::RX,
3163  TrigVectorInfo error = NONE);
3164 
3174  void SchedulePowerMeasurementChecks(Time delay,
3175  double rxPowerNonOfdmaRu1,
3176  double rxPowerNonOfdmaRu2,
3177  double rxPowerOfdmaRu1,
3178  double rxPowerOfdmaRu2);
3184  void LogScenario(std::string log) const;
3185 
3186  Ptr<OfdmaSpectrumWifiPhy> m_phyAp;
3187  Ptr<OfdmaSpectrumWifiPhy> m_phySta1;
3188  Ptr<OfdmaSpectrumWifiPhy> m_phySta2;
3189  Ptr<OfdmaSpectrumWifiPhy> m_phySta3;
3190 
3191  std::unique_ptr<OfdmaTestPhyListener>
3192  m_apPhyStateListener;
3193 
3194  Ptr<WaveformGenerator> m_phyInterferer;
3195 
3196  uint32_t m_countRxSuccessFromSta1;
3197  uint32_t m_countRxSuccessFromSta2;
3198  uint32_t m_countRxFailureFromSta1;
3199  uint32_t m_countRxFailureFromSta2;
3200  uint32_t m_countRxBytesFromSta1;
3201  uint32_t m_countRxBytesFromSta2;
3202 
3203  uint16_t m_frequency;
3204  uint16_t m_channelWidth;
3205  Time m_expectedPpduDuration;
3206 };
3207 
3208 TestUlOfdmaPhyTransmission::TestUlOfdmaPhyTransmission()
3209  : TestCase("UL-OFDMA PHY test"),
3210  m_countRxSuccessFromSta1(0),
3211  m_countRxSuccessFromSta2(0),
3212  m_countRxFailureFromSta1(0),
3213  m_countRxFailureFromSta2(0),
3214  m_countRxBytesFromSta1(0),
3215  m_countRxBytesFromSta2(0),
3216  m_frequency(DEFAULT_FREQUENCY),
3217  m_channelWidth(DEFAULT_CHANNEL_WIDTH),
3218  m_expectedPpduDuration(NanoSeconds(271200))
3219 {
3220 }
3221 
3222 void
3223 TestUlOfdmaPhyTransmission::SendHeSuPpdu(uint16_t txStaId,
3224  std::size_t payloadSize,
3225  uint64_t uid,
3226  uint8_t bssColor)
3227 {
3228  NS_LOG_FUNCTION(this << txStaId << payloadSize << uid << +bssColor);
3229  WifiConstPsduMap psdus;
3230 
3231  WifiTxVector txVector = WifiTxVector(HePhy::GetHeMcs7(),
3232  0,
3233  WIFI_PREAMBLE_HE_SU,
3234  800,
3235  1,
3236  1,
3237  0,
3238  m_channelWidth,
3239  false,
3240  false,
3241  false,
3242  bssColor);
3243 
3244  Ptr<Packet> pkt = Create<Packet>(payloadSize);
3245  WifiMacHeader hdr;
3246  hdr.SetType(WIFI_MAC_QOSDATA);
3247  hdr.SetQosTid(0);
3248  hdr.SetAddr1(Mac48Address("00:00:00:00:00:00"));
3249  std::ostringstream addr;
3250  addr << "00:00:00:00:00:0" << txStaId;
3251  hdr.SetAddr2(Mac48Address(addr.str().c_str()));
3252  hdr.SetSequenceNumber(1);
3253  Ptr<WifiPsdu> psdu = Create<WifiPsdu>(pkt, hdr);
3254  psdus.insert(std::make_pair(SU_STA_ID, psdu));
3255 
3256  Ptr<OfdmaSpectrumWifiPhy> phy;
3257  if (txStaId == 1)
3258  {
3259  phy = m_phySta1;
3260  }
3261  else if (txStaId == 2)
3262  {
3263  phy = m_phySta2;
3264  }
3265  else if (txStaId == 3)
3266  {
3267  phy = m_phySta3;
3268  }
3269  else if (txStaId == 0)
3270  {
3271  phy = m_phyAp;
3272  }
3273  phy->SetPpduUid(uid);
3274  phy->Send(psdus, txVector);
3275 }
3276 
3277 WifiTxVector
3278 TestUlOfdmaPhyTransmission::GetTxVectorForHeTbPpdu(uint16_t txStaId,
3279  std::size_t index,
3280  uint8_t bssColor) const
3281 {
3282  WifiTxVector txVector = WifiTxVector(HePhy::GetHeMcs7(),
3283  0,
3284  WIFI_PREAMBLE_HE_TB,
3285  1600,
3286  1,
3287  1,
3288  0,
3289  m_channelWidth,
3290  false,
3291  false,
3292  false,
3293  bssColor);
3294 
3295  HeRu::RuType ruType = HeRu::RU_106_TONE;
3296  if (m_channelWidth == 20)
3297  {
3298  ruType = HeRu::RU_106_TONE;
3299  }
3300  else if (m_channelWidth == 40)
3301  {
3302  ruType = HeRu::RU_242_TONE;
3303  }
3304  else if (m_channelWidth == 80)
3305  {
3306  ruType = HeRu::RU_484_TONE;
3307  }
3308  else if (m_channelWidth == 160)
3309  {
3310  ruType = HeRu::RU_996_TONE;
3311  }
3312  else
3313  {
3314  NS_ASSERT_MSG(false, "Unsupported channel width");
3315  }
3316 
3317  bool primary80MHz = true;
3318  if (m_channelWidth == 160 && index == 2)
3319  {
3320  primary80MHz = false;
3321  index = 1;
3322  }
3323  HeRu::RuSpec ru(ruType, index, primary80MHz);
3324  txVector.SetRu(ru, txStaId);
3325  txVector.SetMode(HePhy::GetHeMcs7(), txStaId);
3326  txVector.SetNss(1, txStaId);
3327  return txVector;
3328 }
3329 
3330 void
3331 TestUlOfdmaPhyTransmission::SetTrigVector(uint8_t bssColor, TrigVectorInfo error)
3332 {
3333  uint16_t channelWidth = m_channelWidth;
3334  if (error == CHANNEL_WIDTH)
3335  {
3336  channelWidth = (channelWidth == 160 ? 20 : channelWidth * 2);
3337  }
3338 
3339  WifiTxVector txVector(HePhy::GetHeMcs7(),
3340  0,
3341  WIFI_PREAMBLE_HE_TB,
3342  1600,
3343  1,
3344  1,
3345  0,
3346  channelWidth,
3347  false,
3348  false,
3349  false,
3350  bssColor);
3351 
3352  HeRu::RuType ruType = HeRu::RU_106_TONE;
3353  if (channelWidth == 20)
3354  {
3355  ruType = HeRu::RU_106_TONE;
3356  }
3357  else if (channelWidth == 40)
3358  {
3359  ruType = HeRu::RU_242_TONE;
3360  }
3361  else if (channelWidth == 80)
3362  {
3363  ruType = HeRu::RU_484_TONE;
3364  }
3365  else if (channelWidth == 160)
3366  {
3367  ruType = HeRu::RU_996_TONE;
3368  }
3369  else
3370  {
3371  NS_ASSERT_MSG(false, "Unsupported channel width");
3372  }
3373 
3374  uint16_t aid1 = (error == AID ? 3 : 1);
3375  uint16_t aid2 = (error == AID ? 4 : 2);
3376 
3377  HeRu::RuSpec ru1(ruType, 1, true);
3378  txVector.SetRu(ru1, aid1);
3379  txVector.SetMode(HePhy::GetHeMcs7(), aid1);
3380  txVector.SetNss(1, aid1);
3381 
3382  HeRu::RuSpec ru2(ruType, (channelWidth == 160 ? 1 : 2), (channelWidth == 160 ? false : true));
3383  txVector.SetRu(ru2, aid2);
3384  txVector.SetMode(HePhy::GetHeMcs7(), aid2);
3385  txVector.SetNss(1, aid2);
3386 
3387  uint16_t length;
3388  std::tie(length, m_expectedPpduDuration) =
3389  HePhy::ConvertHeTbPpduDurationToLSigLength(m_expectedPpduDuration,
3390  txVector,
3391  m_phyAp->GetPhyBand());
3392  if (error == UL_LENGTH)
3393  {
3394  ++length;
3395  }
3396  txVector.SetLength(length);
3397  auto hePhyAp = DynamicCast<HePhy>(m_phyAp->GetLatestPhyEntity());
3398  hePhyAp->SetTrigVector(txVector, m_expectedPpduDuration);
3399 }
3400 
3401 void
3402 TestUlOfdmaPhyTransmission::SendHeTbPpdu(uint16_t txStaId,
3403  std::size_t index,
3404  std::size_t payloadSize,
3405  uint64_t uid,
3406  uint8_t bssColor,
3407  bool incrementUid)
3408 {
3409  NS_LOG_FUNCTION(this << txStaId << index << payloadSize << uid << +bssColor << (incrementUid));
3410  WifiConstPsduMap psdus;
3411 
3412  if (incrementUid)
3413  {
3414  ++uid;
3415  }
3416 
3417  WifiTxVector txVector = GetTxVectorForHeTbPpdu(txStaId, index, bssColor);
3418  Ptr<Packet> pkt = Create<Packet>(payloadSize);
3419  WifiMacHeader hdr;
3420  hdr.SetType(WIFI_MAC_QOSDATA);
3421  hdr.SetQosTid(0);
3422  hdr.SetAddr1(Mac48Address("00:00:00:00:00:00"));
3423  std::ostringstream addr;
3424  addr << "00:00:00:00:00:0" << txStaId;
3425  hdr.SetAddr2(Mac48Address(addr.str().c_str()));
3426  hdr.SetSequenceNumber(1);
3427  Ptr<WifiPsdu> psdu = Create<WifiPsdu>(pkt, hdr);
3428  psdus.insert(std::make_pair(txStaId, psdu));
3429 
3430  Ptr<OfdmaSpectrumWifiPhy> phy;
3431  if (txStaId == 1)
3432  {
3433  phy = m_phySta1;
3434  }
3435  else if (txStaId == 2)
3436  {
3437  phy = m_phySta2;
3438  }
3439  else if (txStaId == 3)
3440  {
3441  phy = m_phySta3;
3442  }
3443 
3444  Time txDuration =
3445  phy->CalculateTxDuration(psdu->GetSize(), txVector, phy->GetPhyBand(), txStaId);
3446  txVector.SetLength(
3447  HePhy::ConvertHeTbPpduDurationToLSigLength(txDuration, txVector, phy->GetPhyBand()).first);
3448 
3449  phy->SetPpduUid(uid);
3450  phy->Send(psdus, txVector);
3451 }
3452 
3453 void
3454 TestUlOfdmaPhyTransmission::GenerateInterference(Ptr<SpectrumValue> interferencePsd, Time duration)
3455 {
3456  NS_LOG_FUNCTION(this << duration);
3457  m_phyInterferer->SetTxPowerSpectralDensity(interferencePsd);
3458  m_phyInterferer->SetPeriod(duration);
3459  m_phyInterferer->Start();
3460  Simulator::Schedule(duration, &TestUlOfdmaPhyTransmission::StopInterference, this);
3461 }
3462 
3463 void
3464 TestUlOfdmaPhyTransmission::StopInterference()
3465 {
3466  m_phyInterferer->Stop();
3467 }
3468 
3469 TestUlOfdmaPhyTransmission::~TestUlOfdmaPhyTransmission()
3470 {
3471 }
3472 
3473 void
3474 TestUlOfdmaPhyTransmission::RxSuccess(Ptr<const WifiPsdu> psdu,
3475  RxSignalInfo rxSignalInfo,
3476  WifiTxVector txVector,
3477  std::vector<bool> /*statusPerMpdu*/)
3478 {
3479  NS_LOG_FUNCTION(this << *psdu << psdu->GetAddr2() << rxSignalInfo << txVector);
3480  if (psdu->GetAddr2() == Mac48Address("00:00:00:00:00:01"))
3481  {
3482  m_countRxSuccessFromSta1++;
3483  m_countRxBytesFromSta1 += (psdu->GetSize() - 30);
3484  }
3485  else if (psdu->GetAddr2() == Mac48Address("00:00:00:00:00:02"))
3486  {
3487  m_countRxSuccessFromSta2++;
3488  m_countRxBytesFromSta2 += (psdu->GetSize() - 30);
3489  }
3490 }
3491 
3492 void
3493 TestUlOfdmaPhyTransmission::RxFailure(Ptr<const WifiPsdu> psdu)
3494 {
3495  NS_LOG_FUNCTION(this << *psdu << psdu->GetAddr2());
3496  if (psdu->GetAddr2() == Mac48Address("00:00:00:00:00:01"))
3497  {
3498  m_countRxFailureFromSta1++;
3499  }
3500  else if (psdu->GetAddr2() == Mac48Address("00:00:00:00:00:02"))
3501  {
3502  m_countRxFailureFromSta2++;
3503  }
3504 }
3505 
3506 void
3507 TestUlOfdmaPhyTransmission::CheckRxFromSta1(uint32_t expectedSuccess,
3508  uint32_t expectedFailures,
3509  uint32_t expectedBytes)
3510 {
3511  NS_TEST_ASSERT_MSG_EQ(m_countRxSuccessFromSta1,
3512  expectedSuccess,
3513  "The number of successfully received packets from STA 1 is not correct!");
3514  NS_TEST_ASSERT_MSG_EQ(
3515  m_countRxFailureFromSta1,
3516  expectedFailures,
3517  "The number of unsuccessfuly received packets from STA 1 is not correct!");
3518  NS_TEST_ASSERT_MSG_EQ(m_countRxBytesFromSta1,
3519  expectedBytes,
3520  "The number of bytes received from STA 1 is not correct!");
3521 }
3522 
3523 void
3524 TestUlOfdmaPhyTransmission::CheckRxFromSta2(uint32_t expectedSuccess,
3525  uint32_t expectedFailures,
3526  uint32_t expectedBytes)
3527 {
3528  NS_TEST_ASSERT_MSG_EQ(m_countRxSuccessFromSta2,
3529  expectedSuccess,
3530  "The number of successfully received packets from STA 2 is not correct!");
3531  NS_TEST_ASSERT_MSG_EQ(
3532  m_countRxFailureFromSta2,
3533  expectedFailures,
3534  "The number of unsuccessfuly received packets from STA 2 is not correct!");
3535  NS_TEST_ASSERT_MSG_EQ(m_countRxBytesFromSta2,
3536  expectedBytes,
3537  "The number of bytes received from STA 2 is not correct!");
3538 }
3539 
3540 void
3541 TestUlOfdmaPhyTransmission::CheckNonOfdmaRxPower(Ptr<OfdmaSpectrumWifiPhy> phy,
3542  WifiSpectrumBand band,
3543  double expectedRxPower)
3544 {
3545  Ptr<Event> event = phy->GetCurrentEvent();
3546  NS_ASSERT(event);
3547  double rxPower = event->GetRxPowerW(band);
3548  NS_LOG_FUNCTION(this << band.first << band.second << expectedRxPower << rxPower);
3549  // Since there is out of band emission due to spectrum mask, the tolerance cannot be very low
3550  NS_TEST_ASSERT_MSG_EQ_TOL(rxPower,
3551  expectedRxPower,
3552  5e-3,
3553  "RX power " << rxPower << " over (" << band.first << ", "
3554  << band.second << ") does not match expected power "
3555  << expectedRxPower << " at " << Simulator::Now());
3556 }
3557 
3558 void
3559 TestUlOfdmaPhyTransmission::CheckOfdmaRxPower(Ptr<OfdmaSpectrumWifiPhy> phy,
3560  WifiSpectrumBand band,
3561  double expectedRxPower)
3562 {
3568  NS_LOG_FUNCTION(this << band.first << band.second << expectedRxPower);
3569  double step = 5e-3;
3570  if (expectedRxPower > 0.0)
3571  {
3572  NS_TEST_ASSERT_MSG_EQ(
3573  phy->GetEnergyDuration(expectedRxPower - step, band).IsStrictlyPositive(),
3574  true,
3575  "At least " << expectedRxPower << " W expected for OFDMA part over (" << band.first
3576  << ", " << band.second << ") at " << Simulator::Now());
3577  NS_TEST_ASSERT_MSG_EQ(
3578  phy->GetEnergyDuration(expectedRxPower + step, band).IsStrictlyPositive(),
3579  false,
3580  "At most " << expectedRxPower << " W expected for OFDMA part over (" << band.first
3581  << ", " << band.second << ") at " << Simulator::Now());
3582  }
3583  else
3584  {
3585  NS_TEST_ASSERT_MSG_EQ(
3586  phy->GetEnergyDuration(expectedRxPower + step, band).IsStrictlyPositive(),
3587  false,
3588  "At most " << expectedRxPower << " W expected for OFDMA part over (" << band.first
3589  << ", " << band.second << ") at " << Simulator::Now());
3590  }
3591 }
3592 
3593 void
3594 TestUlOfdmaPhyTransmission::VerifyEventsCleared()
3595 {
3596  NS_TEST_ASSERT_MSG_EQ(m_phyAp->GetCurrentEvent(),
3597  nullptr,
3598  "m_currentEvent for AP was not cleared");
3599  NS_TEST_ASSERT_MSG_EQ(m_phySta1->GetCurrentEvent(),
3600  nullptr,
3601  "m_currentEvent for STA 1 was not cleared");
3602  NS_TEST_ASSERT_MSG_EQ(m_phySta2->GetCurrentEvent(),
3603  nullptr,
3604  "m_currentEvent for STA 2 was not cleared");
3605 }
3606 
3607 void
3608 TestUlOfdmaPhyTransmission::CheckPhyState(Ptr<OfdmaSpectrumWifiPhy> phy, WifiPhyState expectedState)
3609 {
3610  // This is needed to make sure PHY state will be checked as the last event if a state change
3611  // occurred at the exact same time as the check
3612  Simulator::ScheduleNow(&TestUlOfdmaPhyTransmission::DoCheckPhyState, this, phy, expectedState);
3613 }
3614 
3615 void
3616 TestUlOfdmaPhyTransmission::DoCheckPhyState(Ptr<OfdmaSpectrumWifiPhy> phy,
3617  WifiPhyState expectedState)
3618 {
3619  WifiPhyState currentState;
3620  PointerValue ptr;
3621  phy->GetAttribute("State", ptr);
3622  Ptr<WifiPhyStateHelper> state = DynamicCast<WifiPhyStateHelper>(ptr.Get<WifiPhyStateHelper>());
3623  currentState = state->GetState();
3624  NS_LOG_FUNCTION(this << currentState);
3625  NS_TEST_ASSERT_MSG_EQ(currentState,
3626  expectedState,
3627  "PHY State " << currentState << " does not match expected state "
3628  << expectedState << " at " << Simulator::Now());
3629 }
3630 
3631 void
3632 TestUlOfdmaPhyTransmission::CheckApRxStart(uint32_t expectedNotifications,
3633  Time expectedLastNotification)
3634 {
3635  NS_TEST_ASSERT_MSG_EQ(m_apPhyStateListener->GetNumRxStartNotifications(),
3636  expectedNotifications,
3637  "Number of RX start notifications "
3638  << m_apPhyStateListener->GetNumRxStartNotifications()
3639  << " does not match expected count " << expectedNotifications
3640  << " for AP at " << Simulator::Now());
3641  NS_TEST_ASSERT_MSG_EQ(m_apPhyStateListener->GetLastRxStartNotification(),
3642  expectedLastNotification,
3643  "Last time RX start notification has been received "
3644  << m_apPhyStateListener->GetLastRxStartNotification()
3645  << " does not match expected time " << expectedLastNotification
3646  << " for AP at " << Simulator::Now());
3647 }
3648 
3649 void
3650 TestUlOfdmaPhyTransmission::CheckApRxEnd(uint32_t expectedNotifications,
3651  Time expectedLastNotification,
3652  bool expectedSuccess)
3653 {
3654  NS_TEST_ASSERT_MSG_EQ(m_apPhyStateListener->GetNumRxEndNotifications(),
3655  expectedNotifications,
3656  "Number of RX end notifications "
3657  << m_apPhyStateListener->GetNumRxEndNotifications()
3658  << " does not match expected count " << expectedNotifications
3659  << " for AP at " << Simulator::Now());
3660  NS_TEST_ASSERT_MSG_EQ(m_apPhyStateListener->GetLastRxEndNotification(),
3661  expectedLastNotification,
3662  "Last time RX end notification has been received "
3663  << m_apPhyStateListener->GetLastRxEndNotification()
3664  << " does not match expected time " << expectedLastNotification
3665  << " for AP at " << Simulator::Now());
3666  NS_TEST_ASSERT_MSG_EQ(m_apPhyStateListener->IsLastRxSuccess(),
3667  expectedSuccess,
3668  "Last time RX end notification indicated a "
3669  << (m_apPhyStateListener->IsLastRxSuccess() ? "success" : "failure")
3670  << " but expected a " << (expectedSuccess ? "success" : "failure")
3671  << " for AP at " << Simulator::Now());
3672 }
3673 
3674 void
3675 TestUlOfdmaPhyTransmission::Reset()
3676 {
3677  m_countRxSuccessFromSta1 = 0;
3678  m_countRxSuccessFromSta2 = 0;
3679  m_countRxFailureFromSta1 = 0;
3680  m_countRxFailureFromSta2 = 0;
3681  m_countRxBytesFromSta1 = 0;
3682  m_countRxBytesFromSta2 = 0;
3683  m_phySta1->SetPpduUid(0);
3684  m_phySta1->SetTriggerFrameUid(0);
3685  m_phySta2->SetTriggerFrameUid(0);
3686  SetBssColor(m_phyAp, 0);
3687  m_apPhyStateListener->Reset();
3688 }
3689 
3690 void
3691 TestUlOfdmaPhyTransmission::SetBssColor(Ptr<WifiPhy> phy, uint8_t bssColor)
3692 {
3693  Ptr<WifiNetDevice> device = DynamicCast<WifiNetDevice>(phy->GetDevice());
3694  Ptr<HeConfiguration> heConfiguration = device->GetHeConfiguration();
3695  heConfiguration->SetAttribute("BssColor", UintegerValue(bssColor));
3696 }
3697 
3698 void
3699 TestUlOfdmaPhyTransmission::SetPsdLimit(Ptr<WifiPhy> phy, double psdLimit)
3700 {
3701  NS_LOG_FUNCTION(this << phy << psdLimit);
3702  phy->SetAttribute("PowerDensityLimit", DoubleValue(psdLimit));
3703 }
3704 
3705 void
3706 TestUlOfdmaPhyTransmission::DoSetup()
3707 {
3708  Ptr<MultiModelSpectrumChannel> spectrumChannel = CreateObject<MultiModelSpectrumChannel>();
3709  Ptr<FriisPropagationLossModel> lossModel = CreateObject<FriisPropagationLossModel>();
3710  lossModel->SetFrequency(m_frequency);
3711  spectrumChannel->AddPropagationLossModel(lossModel);
3712  Ptr<ConstantSpeedPropagationDelayModel> delayModel =
3713  CreateObject<ConstantSpeedPropagationDelayModel>();
3714  spectrumChannel->SetPropagationDelayModel(delayModel);
3715 
3716  Ptr<ThresholdPreambleDetectionModel> preambleDetectionModel =
3717  CreateObject<ThresholdPreambleDetectionModel>();
3718  preambleDetectionModel->SetAttribute(
3719  "MinimumRssi",
3720  DoubleValue(
3721  -8)); // to ensure that transmission in neighboring channel is ignored (16 dBm baseline)
3722  preambleDetectionModel->SetAttribute("Threshold", DoubleValue(-100)); // no limit on SNR
3723 
3724  Ptr<Node> apNode = CreateObject<Node>();
3725  Ptr<WifiNetDevice> apDev = CreateObject<WifiNetDevice>();
3726  apDev->SetStandard(WIFI_STANDARD_80211ax);
3727  Ptr<ApWifiMac> apMac = CreateObject<ApWifiMac>();
3728  apMac->SetAttribute("BeaconGeneration", BooleanValue(false));
3729  apDev->SetMac(apMac);
3730  m_phyAp = CreateObject<OfdmaSpectrumWifiPhy>(0);
3731  m_phyAp->CreateWifiSpectrumPhyInterface(apDev);
3732  m_phyAp->ConfigureStandard(WIFI_STANDARD_80211ax);
3733  Ptr<HeConfiguration> heConfiguration = CreateObject<HeConfiguration>();
3734  apDev->SetHeConfiguration(heConfiguration);
3735  Ptr<InterferenceHelper> apInterferenceHelper = CreateObject<InterferenceHelper>();
3736  m_phyAp->SetInterferenceHelper(apInterferenceHelper);
3737  Ptr<ErrorRateModel> apErrorModel = CreateObject<NistErrorRateModel>();
3738  m_phyAp->SetErrorRateModel(apErrorModel);
3739  m_phyAp->SetDevice(apDev);
3740  m_phyAp->SetChannel(spectrumChannel);
3741  m_phyAp->SetReceiveOkCallback(MakeCallback(&TestUlOfdmaPhyTransmission::RxSuccess, this));
3742  m_phyAp->SetReceiveErrorCallback(MakeCallback(&TestUlOfdmaPhyTransmission::RxFailure, this));
3743  m_phyAp->SetPreambleDetectionModel(preambleDetectionModel);
3744  Ptr<ConstantPositionMobilityModel> apMobility = CreateObject<ConstantPositionMobilityModel>();
3745  m_phyAp->SetMobility(apMobility);
3746  m_apPhyStateListener = std::make_unique<OfdmaTestPhyListener>();
3747  m_phyAp->RegisterListener(m_apPhyStateListener.get());
3748  apDev->SetPhy(m_phyAp);
3749  apMac->SetWifiPhys({m_phyAp});
3750  apNode->AggregateObject(apMobility);
3751  apNode->AddDevice(apDev);
3752 
3753  Ptr<Node> sta1Node = CreateObject<Node>();
3754  Ptr<WifiNetDevice> sta1Dev = CreateObject<WifiNetDevice>();
3755  sta1Dev->SetStandard(WIFI_STANDARD_80211ax);
3756  sta1Dev->SetHeConfiguration(CreateObject<HeConfiguration>());
3757  m_phySta1 = CreateObject<OfdmaSpectrumWifiPhy>(1);
3758  m_phySta1->CreateWifiSpectrumPhyInterface(sta1Dev);
3759  m_phySta1->ConfigureStandard(WIFI_STANDARD_80211ax);
3760  Ptr<InterferenceHelper> sta1InterferenceHelper = CreateObject<InterferenceHelper>();
3761  m_phySta1->SetInterferenceHelper(sta1InterferenceHelper);
3762  Ptr<ErrorRateModel> sta1ErrorModel = CreateObject<NistErrorRateModel>();
3763  m_phySta1->SetErrorRateModel(sta1ErrorModel);
3764  m_phySta1->SetDevice(sta1Dev);
3765  m_phySta1->SetChannel(spectrumChannel);
3766  m_phySta1->SetPreambleDetectionModel(preambleDetectionModel);
3767  Ptr<ConstantPositionMobilityModel> sta1Mobility = CreateObject<ConstantPositionMobilityModel>();
3768  m_phySta1->SetMobility(sta1Mobility);
3769  sta1Dev->SetPhy(m_phySta1);
3770  sta1Node->AggregateObject(sta1Mobility);
3771  sta1Node->AddDevice(sta1Dev);
3772 
3773  Ptr<Node> sta2Node = CreateObject<Node>();
3774  Ptr<WifiNetDevice> sta2Dev = CreateObject<WifiNetDevice>();
3775  sta2Dev->SetStandard(WIFI_STANDARD_80211ax);
3776  sta2Dev->SetHeConfiguration(CreateObject<HeConfiguration>());
3777  m_phySta2 = CreateObject<OfdmaSpectrumWifiPhy>(2);
3778  m_phySta2->CreateWifiSpectrumPhyInterface(sta2Dev);
3779  m_phySta2->ConfigureStandard(WIFI_STANDARD_80211ax);
3780  Ptr<InterferenceHelper> sta2InterferenceHelper = CreateObject<InterferenceHelper>();
3781  m_phySta2->SetInterferenceHelper(sta2InterferenceHelper);
3782  Ptr<ErrorRateModel> sta2ErrorModel = CreateObject<NistErrorRateModel>();
3783  m_phySta2->SetErrorRateModel(sta2ErrorModel);
3784  m_phySta2->SetDevice(sta2Dev);
3785  m_phySta2->SetChannel(spectrumChannel);
3786  m_phySta2->SetPreambleDetectionModel(preambleDetectionModel);
3787  Ptr<ConstantPositionMobilityModel> sta2Mobility = CreateObject<ConstantPositionMobilityModel>();
3788  m_phySta2->SetMobility(sta2Mobility);
3789  sta2Dev->SetPhy(m_phySta2);
3790  sta2Node->AggregateObject(sta2Mobility);
3791  sta2Node->AddDevice(sta2Dev);
3792 
3793  Ptr<Node> sta3Node = CreateObject<Node>();
3794  Ptr<WifiNetDevice> sta3Dev = CreateObject<WifiNetDevice>();
3795  sta3Dev->SetStandard(WIFI_STANDARD_80211ax);
3796  sta3Dev->SetHeConfiguration(CreateObject<HeConfiguration>());
3797  m_phySta3 = CreateObject<OfdmaSpectrumWifiPhy>(3);
3798  m_phySta3->CreateWifiSpectrumPhyInterface(sta3Dev);
3799  m_phySta3->ConfigureStandard(WIFI_STANDARD_80211ax);
3800  Ptr<InterferenceHelper> sta3InterferenceHelper = CreateObject<InterferenceHelper>();
3801  m_phySta3->SetInterferenceHelper(sta3InterferenceHelper);
3802  Ptr<ErrorRateModel> sta3ErrorModel = CreateObject<NistErrorRateModel>();
3803  m_phySta3->SetErrorRateModel(sta3ErrorModel);
3804  m_phySta3->SetDevice(sta3Dev);
3805  m_phySta3->SetChannel(spectrumChannel);
3806  m_phySta3->SetPreambleDetectionModel(preambleDetectionModel);
3807  Ptr<ConstantPositionMobilityModel> sta3Mobility = CreateObject<ConstantPositionMobilityModel>();
3808  m_phySta3->SetMobility(sta3Mobility);
3809  sta3Dev->SetPhy(m_phySta3);
3810  sta3Node->AggregateObject(sta3Mobility);
3811  sta3Node->AddDevice(sta3Dev);
3812 
3813  Ptr<Node> interfererNode = CreateObject<Node>();
3814  Ptr<NonCommunicatingNetDevice> interfererDev = CreateObject<NonCommunicatingNetDevice>();
3815  m_phyInterferer = CreateObject<WaveformGenerator>();
3816  m_phyInterferer->SetDevice(interfererDev);
3817  m_phyInterferer->SetChannel(spectrumChannel);
3818  m_phyInterferer->SetDutyCycle(1);
3819  interfererNode->AddDevice(interfererDev);
3820 
3821  // Configure power attributes of all wifi devices
3822  std::list<Ptr<WifiPhy>> phys{m_phyAp, m_phySta1, m_phySta2, m_phySta3};
3823  for (auto& phy : phys)
3824  {
3825  phy->SetAttribute("TxGain", DoubleValue(1.0));
3826  phy->SetAttribute("TxPowerStart", DoubleValue(16.0));
3827  phy->SetAttribute("TxPowerEnd", DoubleValue(16.0));
3828  phy->SetAttribute("PowerDensityLimit", DoubleValue(100.0)); // no impact by default
3829  phy->SetAttribute("RxGain", DoubleValue(2.0));
3830  // test assumes no rejection power for simplicity
3831  phy->SetAttribute("TxMaskInnerBandMinimumRejection", DoubleValue(-100.0));
3832  phy->SetAttribute("TxMaskOuterBandMinimumRejection", DoubleValue(-100.0));
3833  phy->SetAttribute("TxMaskOuterBandMaximumRejection", DoubleValue(-100.0));
3834  }
3835 }
3836 
3837 void
3838 TestUlOfdmaPhyTransmission::DoTeardown()
3839 {
3840  m_phyAp->Dispose();
3841  m_phyAp = nullptr;
3842  m_phySta1->Dispose();
3843  m_phySta1 = nullptr;
3844  m_phySta2->Dispose();
3845  m_phySta2 = nullptr;
3846  m_phySta3->Dispose();
3847  m_phySta3 = nullptr;
3848  m_phyInterferer->Dispose();
3849  m_phyInterferer = nullptr;
3850 }
3851 
3852 void
3853 TestUlOfdmaPhyTransmission::LogScenario(std::string log) const
3854 {
3855  NS_LOG_INFO(log);
3856 }
3857 
3858 void
3859 TestUlOfdmaPhyTransmission::ScheduleTest(Time delay,
3860  bool solicited,
3861  WifiPhyState expectedStateAtEnd,
3862  uint32_t expectedSuccessFromSta1,
3863  uint32_t expectedFailuresFromSta1,
3864  uint32_t expectedBytesFromSta1,
3865  uint32_t expectedSuccessFromSta2,
3866  uint32_t expectedFailuresFromSta2,
3867  uint32_t expectedBytesFromSta2,
3868  bool scheduleTxSta1,
3869  Time ulTimeDifference,
3870  WifiPhyState expectedStateBeforeEnd,
3871  TrigVectorInfo error)
3872 {
3873  static uint64_t uid = 0;
3874 
3875  // AP sends an SU packet preceding HE TB PPDUs
3876  Simulator::Schedule(delay - MilliSeconds(10),
3877  &TestUlOfdmaPhyTransmission::SendHeSuPpdu,
3878  this,
3879  0,
3880  50,
3881  ++uid,
3882  0);
3883  if (!solicited)
3884  {
3885  // UID of TB PPDUs will be different than the one of the preceding frame
3886  ++uid;
3887  }
3888  else
3889  {
3890  Simulator::Schedule(delay, &TestUlOfdmaPhyTransmission::SetTrigVector, this, 0, error);
3891  }
3892  // STA1 and STA2 send MU UL PPDUs addressed to AP
3893  Simulator::Schedule(delay - MilliSeconds(1),
3894  &OfdmaTestPhyListener::Reset,
3895  m_apPhyStateListener.get());
3896  if (scheduleTxSta1)
3897  {
3898  Simulator::Schedule(delay,
3899  &TestUlOfdmaPhyTransmission::SendHeTbPpdu,
3900  this,
3901  1,
3902  1,
3903  1000,
3904  uid,
3905  0,
3906  false);
3907  }
3908  Simulator::Schedule(delay + ulTimeDifference,
3909  &TestUlOfdmaPhyTransmission::SendHeTbPpdu,
3910  this,
3911  2,
3912  2,
3913  1001,
3914  uid,
3915  0,
3916  false);
3917 
3918  // Verify it takes m_expectedPpduDuration to transmit the PPDUs
3919  Simulator::Schedule(delay + m_expectedPpduDuration - NanoSeconds(1),
3920  &TestUlOfdmaPhyTransmission::CheckPhyState,
3921  this,
3922  m_phyAp,
3923  expectedStateBeforeEnd);
3924  Simulator::Schedule(delay + m_expectedPpduDuration + ulTimeDifference,
3925  &TestUlOfdmaPhyTransmission::CheckPhyState,
3926  this,
3927  m_phyAp,
3928  expectedStateAtEnd);
3929  // TODO: add checks on TX stop for STAs
3930 
3931  if (expectedSuccessFromSta1 + expectedFailuresFromSta1 + expectedSuccessFromSta2 +
3932  expectedFailuresFromSta2 >
3933  0)
3934  {
3935  // RxEndOk if at least one HE TB PPDU has been successfully received, RxEndError otherwise
3936  const bool isSuccess = (expectedSuccessFromSta1 > 0) || (expectedSuccessFromSta2 > 0);
3937  // The expected time at which the reception is started corresponds to the time at which the
3938  // test is started, plus the time to transmit the PHY preamble and the PHY headers.
3939  const Time expectedPayloadStart = delay + MicroSeconds(48);
3940  // The expected time at which the reception is terminated corresponds to the time at which
3941  // the test is started, plus the time to transmit the PPDU, plus the delay between the first
3942  // received HE TB PPDU and the last received HE TB PPDU.
3943  const Time expectedPayloadEnd = delay + m_expectedPpduDuration + ulTimeDifference;
3944  // At the end of the transmission, verify that a single RX start notification shall have
3945  // been notified when the reception of the first HE RB PPDU starts.
3946  Simulator::Schedule(expectedPayloadEnd,
3947  &TestUlOfdmaPhyTransmission::CheckApRxStart,
3948  this,
3949  1,
3950  Simulator::Now() + expectedPayloadStart);
3951  // After the reception (hence we add 1ns to expectedPayloadEnd), a single RX end
3952  // notification shall have been notified when the reception of the last HE RB PPDU ends
3953  Simulator::Schedule(expectedPayloadEnd + NanoSeconds(1),
3954  &TestUlOfdmaPhyTransmission::CheckApRxEnd,
3955  this,
3956  1,
3957  Simulator::Now() + expectedPayloadEnd,
3958  isSuccess);
3959  }
3960 
3961  delay += MilliSeconds(100);
3962  // Check reception state from STA 1
3963  Simulator::Schedule(delay,
3964  &TestUlOfdmaPhyTransmission::CheckRxFromSta1,
3965  this,
3966  expectedSuccessFromSta1,
3967  expectedFailuresFromSta1,
3968  expectedBytesFromSta1);
3969  // Check reception state from STA 2
3970  Simulator::Schedule(delay,
3971  &TestUlOfdmaPhyTransmission::CheckRxFromSta2,
3972  this,
3973  expectedSuccessFromSta2,
3974  expectedFailuresFromSta2,
3975  expectedBytesFromSta2);
3976  // Verify events data have been cleared
3977  Simulator::Schedule(delay, &TestUlOfdmaPhyTransmission::VerifyEventsCleared, this);
3978 
3979  delay += MilliSeconds(100);
3980  Simulator::Schedule(delay, &TestUlOfdmaPhyTransmission::Reset, this);
3981 }
3982 
3983 void
3984 TestUlOfdmaPhyTransmission::SchedulePowerMeasurementChecks(Time delay,
3985  double rxPowerNonOfdmaRu1,
3986  double rxPowerNonOfdmaRu2,
3987  double rxPowerOfdmaRu1,
3988  double rxPowerOfdmaRu2)
3989 {
3990  Time detectionDuration = WifiPhy::GetPreambleDetectionDuration();
3991  WifiTxVector txVectorSta1 = GetTxVectorForHeTbPpdu(1, 1, 0);
3992  WifiTxVector txVectorSta2 = GetTxVectorForHeTbPpdu(2, 2, 0);
3993  Ptr<const HePhy> hePhy = m_phyAp->GetHePhy();
3994  Time nonOfdmaDuration = hePhy->CalculateNonOfdmaDurationForHeTb(txVectorSta2);
3995  NS_ASSERT(nonOfdmaDuration == hePhy->CalculateNonOfdmaDurationForHeTb(txVectorSta1));
3996 
3997  std::vector<double> rxPowerNonOfdma{rxPowerNonOfdmaRu1, rxPowerNonOfdmaRu2};
3998  std::vector<WifiSpectrumBand> nonOfdmaBand{hePhy->GetNonOfdmaBand(txVectorSta1, 1),
3999  hePhy->GetNonOfdmaBand(txVectorSta2, 2)};
4000  std::vector<double> rxPowerOfdma{rxPowerOfdmaRu1, rxPowerOfdmaRu2};
4001  std::vector<WifiSpectrumBand> ofdmaBand{hePhy->GetRuBandForRx(txVectorSta1, 1),
4002  hePhy->GetRuBandForRx(txVectorSta2, 2)};
4003 
4004  for (uint8_t i = 0; i < 2; ++i)
4005  {
4009  // Check received power on non-OFDMA portion
4010  Simulator::Schedule(
4011  delay + detectionDuration +
4012  NanoSeconds(1), // just after beginning of portion (once event is stored)
4013  &TestUlOfdmaPhyTransmission::CheckNonOfdmaRxPower,
4014  this,
4015  m_phyAp,
4016  nonOfdmaBand[i],
4017  rxPowerNonOfdma[i]);
4018  Simulator::Schedule(delay + nonOfdmaDuration - NanoSeconds(1), // just before end of portion
4019  &TestUlOfdmaPhyTransmission::CheckNonOfdmaRxPower,
4020  this,
4021  m_phyAp,
4022  nonOfdmaBand[i],
4023  rxPowerNonOfdma[i]);
4024  // Check received power on OFDMA portion
4025  Simulator::Schedule(delay + nonOfdmaDuration +
4026  NanoSeconds(1), // just after beginning of portion
4027  &TestUlOfdmaPhyTransmission::CheckOfdmaRxPower,
4028  this,
4029  m_phyAp,
4030  ofdmaBand[i],
4031  rxPowerOfdma[i]);
4032  Simulator::Schedule(delay + m_expectedPpduDuration -
4033  NanoSeconds(1), // just before end of portion
4034  &TestUlOfdmaPhyTransmission::CheckOfdmaRxPower,
4035  this,
4036  m_phyAp,
4037  ofdmaBand[i],
4038  rxPowerOfdma[i]);
4039 
4045  // Check received power on non-OFDMA portion
4046  Simulator::Schedule(
4047  delay + detectionDuration +
4048  NanoSeconds(1), // just after beginning of portion (once event is stored)
4049  &TestUlOfdmaPhyTransmission::CheckOfdmaRxPower,
4050  this,
4051  m_phySta3,
4052  nonOfdmaBand[i],
4053  rxPowerNonOfdma[i]);
4054  Simulator::Schedule(delay + nonOfdmaDuration - NanoSeconds(1), // just before end of portion
4055  &TestUlOfdmaPhyTransmission::CheckOfdmaRxPower,
4056  this,
4057  m_phySta3,
4058  nonOfdmaBand[i],
4059  rxPowerNonOfdma[i]);
4060  // Check received power on OFDMA portion
4061  Simulator::Schedule(delay + nonOfdmaDuration +
4062  NanoSeconds(1), // just after beginning of portion
4063  &TestUlOfdmaPhyTransmission::CheckOfdmaRxPower,
4064  this,
4065  m_phySta3,
4066  ofdmaBand[i],
4067  rxPowerOfdma[i]);
4068  Simulator::Schedule(delay + m_expectedPpduDuration -
4069  NanoSeconds(1), // just before end of portion
4070  &TestUlOfdmaPhyTransmission::CheckOfdmaRxPower,
4071  this,
4072  m_phySta3,
4073  ofdmaBand[i],
4074  rxPowerOfdma[i]);
4075  }
4076 
4077  if (rxPowerOfdmaRu1 != 0.0)
4078  {
4084  double rxPowerNonOfdmaSta1Only =
4085  (m_channelWidth >= 40)
4086  ? rxPowerNonOfdma[0]
4087  : rxPowerNonOfdma[0] / 2; // both STAs transmit over the same 20 MHz channel
4088  // Check received power on non-OFDMA portion
4089  Simulator::Schedule(
4090  delay + detectionDuration +
4091  NanoSeconds(1), // just after beginning of portion (once event is stored)
4092  &TestUlOfdmaPhyTransmission::CheckOfdmaRxPower,
4093  this,
4094  m_phySta2,
4095  nonOfdmaBand[0],
4096  rxPowerNonOfdmaSta1Only);
4097  Simulator::Schedule(delay + nonOfdmaDuration - NanoSeconds(1), // just before end of portion
4098  &TestUlOfdmaPhyTransmission::CheckOfdmaRxPower,
4099  this,
4100  m_phySta2,
4101  nonOfdmaBand[0],
4102  rxPowerNonOfdmaSta1Only);
4103  // Check received power on OFDMA portion
4104  Simulator::Schedule(delay + nonOfdmaDuration +
4105  NanoSeconds(1), // just after beginning of portion
4106  &TestUlOfdmaPhyTransmission::CheckOfdmaRxPower,
4107  this,
4108  m_phySta2,
4109  ofdmaBand[0],
4110  rxPowerOfdma[0]);
4111  Simulator::Schedule(delay + m_expectedPpduDuration -
4112  NanoSeconds(1), // just before end of portion
4113  &TestUlOfdmaPhyTransmission::CheckOfdmaRxPower,
4114  this,
4115  m_phySta2,
4116  ofdmaBand[0],
4117  rxPowerOfdma[0]);
4118  }
4119 }
4120 
4121 void
4122 TestUlOfdmaPhyTransmission::RunOne()
4123 {
4124  RngSeedManager::SetSeed(1);
4125  RngSeedManager::SetRun(1);
4126  int64_t streamNumber = 0;
4127  m_phyAp->AssignStreams(streamNumber);
4128  m_phySta1->AssignStreams(streamNumber);
4129  m_phySta2->AssignStreams(streamNumber);
4130  m_phySta3->AssignStreams(streamNumber);
4131 
4132  auto channelNum = std::get<0>(*WifiPhyOperatingChannel::FindFirst(0,
4133  m_frequency,
4134  m_channelWidth,
4135  WIFI_STANDARD_80211ax,
4136  WIFI_PHY_BAND_5GHZ));
4137 
4138  m_phyAp->SetOperatingChannel(
4139  WifiPhy::ChannelTuple{channelNum, m_channelWidth, (int)(WIFI_PHY_BAND_5GHZ), 0});
4140  m_phySta1->SetOperatingChannel(
4141  WifiPhy::ChannelTuple{channelNum, m_channelWidth, (int)(WIFI_PHY_BAND_5GHZ), 0});
4142  m_phySta2->SetOperatingChannel(
4143  WifiPhy::ChannelTuple{channelNum, m_channelWidth, (int)(WIFI_PHY_BAND_5GHZ), 0});
4144  m_phySta3->SetOperatingChannel(
4145  WifiPhy::ChannelTuple{channelNum, m_channelWidth, (int)(WIFI_PHY_BAND_5GHZ), 0});
4146 
4147  Time delay = Seconds(0.0);
4148  Simulator::Schedule(delay, &TestUlOfdmaPhyTransmission::Reset, this);
4149  delay += Seconds(1.0);
4150 
4159  //---------------------------------------------------------------------------
4160  // Verify that both solicited HE TB PPDUs have been corrected received
4161  Simulator::Schedule(delay,
4162  &TestUlOfdmaPhyTransmission::LogScenario,
4163  this,
4164  "Reception of solicited HE TB PPDUs");
4165  ScheduleTest(delay,
4166  true,
4167  WifiPhyState::IDLE,
4168  1,
4169  0,
4170  1000, // One PSDU of 1000 bytes should have been successfully received from STA 1
4171  1,
4172  0,
4173  1001); // One PSDU of 1001 bytes should have been successfully received from STA 2
4174  delay += Seconds(1.0);
4175 
4176  //---------------------------------------------------------------------------
4177  // Verify that two solicited HE TB PPDUs with delay (< 400ns) between the two signals have been
4178  // corrected received
4179  Simulator::Schedule(
4180  delay,
4181  &TestUlOfdmaPhyTransmission::LogScenario,
4182  this,
4183  "Reception of solicited HE TB PPDUs with delay (< 400ns) between the two signals");
4184  ScheduleTest(delay,
4185  true,
4186  WifiPhyState::IDLE,
4187  1,
4188  0,
4189  1000, // One PSDU of 1000 bytes should have been successfully received from STA 1
4190  1,
4191  0,
4192  1001, // One PSDU of 1001 bytes should have been successfully received from STA 2
4193  true,
4194  NanoSeconds(100));
4195  delay += Seconds(1.0);
4196 
4197  //---------------------------------------------------------------------------
4198  // Verify that no unsolicited HE TB PPDU is received
4199  Simulator::Schedule(delay,
4200  &TestUlOfdmaPhyTransmission::LogScenario,
4201  this,
4202  "Dropping of unsolicited HE TB PPDUs");
4203  ScheduleTest(delay,
4204  false,
4205  WifiPhyState::IDLE,
4206  0,
4207  0,
4208  0, // PSDU from STA 1 is not received (no TRIGVECTOR)
4209  0,
4210  0,
4211  0, // PSDU from STA 2 is not received (no TRIGVECTOR)
4212  true,
4213  Seconds(0),
4214  WifiPhyState::CCA_BUSY);
4215  delay += Seconds(1.0);
4216 
4217  //---------------------------------------------------------------------------
4218  // Verify that HE TB PPDUs with channel width differing from TRIGVECTOR are discarded
4219  Simulator::Schedule(delay,
4220  &TestUlOfdmaPhyTransmission::LogScenario,
4221  this,
4222  "Dropping of HE TB PPDUs with channel width differing from TRIGVECTOR");
4223  ScheduleTest(delay,
4224  true,
4225  WifiPhyState::IDLE,
4226  0,
4227  0,
4228  0, // PSDU from STA 1 is not received (no TRIGVECTOR)
4229  0,
4230  0,
4231  0, // PSDU from STA 2 is not received (no TRIGVECTOR)
4232  true,
4233  Seconds(0),
4234  WifiPhyState::CCA_BUSY,
4235  CHANNEL_WIDTH);
4236  delay += Seconds(1.0);
4237 
4238  //---------------------------------------------------------------------------
4239  // Verify that HE TB PPDUs with UL Length differing from TRIGVECTOR are discarded
4240  Simulator::Schedule(delay,
4241  &TestUlOfdmaPhyTransmission::LogScenario,
4242  this,
4243  "Dropping of HE TB PPDUs with UL Length differing from TRIGVECTOR");
4244  ScheduleTest(delay,
4245  true,
4246  WifiPhyState::IDLE,
4247  0,
4248  0,
4249  0, // PSDU from STA 1 is not received (no TRIGVECTOR)
4250  0,
4251  0,
4252  0, // PSDU from STA 2 is not received (no TRIGVECTOR)
4253  true,
4254  Seconds(0),
4255  WifiPhyState::CCA_BUSY,
4256  UL_LENGTH);
4257  delay += Seconds(1.0);
4258 
4259  //---------------------------------------------------------------------------
4260  // Verify that HE TB PPDUs with AIDs differing from TRIGVECTOR are discarded
4261  Simulator::Schedule(delay,
4262  &TestUlOfdmaPhyTransmission::LogScenario,
4263  this,
4264  "Dropping of HE TB PPDUs with AIDs differing from TRIGVECTOR");
4265  ScheduleTest(delay,
4266  true,
4267  WifiPhyState::IDLE,
4268  0,
4269  0,
4270  0, // PSDU from STA 1 is not received (no TRIGVECTOR)
4271  0,
4272  0,
4273  0, // PSDU from STA 2 is not received (no TRIGVECTOR)
4274  true,
4275  Seconds(0),
4276  WifiPhyState::CCA_BUSY,
4277  AID);
4278  delay += Seconds(1.0);
4279 
4280  //---------------------------------------------------------------------------
4281  // Generate an interference on RU 1 and verify that only STA 1's solicited HE TB PPDU has been
4282  // impacted
4283  Simulator::Schedule(
4284  delay,
4285  &TestUlOfdmaPhyTransmission::LogScenario,
4286  this,
4287  "Reception of solicited HE TB PPDUs with interference on RU 1 during PSDU reception");
4288  // A strong non-wifi interference is generated on RU 1 during PSDU reception
4289  BandInfo bandInfo;
4290  bandInfo.fc = (m_frequency - (m_channelWidth / 4)) * 1e6;
4291  bandInfo.fl = bandInfo.fc - ((m_channelWidth / 4) * 1e6);
4292  bandInfo.fh = bandInfo.fc + ((m_channelWidth / 4) * 1e6);
4293  Bands bands;
4294  bands.push_back(bandInfo);
4295 
4296  Ptr<SpectrumModel> SpectrumInterferenceRu1 = Create<SpectrumModel>(bands);
4297  Ptr<SpectrumValue> interferencePsdRu1 = Create<SpectrumValue>(SpectrumInterferenceRu1);
4298  double interferencePower = 0.1; // watts
4299  *interferencePsdRu1 = interferencePower / ((m_channelWidth / 2) * 20e6);
4300 
4301  Simulator::Schedule(delay + MicroSeconds(50),
4302  &TestUlOfdmaPhyTransmission::GenerateInterference,
4303  this,
4304  interferencePsdRu1,
4305  MilliSeconds(100));
4306  ScheduleTest(
4307  delay,
4308  true,
4309  WifiPhyState::CCA_BUSY, // PHY should move to CCA_BUSY instead of IDLE due to the
4310  // interference
4311  0,
4312  1,
4313  0, // Reception of the PSDU from STA 1 should have failed (since interference occupies RU 1)
4314  1,
4315  0,
4316  1001); // One PSDU of 1001 bytes should have been successfully received from STA 2
4317  delay += Seconds(1.0);
4318 
4319  //---------------------------------------------------------------------------
4320  // Generate an interference on RU 2 and verify that only STA 2's solicited HE TB PPDU has been
4321  // impacted
4322  Simulator::Schedule(
4323  delay,
4324  &TestUlOfdmaPhyTransmission::LogScenario,
4325  this,
4326  "Reception of solicited HE TB PPDUs with interference on RU 2 during PSDU reception");
4327  // A strong non-wifi interference is generated on RU 2 during PSDU reception
4328  bandInfo.fc = (m_frequency + (m_channelWidth / 4)) * 1e6;
4329  bandInfo.fl = bandInfo.fc - ((m_channelWidth / 4) * 1e6);
4330  bandInfo.fh = bandInfo.fc + ((m_channelWidth / 4) * 1e6);
4331  bands.clear();
4332  bands.push_back(bandInfo);
4333 
4334  Ptr<SpectrumModel> SpectrumInterferenceRu2 = Create<SpectrumModel>(bands);
4335  Ptr<SpectrumValue> interferencePsdRu2 = Create<SpectrumValue>(SpectrumInterferenceRu2);
4336  *interferencePsdRu2 = interferencePower / ((m_channelWidth / 2) * 20e6);
4337 
4338  Simulator::Schedule(delay + MicroSeconds(50),
4339  &TestUlOfdmaPhyTransmission::GenerateInterference,
4340  this,
4341  interferencePsdRu2,
4342  MilliSeconds(100));
4343  ScheduleTest(delay,
4344  true,
4345  (m_channelWidth >= 40)
4346  ? WifiPhyState::IDLE
4347  : WifiPhyState::CCA_BUSY, // PHY should move to CCA_BUSY if interference is
4348  // generated in its primary channel
4349  1,
4350  0,
4351  1000, // One PSDU of 1000 bytes should have been successfully received from STA 1
4352  0,
4353  1,
4354  0); // Reception of the PSDU from STA 2 should have failed (since interference
4355  // occupies RU 2)
4356  delay += Seconds(1.0);
4357 
4358  //---------------------------------------------------------------------------
4359  // Generate an interference on the full band and verify that both solicited HE TB PPDUs have
4360  // been impacted
4361  Simulator::Schedule(delay,
4362  &TestUlOfdmaPhyTransmission::LogScenario,
4363  this,
4364  "Reception of solicited HE TB PPDUs with interference on the full band "
4365  "during PSDU reception");
4366  // A strong non-wifi interference is generated on the full band during PSDU reception
4367  bandInfo.fc = m_frequency * 1e6;
4368  bandInfo.fl = bandInfo.fc - ((m_channelWidth / 2) * 1e6);
4369  bandInfo.fh = bandInfo.fc + ((m_channelWidth / 2) * 1e6);
4370  bands.clear();
4371  bands.push_back(bandInfo);
4372 
4373  Ptr<SpectrumModel> SpectrumInterferenceAll = Create<SpectrumModel>(bands);
4374  Ptr<SpectrumValue> interferencePsdAll = Create<SpectrumValue>(SpectrumInterferenceAll);
4375  *interferencePsdAll = interferencePower / (m_channelWidth * 20e6);
4376 
4377  Simulator::Schedule(delay + MicroSeconds(50),
4378  &TestUlOfdmaPhyTransmission::GenerateInterference,
4379  this,
4380  interferencePsdAll,
4381  MilliSeconds(100));
4382  ScheduleTest(
4383  delay,
4384  true,
4385  WifiPhyState::CCA_BUSY, // PHY should move to CCA_BUSY instead of IDLE due to the
4386  // interference
4387  0,
4388  1,
4389  0, // Reception of the PSDU from STA 1 should have failed (since interference occupies RU 1)
4390  0,
4391  1,
4392  0); // Reception of the PSDU from STA 2 should have failed (since interference occupies RU
4393  // 2)
4394  delay += Seconds(1.0);
4395 
4396  //---------------------------------------------------------------------------
4397  // Send another HE TB PPDU (of another UL MU transmission) on RU 1 and verify that both
4398  // solicited HE TB PPDUs have been impacted if they are on the same
4399  // 20 MHz channel. Only STA 1's solicited HE TB PPDU is impacted otherwise.
4400  Simulator::Schedule(delay,
4401  &TestUlOfdmaPhyTransmission::LogScenario,
4402  this,
4403  "Reception of solicited HE TB PPDUs with another HE TB PPDU arriving on RU "
4404  "1 during PSDU reception");
4405  // Another HE TB PPDU arrives at AP on the same RU as STA 1 during PSDU reception
4406  Simulator::Schedule(delay + MicroSeconds(50),
4407  &TestUlOfdmaPhyTransmission::SendHeTbPpdu,
4408  this,
4409  3,
4410  1,
4411  1002,
4412  1,
4413  0,
4414  false);
4415  // Expected figures from STA 2
4416  uint32_t succ;
4417  uint32_t fail;
4418  uint32_t bytes;
4419  if (m_channelWidth > 20)
4420  {
4421  // One PSDU of 1001 bytes should have been successfully received from STA 2 (since
4422  // interference from STA 3 on distinct 20 MHz channel)
4423  succ = 1;
4424  fail = 0;
4425  bytes = 1001;
4426  }
4427  else
4428  {
4429  // Reception of the PSDU from STA 2 should have failed (since interference from STA 3 on
4430  // same 20 MHz channel)
4431  succ = 0;
4432  fail = 1;
4433  bytes = 0;
4434  }
4435  ScheduleTest(delay,
4436  true,
4437  WifiPhyState::CCA_BUSY, // PHY should move to CCA_BUSY instead of IDLE due to the
4438  // interference on measurement channel width
4439  0,
4440  1,
4441  0, // Reception of the PSDU from STA 1 should have failed (since interference from
4442  // STA 3 on same 20 MHz channel)
4443  succ,
4444  fail,
4445  bytes);
4446  delay += Seconds(1.0);
4447 
4448  //---------------------------------------------------------------------------
4449  // Send another HE TB PPDU (of another UL MU transmission) on RU 2 and verify that both
4450  // solicited HE TB PPDUs have been impacted if they are on the same
4451  // 20 MHz channel. Only STA 2's solicited HE TB PPDU is impacted otherwise.
4452  Simulator::Schedule(delay,
4453  &TestUlOfdmaPhyTransmission::LogScenario,
4454  this,
4455  "Reception of solicited HE TB PPDUs with another HE TB PPDU arriving on RU "
4456  "2 during PSDU reception");
4457  // Another HE TB PPDU arrives at AP on the same RU as STA 2 during PSDU reception
4458  Simulator::Schedule(delay + MicroSeconds(50),
4459  &TestUlOfdmaPhyTransmission::SendHeTbPpdu,
4460  this,
4461  3,
4462  2,
4463  1002,
4464  1,
4465  0,
4466  false);
4467  // Expected figures from STA 1
4468  if (m_channelWidth > 20)
4469  {
4470  // One PSDU of 1000 bytes should have been successfully received from STA 1 (since
4471  // interference from STA 3 on distinct 20 MHz channel)
4472  succ = 1;
4473  fail = 0;
4474  bytes = 1000;
4475  }
4476  else
4477  {
4478  // Reception of the PSDU from STA 1 should have failed (since interference from STA 3 on
4479  // same 20 MHz channel)
4480  succ = 0;
4481  fail = 1;
4482  bytes = 0;
4483  }
4484  ScheduleTest(delay,
4485  true,
4486  (m_channelWidth >= 40)
4487  ? WifiPhyState::IDLE
4488  : WifiPhyState::CCA_BUSY, // PHY should move to CCA_BUSY instead of IDLE if HE
4489  // TB PPDU on primary channel
4490  succ,
4491  fail,
4492  bytes,
4493  0,
4494  1,
4495  0); // Reception of the PSDU from STA 2 should have failed (since interference from
4496  // STA 3 on same 20 MHz channel)
4497  delay += Seconds(1.0);
4498 
4499  //---------------------------------------------------------------------------
4500  // Send an HE SU PPDU during 400 ns window and verify that both solicited HE TB PPDUs have been
4501  // impacted
4502  Simulator::Schedule(
4503  delay,
4504  &TestUlOfdmaPhyTransmission::LogScenario,
4505  this,
4506  "Reception of solicited HE TB PPDUs with an HE SU PPDU arriving during the 400 ns window");
4507  // One HE SU arrives at AP during the 400ns window
4508  Simulator::Schedule(delay + NanoSeconds(300),
4509  &TestUlOfdmaPhyTransmission::SendHeSuPpdu,
4510  this,
4511  3,
4512  1002,
4513  1,
4514  0);
4515  ScheduleTest(
4516  delay,
4517  true,
4518  WifiPhyState::IDLE,
4519  0,
4520  1,
4521  0, // Reception of the PSDU from STA 1 should have failed (since interference from STA 3)
4522  0,
4523  1,
4524  0); // Reception of the PSDU from STA 2 should have failed (since interference from STA 3)
4525  delay += Seconds(1.0);
4526 
4527  //---------------------------------------------------------------------------
4528  // Only send a solicited HE TB PPDU from STA 2 on RU 2 and verify that it has been correctly
4529  // received
4530  Simulator::Schedule(delay,
4531  &TestUlOfdmaPhyTransmission::LogScenario,
4532  this,
4533  "Reception of solicited HE TB PPDU only on RU 2");
4534  // Check that STA3 will correctly set its state to CCA_BUSY if in measurement channel or IDLE
4535  // otherwise
4536  Simulator::Schedule(delay + m_expectedPpduDuration - NanoSeconds(1),
4537  &TestUlOfdmaPhyTransmission::CheckPhyState,
4538  this,
4539  m_phySta3,
4540  (m_channelWidth >= 40)
4541  ? WifiPhyState::IDLE
4542  : WifiPhyState::CCA_BUSY); // PHY should move to CCA_BUSY instead of
4543  // IDLE if HE TB PPDU on primary channel
4544  ScheduleTest(delay,
4545  true,
4546  WifiPhyState::IDLE,
4547  0,
4548  0,
4549  0, // No transmission scheduled for STA 1
4550  1,
4551  0,
4552  1001, // One PSDU of 1001 bytes should have been successfully received from STA 2
4553  false,
4554  Seconds(0),
4555  WifiPhyState::RX); // Measurement channel is total channel width
4556  delay += Seconds(1.0);
4557 
4558  //---------------------------------------------------------------------------
4559  // Measure the power of a solicited HE TB PPDU from STA 2 on RU 2
4560  Simulator::Schedule(delay,
4561  &TestUlOfdmaPhyTransmission::LogScenario,
4562  this,
4563  "Measure power for reception of HE TB PPDU only on RU 2");
4564  double rxPower =
4565  DbmToW(19); // 16+1 dBm at STAs and +2 at AP (no loss since all devices are colocated)
4566  SchedulePowerMeasurementChecks(delay,
4567  (m_channelWidth >= 40) ? 0.0 : rxPower,
4568  rxPower, // power detected on RU1 only if same 20 MHz as RU 2
4569  0.0,
4570  rxPower);
4571  ScheduleTest(delay,
4572  true,
4573  WifiPhyState::IDLE,
4574  0,
4575  0,
4576  0, // No transmission scheduled for STA 1
4577  1,
4578  0,
4579  1001, // One PSDU of 1001 bytes should have been successfully received from STA 2
4580  false,
4581  Seconds(0),
4582  WifiPhyState::RX); // Measurement channel is total channel width
4583  delay += Seconds(1.0);
4584 
4585  //---------------------------------------------------------------------------
4586  // Measure the power of a solicited HE TB PPDU from STA 2 on RU 2 with power spectrum density
4587  // limitation enforced
4588  Simulator::Schedule(
4589  delay,
4590  &TestUlOfdmaPhyTransmission::LogScenario,
4591  this,
4592  "Measure power for reception of HE TB PPDU only on RU 2 with PSD limitation");
4593  // Configure PSD limitation at 3 dBm/MHz -> 3+13.0103=16.0103 dBm max for 20 MHz,
4594  // 3+9.0309=12.0309 dBm max for 106-tone RU, no impact for 40 MHz and above
4595  Simulator::Schedule(delay - NanoSeconds(1), // just before sending HE TB
4596  &TestUlOfdmaPhyTransmission::SetPsdLimit,
4597  this,
4598  m_phySta2,
4599  3.0);
4600 
4601  rxPower = (m_channelWidth > 40)
4602  ? DbmToW(19)
4603  : DbmToW(18.0103); // 15.0103+1 dBm at STA 2 and +2 at AP for non-OFDMA
4604  // transmitted only on one 20 MHz channel
4605  double rxPowerOfdma = rxPower;
4606  if (m_channelWidth <= 40)
4607  {
4608  rxPowerOfdma = (m_channelWidth == 20)
4609  ? DbmToW(14.0309) // 11.0309+1 dBm at STA and +2 at AP if 106-tone RU
4610  : DbmToW(18.0103); // 15.0103+1 dBm at STA 2 and +2 at AP if 242-tone RU
4611  }
4612  SchedulePowerMeasurementChecks(delay,
4613  (m_channelWidth >= 40) ? 0.0 : rxPower,
4614  rxPower, // power detected on RU1 only if same 20 MHz as RU 2
4615  0.0,
4616  rxPowerOfdma);
4617 
4618  // Reset PSD limitation once HE TB has been sent
4619  Simulator::Schedule(delay + m_expectedPpduDuration,
4620  &TestUlOfdmaPhyTransmission::SetPsdLimit,
4621  this,
4622  m_phySta2,
4623  100.0);
4624  ScheduleTest(delay,
4625  true,
4626  WifiPhyState::IDLE,
4627  0,
4628  0,
4629  0, // No transmission scheduled for STA 1
4630  1,
4631  0,
4632  1001, // One PSDU of 1001 bytes should have been successfully received from STA 2
4633  false,
4634  Seconds(0),
4635  WifiPhyState::RX); // Measurement channel is total channel width
4636  delay += Seconds(1.0);
4637 
4638  //---------------------------------------------------------------------------
4639  // Measure the power of 2 solicited HE TB PPDU from both STAs
4640  Simulator::Schedule(delay,
4641  &TestUlOfdmaPhyTransmission::LogScenario,
4642  this,
4643  "Measure power for reception of HE TB PPDU on both RUs");
4644  rxPower = DbmToW(19); // 16+1 dBm at STAs and +2 at AP (no loss since all devices are colocated)
4645  double rxPowerNonOfdma = (m_channelWidth >= 40)
4646  ? rxPower
4647  : rxPower * 2; // both STAs transmit over the same 20 MHz channel
4648  SchedulePowerMeasurementChecks(delay, rxPowerNonOfdma, rxPowerNonOfdma, rxPower, rxPower);
4649  ScheduleTest(delay,
4650  true,
4651  WifiPhyState::IDLE,
4652  1,
4653  0,
4654  1000, // One PSDU of 1000 bytes should have been successfully received from STA 1
4655  1,
4656  0,
4657  1001); // One PSDU of 1001 bytes should have been successfully received from STA 2
4658  delay += Seconds(1.0);
4659 
4660  //---------------------------------------------------------------------------
4661  // Verify that an HE TB PPDU from another BSS has been correctly received (no UL MU transmission
4662  // ongoing)
4663  Simulator::Schedule(delay,
4664  &TestUlOfdmaPhyTransmission::LogScenario,
4665  this,
4666  "Reception of an HE TB PPDU from another BSS");
4667  // One HE TB from another BSS (BSS color 2) arrives at AP (BSS color 1)
4668  Simulator::Schedule(delay, &TestUlOfdmaPhyTransmission::SetBssColor, this, m_phyAp, 1);
4669  Simulator::Schedule(delay + MilliSeconds(100),
4670  &TestUlOfdmaPhyTransmission::SendHeTbPpdu,
4671  this,
4672  3,
4673  1,
4674  1002,
4675  1,
4676  2,
4677  false);
4678 
4679  // Verify events data have been cleared
4680  Simulator::Schedule(delay + MilliSeconds(200),
4681  &TestUlOfdmaPhyTransmission::VerifyEventsCleared,
4682  this);
4683 
4684  Simulator::Schedule(delay + MilliSeconds(500), &TestUlOfdmaPhyTransmission::Reset, this);
4685  delay += Seconds(1.0);
4686 
4687  //---------------------------------------------------------------------------
4688  // Verify that two solicited HE TB PPDUs with delay (< 400ns) between the two signals have been
4689  // corrected received
4690  Simulator::Schedule(
4691  delay,
4692  &TestUlOfdmaPhyTransmission::LogScenario,
4693  this,
4694  "Reception of solicited HE TB PPDUs with delay (< 400ns) between the two signals and "
4695  "reception of an HE TB PPDU from another BSS between the ends of the two HE TB PPDUs");
4696  Simulator::Schedule(delay, &TestUlOfdmaPhyTransmission::SetBssColor, this, m_phyAp, 1);
4697  Simulator::Schedule(delay + m_expectedPpduDuration + NanoSeconds(100),
4698  &TestUlOfdmaPhyTransmission::SendHeTbPpdu,
4699  this,
4700  3,
4701  1,
4702  1002,
4703  1,
4704  2,
4705  true);
4706  ScheduleTest(delay,
4707  true,
4708  WifiPhyState::CCA_BUSY,
4709  1,
4710  0,
4711  1000, // One PSDU of 1000 bytes should have been successfully received from STA 1
4712  1,
4713  0,
4714  1001, // One PSDU of 1001 bytes should have been successfully received from STA 2
4715  true,
4716  NanoSeconds(200));
4717  delay += Seconds(1.0);
4718 
4719  Simulator::Run();
4720 }
4721 
4722 void
4723 TestUlOfdmaPhyTransmission::DoRun()
4724 {
4725  m_frequency = 5180;
4726  m_channelWidth = 20;
4727  m_expectedPpduDuration = NanoSeconds(292800);
4728  NS_LOG_DEBUG("Run UL OFDMA PHY transmission test for " << m_channelWidth << " MHz");
4729  RunOne();
4730 
4731  m_frequency = 5190;
4732  m_channelWidth = 40;
4733  m_expectedPpduDuration = NanoSeconds(163200);
4734  NS_LOG_DEBUG("Run UL OFDMA PHY transmission test for " << m_channelWidth << " MHz");
4735  RunOne();
4736 
4737  m_frequency = 5210;
4738  m_channelWidth = 80;
4739  m_expectedPpduDuration = NanoSeconds(105600);
4740  NS_LOG_DEBUG("Run UL OFDMA PHY transmission test for " << m_channelWidth << " MHz");
4741  RunOne();
4742 
4743  m_frequency = 5250;
4744  m_channelWidth = 160;
4745  m_expectedPpduDuration = NanoSeconds(76800);
4746  NS_LOG_DEBUG("Run UL OFDMA PHY transmission test for " << m_channelWidth << " MHz");
4747  RunOne();
4748 
4749  Simulator::Destroy();
4750 }
4751 
4758 class TestPhyPaddingExclusion : public TestCase
4759 {
4760  public:
4761  TestPhyPaddingExclusion();
4762  ~TestPhyPaddingExclusion() override;
4763 
4764  private:
4765  void DoSetup() override;
4766  void DoTeardown() override;
4767  void DoRun() override;
4768 
4776  void SendHeTbPpdu(uint16_t txStaId,
4777  std::size_t index,
4778  std::size_t payloadSize,
4779  Time txDuration);
4785  void SetTrigVector(Time ppduDuration);
4786 
4792  void GenerateInterference(Ptr<SpectrumValue> interferencePsd, Time duration);
4796  void StopInterference();
4797 
4801  void RunOne();
4802 
4809  void CheckRxFromSta1(uint32_t expectedSuccess,
4810  uint32_t expectedFailures,
4811  uint32_t expectedBytes);
4812 
4819  void CheckRxFromSta2(uint32_t expectedSuccess,
4820  uint32_t expectedFailures,
4821  uint32_t expectedBytes);
4822 
4826  void VerifyEventsCleared();
4827 
4833  void CheckPhyState(Ptr<OfdmaSpectrumWifiPhy> phy, WifiPhyState expectedState);
4835  void DoCheckPhyState(Ptr<OfdmaSpectrumWifiPhy> phy, WifiPhyState expectedState);
4836 
4840  void Reset();
4841 
4849  void RxSuccess(Ptr<const WifiPsdu> psdu,
4850  RxSignalInfo rxSignalInfo,
4851  WifiTxVector txVector,
4852  std::vector<bool> statusPerMpdu);
4853 
4858  void RxFailure(Ptr<const WifiPsdu> psdu);
4859 
4860  Ptr<OfdmaSpectrumWifiPhy> m_phyAp;
4861  Ptr<OfdmaSpectrumWifiPhy> m_phySta1;
4862  Ptr<OfdmaSpectrumWifiPhy> m_phySta2;
4863 
4864  Ptr<WaveformGenerator> m_phyInterferer;
4865 
4866  uint32_t m_countRxSuccessFromSta1;
4867  uint32_t m_countRxSuccessFromSta2;
4868  uint32_t m_countRxFailureFromSta1;
4869  uint32_t m_countRxFailureFromSta2;
4870  uint32_t m_countRxBytesFromSta1;
4871  uint32_t m_countRxBytesFromSta2;
4872 };
4873 
4874 TestPhyPaddingExclusion::TestPhyPaddingExclusion()
4875  : TestCase("PHY padding exclusion test"),
4876  m_countRxSuccessFromSta1(0),
4877  m_countRxSuccessFromSta2(0),
4878  m_countRxFailureFromSta1(0),
4879  m_countRxFailureFromSta2(0),
4880  m_countRxBytesFromSta1(0),
4881  m_countRxBytesFromSta2(0)
4882 {
4883 }
4884 
4885 void
4886 TestPhyPaddingExclusion::SendHeTbPpdu(uint16_t txStaId,
4887  std::size_t index,
4888  std::size_t payloadSize,
4889  Time txDuration)
4890 {
4891  WifiConstPsduMap psdus;
4892 
4893  WifiTxVector txVector = WifiTxVector(HePhy::GetHeMcs7(),
4894  0,
4895  WIFI_PREAMBLE_HE_TB,
4896  1600,
4897  1,
4898  1,
4899  0,
4900  DEFAULT_CHANNEL_WIDTH,
4901  false,
4902  false,
4903  1);
4904 
4905  HeRu::RuSpec ru(HeRu::RU_106_TONE, index, false);
4906  txVector.SetRu(ru, txStaId);
4907  txVector.SetMode(HePhy::GetHeMcs7(), txStaId);
4908  txVector.SetNss(1, txStaId);
4909 
4910  Ptr<Packet> pkt = Create<Packet>(payloadSize);
4911  WifiMacHeader hdr;
4912  hdr.SetType(WIFI_MAC_QOSDATA);
4913  hdr.SetQosTid(0);
4914  hdr.SetAddr1(Mac48Address("00:00:00:00:00:00"));
4915  std::ostringstream addr;
4916  addr << "00:00:00:00:00:0" << txStaId;
4917  hdr.SetAddr2(Mac48Address(addr.str().c_str()));
4918  hdr.SetSequenceNumber(1);
4919  Ptr<WifiPsdu> psdu = Create<WifiPsdu>(pkt, hdr);
4920  psdus.insert(std::make_pair(txStaId, psdu));
4921 
4922  Ptr<OfdmaSpectrumWifiPhy> phy;
4923  if (txStaId == 1)
4924  {
4925  phy = m_phySta1;
4926  }
4927  else if (txStaId == 2)
4928  {
4929  phy = m_phySta2;
4930  }
4931 
4932  txVector.SetLength(
4933  HePhy::ConvertHeTbPpduDurationToLSigLength(txDuration, txVector, phy->GetPhyBand()).first);
4934 
4935  phy->SetPpduUid(0);
4936  phy->Send(psdus, txVector);
4937 }
4938 
4939 void
4940 TestPhyPaddingExclusion::GenerateInterference(Ptr<SpectrumValue> interferencePsd, Time duration)
4941 {
4942  m_phyInterferer->SetTxPowerSpectralDensity(interferencePsd);
4943  m_phyInterferer->SetPeriod(duration);
4944  m_phyInterferer->Start();
4945  Simulator::Schedule(duration, &TestPhyPaddingExclusion::StopInterference, this);
4946 }
4947 
4948 void
4949 TestPhyPaddingExclusion::StopInterference()
4950 {
4951  m_phyInterferer->Stop();
4952 }
4953 
4954 TestPhyPaddingExclusion::~TestPhyPaddingExclusion()
4955 {
4956 }
4957 
4958 void
4959 TestPhyPaddingExclusion::RxSuccess(Ptr<const WifiPsdu> psdu,
4960  RxSignalInfo rxSignalInfo,
4961  WifiTxVector txVector,
4962  std::vector<bool> /*statusPerMpdu*/)
4963 {
4964  NS_LOG_FUNCTION(this << *psdu << psdu->GetAddr2() << rxSignalInfo << txVector);
4965  if (psdu->GetAddr2() == Mac48Address("00:00:00:00:00:01"))
4966  {
4967  m_countRxSuccessFromSta1++;
4968  m_countRxBytesFromSta1 += (psdu->GetSize() - 30);
4969  }
4970  else if (psdu->GetAddr2() == Mac48Address("00:00:00:00:00:02"))
4971  {
4972  m_countRxSuccessFromSta2++;
4973  m_countRxBytesFromSta2 += (psdu->GetSize() - 30);
4974  }
4975 }
4976 
4977 void
4978 TestPhyPaddingExclusion::RxFailure(Ptr<const WifiPsdu> psdu)
4979 {
4980  NS_LOG_FUNCTION(this << *psdu << psdu->GetAddr2());
4981  if (psdu->GetAddr2() == Mac48Address("00:00:00:00:00:01"))
4982  {
4983  m_countRxFailureFromSta1++;
4984  }
4985  else if (psdu->GetAddr2() == Mac48Address("00:00:00:00:00:02"))
4986  {
4987  m_countRxFailureFromSta2++;
4988  }
4989 }
4990 
4991 void
4992 TestPhyPaddingExclusion::CheckRxFromSta1(uint32_t expectedSuccess,
4993  uint32_t expectedFailures,
4994  uint32_t expectedBytes)
4995 {
4996  NS_TEST_ASSERT_MSG_EQ(m_countRxSuccessFromSta1,
4997  expectedSuccess,
4998  "The number of successfully received packets from STA 1 is not correct!");
4999  NS_TEST_ASSERT_MSG_EQ(
5000  m_countRxFailureFromSta1,
5001  expectedFailures,
5002  "The number of unsuccessfuly received packets from STA 1 is not correct!");
5003  NS_TEST_ASSERT_MSG_EQ(m_countRxBytesFromSta1,
5004  expectedBytes,
5005  "The number of bytes received from STA 1 is not correct!");
5006 }
5007 
5008 void
5009 TestPhyPaddingExclusion::CheckRxFromSta2(uint32_t expectedSuccess,
5010  uint32_t expectedFailures,
5011  uint32_t expectedBytes)
5012 {
5013  NS_TEST_ASSERT_MSG_EQ(m_countRxSuccessFromSta2,
5014  expectedSuccess,
5015  "The number of successfully received packets from STA 2 is not correct!");
5016  NS_TEST_ASSERT_MSG_EQ(
5017  m_countRxFailureFromSta2,
5018  expectedFailures,
5019  "The number of unsuccessfuly received packets from STA 2 is not correct!");
5020  NS_TEST_ASSERT_MSG_EQ(m_countRxBytesFromSta2,
5021  expectedBytes,
5022  "The number of bytes received from STA 2 is not correct!");
5023 }
5024 
5025 void
5026 TestPhyPaddingExclusion::VerifyEventsCleared()
5027 {
5028  NS_TEST_ASSERT_MSG_EQ(m_phyAp->GetCurrentEvent(),
5029  nullptr,
5030  "m_currentEvent for AP was not cleared");
5031  NS_TEST_ASSERT_MSG_EQ(m_phySta1->GetCurrentEvent(),
5032  nullptr,
5033  "m_currentEvent for STA 1 was not cleared");
5034  NS_TEST_ASSERT_MSG_EQ(m_phySta2->GetCurrentEvent(),
5035  nullptr,
5036  "m_currentEvent for STA 2 was not cleared");
5037 }
5038 
5039 void
5040 TestPhyPaddingExclusion::CheckPhyState(Ptr<OfdmaSpectrumWifiPhy> phy, WifiPhyState expectedState)
5041 {
5042  // This is needed to make sure PHY state will be checked as the last event if a state change
5043  // occurred at the exact same time as the check
5044  Simulator::ScheduleNow(&TestPhyPaddingExclusion::DoCheckPhyState, this, phy, expectedState);
5045 }
5046 
5047 void
5048 TestPhyPaddingExclusion::DoCheckPhyState(Ptr<OfdmaSpectrumWifiPhy> phy, WifiPhyState expectedState)
5049 {
5050  WifiPhyState currentState = phy->GetState()->GetState();
5051  NS_LOG_FUNCTION(this << currentState);
5052  NS_TEST_ASSERT_MSG_EQ(currentState,
5053  expectedState,
5054  "PHY State " << currentState << " does not match expected state "
5055  << expectedState << " at " << Simulator::Now());
5056 }
5057 
5058 void
5059 TestPhyPaddingExclusion::Reset()
5060 {
5061  m_countRxSuccessFromSta1 = 0;
5062  m_countRxSuccessFromSta2 = 0;
5063  m_countRxFailureFromSta1 = 0;
5064  m_countRxFailureFromSta2 = 0;
5065  m_countRxBytesFromSta1 = 0;
5066  m_countRxBytesFromSta2 = 0;
5067  m_phySta1->SetPpduUid(0);
5068  m_phySta1->SetTriggerFrameUid(0);
5069  m_phySta2->SetTriggerFrameUid(0);
5070 }
5071 
5072 void
5073 TestPhyPaddingExclusion::DoSetup()
5074 {
5075  RngSeedManager::SetSeed(1);
5076  RngSeedManager::SetRun(1);
5077  int64_t streamNumber = 0;
5078 
5079  Ptr<MultiModelSpectrumChannel> spectrumChannel = CreateObject<MultiModelSpectrumChannel>();
5080  Ptr<FriisPropagationLossModel> lossModel = CreateObject<FriisPropagationLossModel>();
5081  lossModel->SetFrequency(DEFAULT_FREQUENCY * 1e6);
5082  spectrumChannel->AddPropagationLossModel(lossModel);
5083  Ptr<ConstantSpeedPropagationDelayModel> delayModel =
5084  CreateObject<ConstantSpeedPropagationDelayModel>();
5085  spectrumChannel->SetPropagationDelayModel(delayModel);
5086 
5087  Ptr<Node> apNode = CreateObject<Node>();
5088  Ptr<WifiNetDevice> apDev = CreateObject<WifiNetDevice>();
5089  Ptr<ApWifiMac> apMac = CreateObject<ApWifiMac>();
5090  apMac->SetAttribute("BeaconGeneration", BooleanValue(false));
5091  apDev->SetMac(apMac);
5092  m_phyAp = CreateObject<OfdmaSpectrumWifiPhy>(0);
5093  m_phyAp->CreateWifiSpectrumPhyInterface(apDev);
5094  m_phyAp->ConfigureStandard(WIFI_STANDARD_80211ax);
5095  Ptr<HeConfiguration> heConfiguration = CreateObject<HeConfiguration>();
5096  apDev->SetHeConfiguration(heConfiguration);
5097  Ptr<InterferenceHelper> apInterferenceHelper = CreateObject<InterferenceHelper>();
5098  m_phyAp->SetInterferenceHelper(apInterferenceHelper);
5099  Ptr<ErrorRateModel> apErrorModel = CreateObject<NistErrorRateModel>();
5100  m_phyAp->SetErrorRateModel(apErrorModel);
5101  m_phyAp->SetDevice(apDev);
5102  m_phyAp->SetChannel(spectrumChannel);
5103  m_phyAp->AssignStreams(streamNumber);
5104  auto channelNum = std::get<0>(*WifiPhyOperatingChannel::FindFirst(0,
5105  DEFAULT_FREQUENCY,
5106  DEFAULT_CHANNEL_WIDTH,
5107  WIFI_STANDARD_80211ax,
5108  WIFI_PHY_BAND_5GHZ));
5109 
5110  m_phyAp->SetOperatingChannel(
5111  WifiPhy::ChannelTuple{channelNum, DEFAULT_CHANNEL_WIDTH, (int)(WIFI_PHY_BAND_5GHZ), 0});
5112  m_phyAp->SetReceiveOkCallback(MakeCallback(&TestPhyPaddingExclusion::RxSuccess, this));
5113  m_phyAp->SetReceiveErrorCallback(MakeCallback(&TestPhyPaddingExclusion::RxFailure, this));
5114  Ptr<ConstantPositionMobilityModel> apMobility = CreateObject<ConstantPositionMobilityModel>();
5115  m_phyAp->SetMobility(apMobility);
5116  apDev->SetPhy(m_phyAp);
5117  apDev->SetStandard(WIFI_STANDARD_80211ax);
5118  apDev->SetHeConfiguration(CreateObject<HeConfiguration>());
5119  apMac->SetWifiPhys({m_phyAp});
5120  apNode->AggregateObject(apMobility);
5121  apNode->AddDevice(apDev);
5122 
5123  Ptr<Node> sta1Node = CreateObject<Node>();
5124  Ptr<WifiNetDevice> sta1Dev = CreateObject<WifiNetDevice>();
5125  m_phySta1 = CreateObject<OfdmaSpectrumWifiPhy>(1);
5126  m_phySta1->CreateWifiSpectrumPhyInterface(sta1Dev);
5127  m_phySta1->ConfigureStandard(WIFI_STANDARD_80211ax);
5128  Ptr<InterferenceHelper> sta1InterferenceHelper = CreateObject<InterferenceHelper>();
5129  m_phySta1->SetInterferenceHelper(sta1InterferenceHelper);
5130  Ptr<ErrorRateModel> sta1ErrorModel = CreateObject<NistErrorRateModel>();
5131  m_phySta1->SetErrorRateModel(sta1ErrorModel);
5132  m_phySta1->SetDevice(sta1Dev);
5133  m_phySta1->SetChannel(spectrumChannel);
5134  m_phySta1->AssignStreams(streamNumber);
5135  m_phySta1->SetOperatingChannel(
5136  WifiPhy::ChannelTuple{channelNum, DEFAULT_CHANNEL_WIDTH, (int)(WIFI_PHY_BAND_5GHZ), 0});
5137  Ptr<ConstantPositionMobilityModel> sta1Mobility = CreateObject<ConstantPositionMobilityModel>();
5138  m_phySta1->SetMobility(sta1Mobility);
5139  sta1Dev->SetPhy(m_phySta1);
5140  sta1Dev->SetStandard(WIFI_STANDARD_80211ax);
5141  sta1Dev->SetHeConfiguration(CreateObject<HeConfiguration>());
5142  sta1Node->AggregateObject(sta1Mobility);
5143  sta1Node->AddDevice(sta1Dev);
5144 
5145  Ptr<Node> sta2Node = CreateObject<Node>();
5146  Ptr<WifiNetDevice> sta2Dev = CreateObject<WifiNetDevice>();
5147  m_phySta2 = CreateObject<OfdmaSpectrumWifiPhy>(2);
5148  m_phySta2->CreateWifiSpectrumPhyInterface(sta2Dev);
5149  m_phySta2->ConfigureStandard(WIFI_STANDARD_80211ax);
5150  Ptr<InterferenceHelper> sta2InterferenceHelper = CreateObject<InterferenceHelper>();
5151  m_phySta2->SetInterferenceHelper(sta2InterferenceHelper);
5152  Ptr<ErrorRateModel> sta2ErrorModel = CreateObject<NistErrorRateModel>();
5153  m_phySta2->SetErrorRateModel(sta2ErrorModel);
5154  m_phySta2->SetDevice(sta2Dev);
5155  m_phySta2->SetChannel(spectrumChannel);
5156  m_phySta2->AssignStreams(streamNumber);
5157  m_phySta2->SetOperatingChannel(
5158  WifiPhy::ChannelTuple{channelNum, DEFAULT_CHANNEL_WIDTH, (int)(WIFI_PHY_BAND_5GHZ), 0});
5159  Ptr<ConstantPositionMobilityModel> sta2Mobility = CreateObject<ConstantPositionMobilityModel>();
5160  m_phySta2->SetMobility(sta2Mobility);
5161  sta2Dev->SetPhy(m_phySta2);
5162  sta2Dev->SetStandard(WIFI_STANDARD_80211ax);
5163  sta2Dev->SetHeConfiguration(CreateObject<HeConfiguration>());
5164  sta2Node->AggregateObject(sta2Mobility);
5165  sta2Node->AddDevice(sta2Dev);
5166 
5167  Ptr<Node> interfererNode = CreateObject<Node>();
5168  Ptr<NonCommunicatingNetDevice> interfererDev = CreateObject<NonCommunicatingNetDevice>();
5169  m_phyInterferer = CreateObject<WaveformGenerator>();
5170  m_phyInterferer->SetDevice(interfererDev);
5171  m_phyInterferer->SetChannel(spectrumChannel);
5172  m_phyInterferer->SetDutyCycle(1);
5173  interfererNode->AddDevice(interfererDev);
5174 }
5175 
5176 void
5177 TestPhyPaddingExclusion::DoTeardown()
5178 {
5179  m_phyAp->Dispose();
5180  m_phyAp = nullptr;
5181  m_phySta1->Dispose();
5182  m_phySta1 = nullptr;
5183  m_phySta2->Dispose();
5184  m_phySta2 = nullptr;
5185  m_phyInterferer->Dispose();
5186  m_phyInterferer = nullptr;
5187 }
5188 
5189 void
5190 TestPhyPaddingExclusion::SetTrigVector(Time ppduDuration)
5191 {
5192  WifiTxVector trigVector(HePhy::GetHeMcs7(),
5193  0,
5194  WIFI_PREAMBLE_HE_TB,
5195  1600,
5196  1,
5197  1,
5198  0,
5199  DEFAULT_CHANNEL_WIDTH,
5200  false,
5201  false,
5202  1);
5203  trigVector.SetRu(HeRu::RuSpec(HeRu::RU_106_TONE, 1, false), 1);
5204  trigVector.SetMode(HePhy::GetHeMcs7(), 1);
5205  trigVector.SetNss(1, 1);
5206  trigVector.SetRu(HeRu::RuSpec(HeRu::RU_106_TONE, 2, false), 2);
5207  trigVector.SetMode(HePhy::GetHeMcs7(), 2);
5208  trigVector.SetNss(1, 2);
5209  uint16_t length;
5210  std::tie(length, ppduDuration) =
5211  HePhy::ConvertHeTbPpduDurationToLSigLength(ppduDuration, trigVector, m_phyAp->GetPhyBand());
5212  trigVector.SetLength(length);
5213  auto hePhyAp = DynamicCast<HePhy>(m_phyAp->GetLatestPhyEntity());
5214  hePhyAp->SetTrigVector(trigVector, ppduDuration);
5215 }
5216 
5217 void
5218 TestPhyPaddingExclusion::DoRun()
5219 {
5220  Time expectedPpduDuration = NanoSeconds(292800);
5221  Time ppduWithPaddingDuration =
5222  expectedPpduDuration + 10 * NanoSeconds(12800 + 1600 /* GI */); // add 10 extra OFDM symbols
5223 
5224  Simulator::Schedule(Seconds(0.0), &TestPhyPaddingExclusion::Reset, this);
5225 
5226  // STA1 and STA2 send MU UL PPDUs addressed to AP:
5227  Simulator::Schedule(Seconds(1.0),
5228  &TestPhyPaddingExclusion::SendHeTbPpdu,
5229  this,
5230  1,
5231  1,
5232  1000,
5233  ppduWithPaddingDuration);
5234  Simulator::Schedule(Seconds(1.0),
5235  &TestPhyPaddingExclusion::SendHeTbPpdu,
5236  this,
5237  2,
5238  2,
5239  1001,
5240  ppduWithPaddingDuration);
5241 
5242  // Set TRIGVECTOR on AP
5243  Simulator::Schedule(Seconds(1.0),
5244  &TestPhyPaddingExclusion::SetTrigVector,
5245  this,
5246  ppduWithPaddingDuration);
5247 
5248  // Verify it takes expectedPpduDuration + padding to transmit the PPDUs
5249  Simulator::Schedule(Seconds(1.0) + ppduWithPaddingDuration - NanoSeconds(1),
5250  &TestPhyPaddingExclusion::CheckPhyState,
5251  this,
5252  m_phyAp,
5253  WifiPhyState::RX);
5254  Simulator::Schedule(Seconds(1.0) + ppduWithPaddingDuration,
5255  &TestPhyPaddingExclusion::CheckPhyState,
5256  this,
5257  m_phyAp,
5258  WifiPhyState::IDLE);
5259 
5260  // One PSDU of 1000 bytes should have been successfully received from STA 1
5261  Simulator::Schedule(Seconds(1.1), &TestPhyPaddingExclusion::CheckRxFromSta1, this, 1, 0, 1000);
5262  // One PSDU of 1001 bytes should have been successfully received from STA 2
5263  Simulator::Schedule(Seconds(1.1), &TestPhyPaddingExclusion::CheckRxFromSta2, this, 1, 0, 1001);
5264  // Verify events data have been cleared
5265  Simulator::Schedule(Seconds(1.1), &TestPhyPaddingExclusion::VerifyEventsCleared, this);
5266 
5267  Simulator::Schedule(Seconds(1.5), &TestPhyPaddingExclusion::Reset, this);
5268 
5269  // STA1 and STA2 send MU UL PPDUs addressed to AP:
5270  Simulator::Schedule(Seconds(2.0),
5271  &TestPhyPaddingExclusion::SendHeTbPpdu,
5272  this,
5273  1,
5274  1,
5275  1000,
5276  ppduWithPaddingDuration);
5277  Simulator::Schedule(Seconds(2.0),
5278  &TestPhyPaddingExclusion::SendHeTbPpdu,
5279  this,
5280  2,
5281  2,
5282  1001,
5283  ppduWithPaddingDuration);
5284 
5285  // Set TRIGVECTOR on AP
5286  Simulator::Schedule(Seconds(2.0),
5287  &TestPhyPaddingExclusion::SetTrigVector,
5288  this,
5289  ppduWithPaddingDuration);
5290 
5291  // A strong non-wifi interference is generated on RU 1 during padding reception
5292  BandInfo bandInfo;
5293  bandInfo.fc = (DEFAULT_FREQUENCY - (DEFAULT_CHANNEL_WIDTH / 4)) * 1e6;
5294  bandInfo.fl = bandInfo.fc - ((DEFAULT_CHANNEL_WIDTH / 4) * 1e6);
5295  bandInfo.fh = bandInfo.fc + ((DEFAULT_CHANNEL_WIDTH / 4) * 1e6);
5296  Bands bands;
5297  bands.push_back(bandInfo);
5298 
5299  Ptr<SpectrumModel> SpectrumInterferenceRu1 = Create<SpectrumModel>(bands);
5300  Ptr<SpectrumValue> interferencePsdRu1 = Create<SpectrumValue>(SpectrumInterferenceRu1);
5301  double interferencePower = 0.1; // watts
5302  *interferencePsdRu1 = interferencePower / ((DEFAULT_CHANNEL_WIDTH / 2) * 20e6);
5303 
5304  Simulator::Schedule(Seconds(2.0) + MicroSeconds(50) + expectedPpduDuration,
5305  &TestPhyPaddingExclusion::GenerateInterference,
5306  this,
5307  interferencePsdRu1,
5308  MilliSeconds(100));
5309 
5310  // Verify it takes expectedPpduDuration + padding to transmit the PPDUs (PHY should move to
5311  // CCA_BUSY instead of IDLE due to the interference)
5312  Simulator::Schedule(Seconds(2.0) + ppduWithPaddingDuration - NanoSeconds(1),
5313  &TestPhyPaddingExclusion::CheckPhyState,
5314  this,
5315  m_phyAp,
5316  WifiPhyState::RX);
5317  Simulator::Schedule(Seconds(2.0) + ppduWithPaddingDuration,
5318  &TestPhyPaddingExclusion::CheckPhyState,
5319  this,
5320  m_phyAp,
5321  WifiPhyState::CCA_BUSY);
5322 
5323  // One PSDU of 1000 bytes should have been successfully received from STA 1 (since interference
5324  // occupies RU 1 after payload, during PHY padding)
5325  Simulator::Schedule(Seconds(2.1), &TestPhyPaddingExclusion::CheckRxFromSta1, this, 1, 0, 1000);
5326  // One PSDU of 1001 bytes should have been successfully received from STA 2
5327  Simulator::Schedule(Seconds(2.1), &TestPhyPaddingExclusion::CheckRxFromSta2, this, 1, 0, 1001);
5328  // Verify events data have been cleared
5329  Simulator::Schedule(Seconds(2.1), &TestPhyPaddingExclusion::VerifyEventsCleared, this);
5330 
5331  Simulator::Schedule(Seconds(2.5), &TestPhyPaddingExclusion::Reset, this);
5332 
5333  Simulator::Run();
5334 
5335  Simulator::Destroy();
5336 }
5337 
5344 class TestUlOfdmaPowerControl : public TestCase
5345 {
5346  public:
5347  TestUlOfdmaPowerControl();
5348  ~TestUlOfdmaPowerControl() override;
5349 
5350  private:
5351  void DoSetup() override;
5352  void DoTeardown() override;
5353  void DoRun() override;
5354 
5360  void SendMuBar(std::vector<uint16_t> staIds);
5361 
5368  void SetupBa(Address destination);
5369 
5376  void RunOne(bool setupBa);
5377 
5382  void ReplaceReceiveOkCallbackOfAp();
5383 
5393  void ReceiveOkCallbackAtAp(Ptr<const WifiPsdu> psdu,
5394  RxSignalInfo rxSignalInfo,
5395  WifiTxVector txVector,
5396  std::vector<bool> statusPerMpdu);
5397 
5398  uint8_t m_bssColor;
5399 
5400  Ptr<WifiNetDevice> m_apDev;
5401  Ptr<WifiNetDevice> m_sta1Dev;
5402  Ptr<WifiNetDevice> m_sta2Dev;
5403 
5404  Ptr<SpectrumWifiPhy> m_phyAp;
5405 
5406  double m_txPowerAp;
5407  double m_txPowerStart;
5408  double m_txPowerEnd;
5409  uint8_t m_txPowerLevels;
5410 
5411  double m_requestedRssiSta1;
5412  double m_requestedRssiSta2;
5413 
5414  double m_rssiSta1;
5415  double m_rssiSta2;
5416 
5417  double m_tol;
5418 };
5419 
5420 TestUlOfdmaPowerControl::TestUlOfdmaPowerControl()
5421  : TestCase("UL-OFDMA power control test"),
5422  m_bssColor(1),
5423  m_txPowerAp(0),
5424  m_txPowerStart(0),
5425  m_txPowerEnd(0),
5426  m_txPowerLevels(0),
5427  m_requestedRssiSta1(0),
5428  m_requestedRssiSta2(0),
5429  m_rssiSta1(0),
5430  m_rssiSta2(0),
5431  m_tol(0.1)
5432 {
5433 }
5434 
5435 TestUlOfdmaPowerControl::~TestUlOfdmaPowerControl()
5436 {
5437  m_phyAp = nullptr;
5438  m_apDev = nullptr;
5439  m_sta1Dev = nullptr;
5440  m_sta2Dev = nullptr;
5441 }
5442 
5443 void
5444 TestUlOfdmaPowerControl::SetupBa(Address destination)
5445 {
5446  // Only one packet is sufficient to set up BA since AP and STAs are HE capable
5447  Ptr<Packet> pkt = Create<Packet>(100); // 100 dummy bytes of data
5448  m_apDev->Send(pkt, destination, 0);
5449 }
5450 
5451 void
5452 TestUlOfdmaPowerControl::SendMuBar(std::vector<uint16_t> staIds)
5453 {
5454  NS_ASSERT(!staIds.empty() && staIds.size() <= 2);
5455 
5456  // Build MU-BAR trigger frame
5457  CtrlTriggerHeader muBar;
5458  muBar.SetType(TriggerFrameType::MU_BAR_TRIGGER);
5459  muBar.SetMoreTF(true);
5460  muBar.SetCsRequired(true);
5461  muBar.SetUlBandwidth(DEFAULT_CHANNEL_WIDTH);
5462  muBar.SetGiAndLtfType(1600, 2);
5463  muBar.SetApTxPower(static_cast<int8_t>(m_txPowerAp));
5464  muBar.SetUlSpatialReuse(60500);
5465 
5466  HeRu::RuType ru = (staIds.size() == 1) ? HeRu::RU_242_TONE : HeRu::RU_106_TONE;
5467  std::size_t index = 1;
5468  int8_t ulTargetRssi = -40; // will be overwritten
5469  for (const auto& staId : staIds)
5470  {
5471  CtrlTriggerUserInfoField& ui = muBar.AddUserInfoField();
5472  ui.SetAid12(staId);
5473  ui.SetRuAllocation({ru, index, true});
5474  ui.SetUlFecCodingType(true);
5475  ui.SetUlMcs(7);
5476  ui.SetUlDcm(false);
5477  ui.SetSsAllocation(1, 1);
5478  if (staId == 1)
5479  {
5480  ulTargetRssi = m_requestedRssiSta1;
5481  }
5482  else if (staId == 2)
5483  {
5484  ulTargetRssi = m_requestedRssiSta2;
5485  }
5486  else
5487  {
5488  NS_ABORT_MSG("Unknown STA-ID (" << staId << ")");
5489  }
5490  ui.SetUlTargetRssi(ulTargetRssi);
5491 
5492  CtrlBAckRequestHeader bar;
5493  bar.SetType(BlockAckReqType::COMPRESSED);
5494  bar.SetTidInfo(0);
5495  bar.SetStartingSequence(4095);
5496  ui.SetMuBarTriggerDepUserInfo(bar);
5497 
5498  ++index;
5499  }
5500 
5501  WifiTxVector tbTxVector = muBar.GetHeTbTxVector(staIds.front());
5502  muBar.SetUlLength(HePhy::ConvertHeTbPpduDurationToLSigLength(MicroSeconds(128),
5503  tbTxVector,
5504  WIFI_PHY_BAND_5GHZ)
5505  .first);
5506 
5507  WifiConstPsduMap psdus;
5508  WifiTxVector txVector = WifiTxVector(HePhy::GetHeMcs7(),
5509  0,
5510  WIFI_PREAMBLE_HE_SU,
5511  800,
5512  1,
5513  1,
5514  0,
5515  DEFAULT_CHANNEL_WIDTH,
5516  false,
5517  false,
5518  false,
5519  m_bssColor);
5520 
5521  Ptr<Packet> bar = Create<Packet>();
5522  bar->AddHeader(muBar);
5523 
5524  Mac48Address receiver = Mac48Address::GetBroadcast();
5525  if (staIds.size() == 1)
5526  {
5527  uint16_t aidSta1 = DynamicCast<StaWifiMac>(m_sta1Dev->GetMac())->GetAssociationId();
5528  if (staIds.front() == aidSta1)
5529  {
5530  receiver = Mac48Address::ConvertFrom(m_sta1Dev->GetAddress());
5531  }
5532  else
5533  {
5534  NS_ASSERT(staIds.front() ==
5535  DynamicCast<StaWifiMac>(m_sta2Dev->GetMac())->GetAssociationId());
5536  receiver = Mac48Address::ConvertFrom(m_sta2Dev->GetAddress());
5537  }
5538  }
5539 
5540  WifiMacHeader hdr;
5541  hdr.SetType(WIFI_MAC_CTL_TRIGGER);
5542  hdr.SetAddr1(receiver);
5543  hdr.SetAddr2(Mac48Address::ConvertFrom(m_apDev->GetAddress()));
5544  hdr.SetAddr3(Mac48Address::ConvertFrom(m_apDev->GetAddress()));
5545  hdr.SetDsNotTo();
5546  hdr.SetDsFrom();
5547  hdr.SetNoRetry();
5548  hdr.SetNoMoreFragments();
5549  Ptr<WifiPsdu> psdu = Create<WifiPsdu>(bar, hdr);
5550 
5551  Time nav = m_apDev->GetPhy()->GetSifs();
5552  uint16_t staId = staIds.front(); // either will do
5553  nav += m_phyAp->CalculateTxDuration(GetBlockAckSize(BlockAckType::COMPRESSED),
5554  tbTxVector,
5555  DEFAULT_WIFI_BAND,
5556  staId);
5557  psdu->SetDuration(nav);
5558  psdus.insert(std::make_pair(SU_STA_ID, psdu));
5559 
5560  m_phyAp->Send(psdus, txVector);
5561 }
5562 
5563 void
5564 TestUlOfdmaPowerControl::ReceiveOkCallbackAtAp(Ptr<const WifiPsdu> psdu,
5565  RxSignalInfo rxSignalInfo,
5566  WifiTxVector txVector,
5567  std::vector<bool> /*statusPerMpdu*/)
5568 {
5569  NS_TEST_ASSERT_MSG_EQ(txVector.GetPreambleType(), WIFI_PREAMBLE_HE_TB, "HE TB PPDU expected");
5570  double rssi = rxSignalInfo.rssi;
5571  NS_ASSERT(psdu->GetNMpdus() == 1);
5572  WifiMacHeader hdr = psdu->GetHeader(0);
5573  NS_TEST_ASSERT_MSG_EQ(hdr.GetType(), WIFI_MAC_CTL_BACKRESP, "Block ACK expected");
5574  if (hdr.GetAddr2() == m_sta1Dev->GetAddress())
5575  {
5576  NS_TEST_ASSERT_MSG_EQ_TOL(
5577  rssi,
5578  m_rssiSta1,
5579  m_tol,
5580  "The obtained RSSI from STA 1 at AP is different from the expected one ("
5581  << rssi << " vs " << m_rssiSta1 << ", with tolerance of " << m_tol << ")");
5582  }
5583  else if (psdu->GetAddr2() == m_sta2Dev->GetAddress())
5584  {
5585  NS_TEST_ASSERT_MSG_EQ_TOL(
5586  rssi,
5587  m_rssiSta2,
5588  m_tol,
5589  "The obtained RSSI from STA 2 at AP is different from the expected one ("
5590  << rssi << " vs " << m_rssiSta2 << ", with tolerance of " << m_tol << ")");
5591  }
5592  else
5593  {
5594  NS_ABORT_MSG("The receiver address is unknown");
5595  }
5596 }
5597 
5598 void
5599 TestUlOfdmaPowerControl::ReplaceReceiveOkCallbackOfAp()
5600 {
5601  // Now that BA session has been established we can plug our method
5602  m_phyAp->SetReceiveOkCallback(
5603  MakeCallback(&TestUlOfdmaPowerControl::ReceiveOkCallbackAtAp, this));
5604 }
5605 
5606 void
5607 TestUlOfdmaPowerControl::DoSetup()
5608 {
5609  Ptr<Node> apNode = CreateObject<Node>();
5610  NodeContainer staNodes;
5611  staNodes.Create(2);
5612 
5613  Ptr<MultiModelSpectrumChannel> spectrumChannel = CreateObject<MultiModelSpectrumChannel>();
5614  Ptr<MatrixPropagationLossModel> lossModel = CreateObject<MatrixPropagationLossModel>();
5615  spectrumChannel->AddPropagationLossModel(lossModel);
5616  Ptr<ConstantSpeedPropagationDelayModel> delayModel =
5617  CreateObject<ConstantSpeedPropagationDelayModel>();
5618  spectrumChannel->SetPropagationDelayModel(delayModel);
5619 
5620  SpectrumWifiPhyHelper spectrumPhy;
5621  spectrumPhy.SetChannel(spectrumChannel);
5622  spectrumPhy.SetErrorRateModel("ns3::NistErrorRateModel");
5623  spectrumPhy.Set("ChannelSettings", StringValue("{0, 0, BAND_5GHZ, 0}"));
5624 
5625  WifiHelper wifi;
5626  wifi.SetStandard(WIFI_STANDARD_80211ax);
5627  wifi.SetRemoteStationManager("ns3::ConstantRateWifiManager",
5628  "DataMode",
5629  StringValue("HeMcs7"),
5630  "ControlMode",
5631  StringValue("HeMcs7"));
5632 
5633  WifiMacHelper mac;
5634  mac.SetType("ns3::StaWifiMac");
5635  NetDeviceContainer staDevs = wifi.Install(spectrumPhy, mac, staNodes);
5636  wifi.AssignStreams(staDevs, 0);
5637  m_sta1Dev = DynamicCast<WifiNetDevice>(staDevs.Get(0));
5638  NS_ASSERT(m_sta1Dev);
5639  m_sta2Dev = DynamicCast<WifiNetDevice>(staDevs.Get(1));
5640  NS_ASSERT(m_sta2Dev);
5641 
5642  // Set the beacon interval long enough so that associated STAs may not consider link lost when
5643  // beacon generation is disabled during the actual tests. Having such a long interval also
5644  // avoids bloating logs with beacons during the set up phase.
5645  mac.SetType("ns3::ApWifiMac",
5646  "BeaconGeneration",
5647  BooleanValue(true),
5648  "BeaconInterval",
5649  TimeValue(MicroSeconds(1024 * 600)));
5650  m_apDev = DynamicCast<WifiNetDevice>(wifi.Install(spectrumPhy, mac, apNode).Get(0));
5651  NS_ASSERT(m_apDev);
5652  m_apDev->GetHeConfiguration()->SetAttribute("BssColor", UintegerValue(m_bssColor));
5653  m_phyAp = DynamicCast<SpectrumWifiPhy>(m_apDev->GetPhy());
5654  NS_ASSERT(m_phyAp);
5655  // ReceiveOkCallback of AP will be set to corresponding test's method once BA sessions have been
5656  // set up for both STAs
5657 
5658  MobilityHelper mobility;
5659  mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
5660  Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator>();
5661  positionAlloc->Add(Vector(0.0, 0.0, 0.0));
5662  positionAlloc->Add(Vector(1.0, 0.0, 0.0)); // put close enough in order to use MCS
5663  positionAlloc->Add(
5664  Vector(2.0, 0.0, 0.0)); // STA 2 is a bit further away, but still in range of MCS
5665  mobility.SetPositionAllocator(positionAlloc);
5666 
5667  mobility.Install(apNode);
5668  mobility.Install(staNodes);
5669 
5670  lossModel->SetDefaultLoss(50.0);
5671  lossModel->SetLoss(apNode->GetObject<MobilityModel>(),
5672  staNodes.Get(1)->GetObject<MobilityModel>(),
5673  56.0,
5674  true); //+6 dB between AP <-> STA 2 compared to AP <-> STA 1
5675 }
5676 
5677 void
5678 TestUlOfdmaPowerControl::DoTeardown()
5679 {
5680  m_phyAp->Dispose();
5681  m_phyAp = nullptr;
5682  m_apDev->Dispose();
5683  m_apDev = nullptr;
5684  m_sta1Dev->Dispose();
5685  m_sta1Dev = nullptr;
5686  m_sta2Dev->Dispose();
5687  m_sta2Dev = nullptr;
5688 }
5689 
5690 void
5691 TestUlOfdmaPowerControl::RunOne(bool setupBa)
5692 {
5693  RngSeedManager::SetSeed(1);
5694  RngSeedManager::SetRun(1);
5695  int64_t streamNumber = 0;
5696 
5697  Ptr<WifiPhy> phySta1 = m_sta1Dev->GetPhy();
5698  Ptr<WifiPhy> phySta2 = m_sta2Dev->GetPhy();
5699 
5700  m_phyAp->AssignStreams(streamNumber);
5701  phySta1->AssignStreams(streamNumber);
5702  phySta2->AssignStreams(streamNumber);
5703 
5704  m_phyAp->SetAttribute("TxPowerStart", DoubleValue(m_txPowerAp));
5705  m_phyAp->SetAttribute("TxPowerEnd", DoubleValue(m_txPowerAp));
5706  m_phyAp->SetAttribute("TxPowerLevels", UintegerValue(1));
5707 
5708  phySta1->SetAttribute("TxPowerStart", DoubleValue(m_txPowerStart));
5709  phySta1->SetAttribute("TxPowerEnd", DoubleValue(m_txPowerEnd));
5710  phySta1->SetAttribute("TxPowerLevels", UintegerValue(m_txPowerLevels));
5711 
5712  phySta2->SetAttribute("TxPowerStart", DoubleValue(m_txPowerStart));
5713  phySta2->SetAttribute("TxPowerEnd", DoubleValue(m_txPowerEnd));
5714  phySta2->SetAttribute("TxPowerLevels", UintegerValue(m_txPowerLevels));
5715 
5716  Time relativeStart = MilliSeconds(0);
5717  if (setupBa)
5718  {
5719  // Set up BA for each station once the association phase has ended
5720  // so that a BA session is established when the MU-BAR is received.
5721  Simulator::Schedule(MilliSeconds(800),
5722  &TestUlOfdmaPowerControl::SetupBa,
5723  this,
5724  m_sta1Dev->GetAddress());
5725  Simulator::Schedule(MilliSeconds(850),
5726  &TestUlOfdmaPowerControl::SetupBa,
5727  this,
5728  m_sta2Dev->GetAddress());
5729  relativeStart = MilliSeconds(1000);
5730  }
5731  else
5732  {
5733  Ptr<ApWifiMac> apMac = DynamicCast<ApWifiMac>(m_apDev->GetMac());
5734  NS_ASSERT(apMac);
5735  apMac->SetAttribute("BeaconGeneration", BooleanValue(false));
5736  }
5737 
5738  Simulator::Schedule(relativeStart,
5739  &TestUlOfdmaPowerControl::ReplaceReceiveOkCallbackOfAp,
5740  this);
5741 
5742  {
5743  // Verify that the RSSI from STA 1 is consistent with what was requested
5744  std::vector<uint16_t> staIds{1};
5745  Simulator::Schedule(relativeStart, &TestUlOfdmaPowerControl::SendMuBar, this, staIds);
5746  }
5747 
5748  {
5749  // Verify that the RSSI from STA 2 is consistent with what was requested
5750  std::vector<uint16_t> staIds{2};
5751  Simulator::Schedule(relativeStart + MilliSeconds(20),
5752  &TestUlOfdmaPowerControl::SendMuBar,
5753  this,
5754  staIds);
5755  }
5756 
5757  {
5758  // Verify that the RSSI from STA 1 and 2 is consistent with what was requested
5759  std::vector<uint16_t> staIds{1, 2};
5760  Simulator::Schedule(relativeStart + MilliSeconds(40),
5761  &TestUlOfdmaPowerControl::SendMuBar,
5762  this,
5763  staIds);
5764  }
5765 
5766  Simulator::Stop(relativeStart + MilliSeconds(100));
5767  Simulator::Run();
5768 }
5769 
5770 void
5771 TestUlOfdmaPowerControl::DoRun()
5772 {
5773  // Power configurations
5774  m_txPowerAp = 20; // dBm, so as to have -30 and -36 dBm at STA 1 and STA 2 resp.,
5775  // since path loss = 50 dB for AP <-> STA 1 and 56 dB for AP <-> STA 2
5776  m_txPowerStart = 15; // dBm
5777 
5778  // Requested UL RSSIs: should correspond to 20 dBm transmit power at STAs
5779  m_requestedRssiSta1 = -30.0;
5780  m_requestedRssiSta2 = -36.0;
5781 
5782  // Test single power level
5783  {
5784  // STA power configurations: 15 dBm only
5785  m_txPowerEnd = 15;
5786  m_txPowerLevels = 1;
5787 
5788  // Expected UL RSSIs, considering that the provided power is 5 dB less than requested,
5789  // regardless of the estimated path loss.
5790  m_rssiSta1 = -35.0; // 15 dBm - 50 dB
5791  m_rssiSta2 = -41.0; // 15 dBm - 56 dB
5792 
5793  RunOne(true);
5794  }
5795 
5796  // Test 2 dBm granularity
5797  {
5798  // STA power configurations: [15:2:25] dBm
5799  m_txPowerEnd = 25;
5800  m_txPowerLevels = 6;
5801 
5802  // Expected UL RSSIs, considering that the provided power (21 dBm) is 1 dB more than
5803  // requested
5804  m_rssiSta1 = -29.0; // 21 dBm - 50 dB
5805  m_rssiSta2 = -35.0; // 21 dBm - 50 dB
5806 
5807  RunOne(false);
5808  }
5809 
5810  // Test 1 dBm granularity
5811  {
5812  // STA power configurations: [15:1:25] dBm
5813  m_txPowerEnd = 25;
5814  m_txPowerLevels = 11;
5815 
5816  // Expected UL RSSIs, considering that we can correctly tune the transmit power
5817  m_rssiSta1 = -30.0; // 20 dBm - 50 dB
5818  m_rssiSta2 = -36.0; // 20 dBm - 56 dB
5819 
5820  RunOne(false);
5821  }
5822 
5823  // Ask for different power levels (3 dB difference between HE_TB_PPDUs)
5824  {
5825  // STA power configurations: [15:1:25] dBm
5826  m_txPowerEnd = 25;
5827  m_txPowerLevels = 11;
5828 
5829  // Requested UL RSSIs
5830  m_requestedRssiSta1 = -28.0; // 2 dB higher than previously -> Tx power = 22 dBm at STA 1
5831  m_requestedRssiSta2 = -37.0; // 1 dB less than previously -> Tx power = 19 dBm at STA 2
5832 
5833  // Expected UL RSSIs, considering that we can correctly tune the transmit power
5834  m_rssiSta1 = -28.0; // 22 dBm - 50 dB
5835  m_rssiSta2 = -37.0; // 19 dBm - 56 dB
5836 
5837  RunOne(false);
5838  }
5839 
5840  Simulator::Destroy();
5841 }
5842 
5849 class WifiPhyOfdmaTestSuite : public TestSuite
5850 {
5851  public:
5852  WifiPhyOfdmaTestSuite();
5853 };
5854 
5855 WifiPhyOfdmaTestSuite::WifiPhyOfdmaTestSuite()
5856  : TestSuite("wifi-phy-ofdma", UNIT)
5857 {
5858  AddTestCase(new TestDlOfdmaPhyTransmission, TestCase::QUICK);
5859  AddTestCase(new TestDlOfdmaPhyPuncturing, TestCase::QUICK);
5860  AddTestCase(new TestUlOfdmaPpduUid, TestCase::QUICK);
5861  AddTestCase(new TestMultipleHeTbPreambles, TestCase::QUICK);
5862  AddTestCase(new TestUlOfdmaPhyTransmission, TestCase::QUICK);
5863  AddTestCase(new TestPhyPaddingExclusion, TestCase::QUICK);
5864  AddTestCase(new TestUlOfdmaPowerControl, TestCase::QUICK);
5865 }
5866 
5867 static WifiPhyOfdmaTestSuite wifiPhyOfdmaTestSuite;
max
#define max(a, b)
Definition: 80211b.c:43
OfdmaSpectrumWifiPhy
SpectrumWifiPhy used for testing OFDMA.
Definition: wifi-phy-ofdma-test.cc:133
OfdmaSpectrumWifiPhy::GetEnergyDuration
Time GetEnergyDuration(double energyW, WifiSpectrumBand band)
Wrapper to InterferenceHelper method.
Definition: wifi-phy-ofdma-test.cc:280
OfdmaSpectrumWifiPhy::SetTriggerFrameUid
void SetTriggerFrameUid(uint64_t uid)
Since we assume trigger frame was previously received from AP, this is used to set its UID.
Definition: wifi-phy-ofdma-test.cc:255
OfdmaSpectrumWifiPhy::GetHePhy
Ptr< const HePhy > GetHePhy() const
Definition: wifi-phy-ofdma-test.cc:286
OfdmaSpectrumWifiPhy::TxPpduUidCallback
void(* TxPpduUidCallback)(uint64_t uid)
TracedCallback signature for UID of transmitted PPDU.
Definition: wifi-phy-ofdma-test.cc:159
OfdmaSpectrumWifiPhy::SetPpduUid
void SetPpduUid(uint64_t uid)
Set the global PPDU UID counter.
Definition: wifi-phy-ofdma-test.cc:248
OfdmaSpectrumWifiPhy::GetTypeId
static TypeId GetTypeId()
Get the type ID.
Definition: wifi-phy-ofdma-test.cc:208
OfdmaSpectrumWifiPhy::GetCurrentPreambleEvents
std::map< std::pair< uint64_t, WifiPreamble >, Ptr< Event > > & GetCurrentPreambleEvents()
Definition: wifi-phy-ofdma-test.cc:268
OfdmaSpectrumWifiPhy::m_ofdmTestHePhy
Ptr< OfdmaTestHePhy > m_ofdmTestHePhy
Pointer to HE PHY instance used for OFDMA test.
Definition: wifi-phy-ofdma-test.cc:202
OfdmaSpectrumWifiPhy::GetCurrentEvent
Ptr< Event > GetCurrentEvent()
Definition: wifi-phy-ofdma-test.cc:274
OfdmaSpectrumWifiPhy::StartTx
void StartTx(Ptr< const WifiPpdu > ppdu) override
Definition: wifi-phy-ofdma-test.cc:261
OfdmaSpectrumWifiPhy::DoDispose
void DoDispose() override
Destructor implementation.
Definition: wifi-phy-ofdma-test.cc:241
OfdmaSpectrumWifiPhy::OfdmaSpectrumWifiPhy
OfdmaSpectrumWifiPhy(uint16_t staId)
Constructor.
Definition: wifi-phy-ofdma-test.cc:221
OfdmaSpectrumWifiPhy::m_phyTxPpduUidTrace
TracedCallback< uint64_t > m_phyTxPpduUidTrace
Callback providing UID of the PPDU that is about to be transmitted.
Definition: wifi-phy-ofdma-test.cc:204
OfdmaSpectrumWifiPhy::DoInitialize
void DoInitialize() override
Initialize() implementation.
Definition: wifi-phy-ofdma-test.cc:233
OfdmaTestHePhy
HE PHY slightly modified so as to return a given STA-ID in case of DL MU for OfdmaSpectrumWifiPhy.
Definition: wifi-phy-ofdma-test.cc:73
OfdmaTestHePhy::OfdmaTestHePhy
OfdmaTestHePhy(uint16_t staId)
Constructor.
Definition: wifi-phy-ofdma-test.cc:103
OfdmaTestHePhy::~OfdmaTestHePhy
~OfdmaTestHePhy() override
Definition: wifi-phy-ofdma-test.cc:109
OfdmaTestHePhy::SetGlobalPpduUid
void SetGlobalPpduUid(uint64_t uid)
Set the global PPDU UID counter.
Definition: wifi-phy-ofdma-test.cc:124
OfdmaTestHePhy::GetStaId
uint16_t GetStaId(const Ptr< const WifiPpdu > ppdu) const override
Return the STA ID that has been assigned to the station this PHY belongs to.
Definition: wifi-phy-ofdma-test.cc:114
OfdmaTestHePhy::m_staId
uint16_t m_staId
ID of the STA to which this PHY belongs to.
Definition: wifi-phy-ofdma-test.cc:100
OfdmaTestPhyListener
PHY listener for OFDMA tests.
Definition: wifi-phy-ofdma-test.cc:2812
OfdmaTestPhyListener::OfdmaTestPhyListener
OfdmaTestPhyListener()=default
OfdmaTestPhyListener::NotifyRxEndError
void NotifyRxEndError() override
We have received the last bit of a packet for which NotifyRxStart was invoked first and,...
Definition: wifi-phy-ofdma-test.cc:2832
OfdmaTestPhyListener::NotifyTxStart
void NotifyTxStart(Time duration, double txPowerDbm) override
Definition: wifi-phy-ofdma-test.cc:2840
OfdmaTestPhyListener::m_lastRxSuccess
bool m_lastRxSuccess
flag whether last RX has been successful
Definition: wifi-phy-ofdma-test.cc:2934
OfdmaTestPhyListener::NotifyRxStart
void NotifyRxStart(Time duration) override
Definition: wifi-phy-ofdma-test.cc:2816
OfdmaTestPhyListener::GetLastRxStartNotification
Time GetLastRxStartNotification() const
Return the time at which the last RX start notification has been received.
Definition: wifi-phy-ofdma-test.cc:2906
OfdmaTestPhyListener::NotifySwitchingStart
void NotifySwitchingStart(Time duration) override
Definition: wifi-phy-ofdma-test.cc:2852
OfdmaTestPhyListener::NotifyWakeup
void NotifyWakeup() override
Notify listeners that we woke up.
Definition: wifi-phy-ofdma-test.cc:2864
OfdmaTestPhyListener::m_notifyRxStart
uint32_t m_notifyRxStart
count number of RX start notifications
Definition: wifi-phy-ofdma-test.cc:2930
OfdmaTestPhyListener::Reset
void Reset()
Reset function.
Definition: wifi-phy-ofdma-test.cc:2875
OfdmaTestPhyListener::m_lastRxEnd
Time m_lastRxEnd
last time a RX end notification has been received
Definition: wifi-phy-ofdma-test.cc:2933
OfdmaTestPhyListener::m_lastRxStart
Time m_lastRxStart
last time a RX start notification has been received
Definition: wifi-phy-ofdma-test.cc:2932
OfdmaTestPhyListener::GetLastRxEndNotification
Time GetLastRxEndNotification() const
Return the time at which the last RX end notification has been received.
Definition: wifi-phy-ofdma-test.cc:2915
OfdmaTestPhyListener::NotifyCcaBusyStart
void NotifyCcaBusyStart(Time duration, WifiChannelListType channelType, const std::vector< Time > &) override
Definition: wifi-phy-ofdma-test.cc:2845
OfdmaTestPhyListener::m_notifyRxEnd
uint32_t m_notifyRxEnd
count number of RX end notifications
Definition: wifi-phy-ofdma-test.cc:2931
OfdmaTestPhyListener::IsLastRxSuccess
bool IsLastRxSuccess() const
Return whether last RX has been successful.
Definition: wifi-phy-ofdma-test.cc:2924
OfdmaTestPhyListener::NotifySleep
void NotifySleep() override
Notify listeners that we went to sleep.
Definition: wifi-phy-ofdma-test.cc:2856
OfdmaTestPhyListener::GetNumRxEndNotifications
uint32_t GetNumRxEndNotifications() const
Return the number of RX end notifications that has been received since the last reset.
Definition: wifi-phy-ofdma-test.cc:2897
OfdmaTestPhyListener::NotifyRxEndOk
void NotifyRxEndOk() override
We have received the last bit of a packet for which NotifyRxStart was invoked first and,...
Definition: wifi-phy-ofdma-test.cc:2824
OfdmaTestPhyListener::GetNumRxStartNotifications
uint32_t GetNumRxStartNotifications() const
Return the number of RX start notifications that has been received since the last reset.
Definition: wifi-phy-ofdma-test.cc:2888
OfdmaTestPhyListener::NotifyOff
void NotifyOff() override
Notify listeners that we went to switch off.
Definition: wifi-phy-ofdma-test.cc:2860
OfdmaTestPhyListener::NotifyOn
void NotifyOn() override
Notify listeners that we went to switch on.
Definition: wifi-phy-ofdma-test.cc:2868
TestDlOfdmaPhyPuncturing
DL-OFDMA PHY puncturing test.
Definition: wifi-phy-ofdma-test.cc:1194
TestDlOfdmaPhyPuncturing::DoTeardown
void DoTeardown() override
Implementation to do any local setup required for this TestCase.
Definition: wifi-phy-ofdma-test.cc:1622
TestDlOfdmaPhyPuncturing::m_countRxBytesSta1
uint32_t m_countRxBytesSta1
count RX bytes for STA 1
Definition: wifi-phy-ofdma-test.cc:1310
TestDlOfdmaPhyPuncturing::m_countRxBytesSta2
uint32_t m_countRxBytesSta2
count RX bytes for STA 2
Definition: wifi-phy-ofdma-test.cc:1311
TestDlOfdmaPhyPuncturing::m_phyAp
Ptr< SpectrumWifiPhy > m_phyAp
PHY of AP.
Definition: wifi-phy-ofdma-test.cc:1313
TestDlOfdmaPhyPuncturing::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition: wifi-phy-ofdma-test.cc:1814
TestDlOfdmaPhyPuncturing::m_expectedPpduDuration20Mhz
Time m_expectedPpduDuration20Mhz
expected duration to send MU PPDU on 20 MHz RU
Definition: wifi-phy-ofdma-test.cc:1324
TestDlOfdmaPhyPuncturing::CheckResultsSta1
void CheckResultsSta1(uint32_t expectedRxSuccess, uint32_t expectedRxFailure, uint32_t expectedRxBytes)
Check the results for STA 1.
Definition: wifi-phy-ofdma-test.cc:1490
TestDlOfdmaPhyPuncturing::ResetResults
void ResetResults()
Reset the results.
Definition: wifi-phy-ofdma-test.cc:1345
TestDlOfdmaPhyPuncturing::m_countRxSuccessSta2
uint32_t m_countRxSuccessSta2
count RX success for STA 2
Definition: wifi-phy-ofdma-test.cc:1307
TestDlOfdmaPhyPuncturing::RunOne
void RunOne()
Run one function.
Definition: wifi-phy-ofdma-test.cc:1635
TestDlOfdmaPhyPuncturing::m_phySta1
Ptr< OfdmaSpectrumWifiPhy > m_phySta1
PHY of STA 1.
Definition: wifi-phy-ofdma-test.cc:1314
TestDlOfdmaPhyPuncturing::RxFailureSta1
void RxFailureSta1(Ptr< const WifiPsdu > psdu)
Receive failure function for STA 1.
Definition: wifi-phy-ofdma-test.cc:1476
TestDlOfdmaPhyPuncturing::m_countRxFailureSta2
uint32_t m_countRxFailureSta2
count RX failure for STA 2
Definition: wifi-phy-ofdma-test.cc:1309
TestDlOfdmaPhyPuncturing::DoSetup
void DoSetup() override
Implementation to do any local setup required for this TestCase.
Definition: wifi-phy-ofdma-test.cc:1545
TestDlOfdmaPhyPuncturing::SendMuPpdu
void SendMuPpdu(uint16_t rxStaId1, uint16_t rxStaId2, const std::vector< bool > &puncturedSubchannels)
Send MU-PPDU function.
Definition: wifi-phy-ofdma-test.cc:1356
TestDlOfdmaPhyPuncturing::m_frequency
uint16_t m_frequency
frequency in MHz
Definition: wifi-phy-ofdma-test.cc:1318
TestDlOfdmaPhyPuncturing::m_channelWidth
uint16_t m_channelWidth
channel width in MHz
Definition: wifi-phy-ofdma-test.cc:1319
TestDlOfdmaPhyPuncturing::m_countRxFailureSta1
uint32_t m_countRxFailureSta1
count RX failure for STA 1
Definition: wifi-phy-ofdma-test.cc:1308
TestDlOfdmaPhyPuncturing::m_expectedPpduDuration40Mhz
Time m_expectedPpduDuration40Mhz
expected duration to send MU PPDU on 40 MHz RU
Definition: wifi-phy-ofdma-test.cc:1325
TestDlOfdmaPhyPuncturing::CheckResultsSta2
void CheckResultsSta2(uint32_t expectedRxSuccess, uint32_t expectedRxFailure, uint32_t expectedRxBytes)
Check the results for STA 2.
Definition: wifi-phy-ofdma-test.cc:1506
TestDlOfdmaPhyPuncturing::DoCheckPhyState
void DoCheckPhyState(Ptr< OfdmaSpectrumWifiPhy > phy, WifiPhyState expectedState)
Check the PHY state now.
Definition: wifi-phy-ofdma-test.cc:1530
TestDlOfdmaPhyPuncturing::RxFailureSta2
void RxFailureSta2(Ptr< const WifiPsdu > psdu)
Receive failure function for STA 2.
Definition: wifi-phy-ofdma-test.cc:1483
TestDlOfdmaPhyPuncturing::m_phyInterferer
Ptr< WaveformGenerator > m_phyInterferer
PHY of interferer.
Definition: wifi-phy-ofdma-test.cc:1316
TestDlOfdmaPhyPuncturing::StopInterference
void StopInterference()
Stop interference function.
Definition: wifi-phy-ofdma-test.cc:1447
TestDlOfdmaPhyPuncturing::CheckPhyState
void CheckPhyState(Ptr< OfdmaSpectrumWifiPhy > phy, WifiPhyState expectedState)
Schedule now to check the PHY state.
Definition: wifi-phy-ofdma-test.cc:1522
TestDlOfdmaPhyPuncturing::m_indexSubchannel
uint8_t m_indexSubchannel
Index of the subchannel (starting from 0) that should contain an interference and be punctured during...
Definition: wifi-phy-ofdma-test.cc:1321
TestDlOfdmaPhyPuncturing::m_countRxSuccessSta1
uint32_t m_countRxSuccessSta1
count RX success for STA 1
Definition: wifi-phy-ofdma-test.cc:1306
TestDlOfdmaPhyPuncturing::m_phySta2
Ptr< OfdmaSpectrumWifiPhy > m_phySta2
PHY of STA 2.
Definition: wifi-phy-ofdma-test.cc:1315
TestDlOfdmaPhyPuncturing::RxSuccessSta1
void RxSuccessSta1(Ptr< const WifiPsdu > psdu, RxSignalInfo rxSignalInfo, WifiTxVector txVector, const std::vector< bool > statusPerMpdu)
Receive success function for STA 1.
Definition: wifi-phy-ofdma-test.cc:1454
TestDlOfdmaPhyPuncturing::RxSuccessSta2
void RxSuccessSta2(Ptr< const WifiPsdu > psdu, RxSignalInfo rxSignalInfo, WifiTxVector txVector, std::vector< bool > statusPerMpdu)
Receive success function for STA 2.
Definition: wifi-phy-ofdma-test.cc:1465
TestDlOfdmaPhyPuncturing::GenerateInterference
void GenerateInterference(Ptr< SpectrumValue > interferencePsd, Time duration)
Generate interference function.
Definition: wifi-phy-ofdma-test.cc:1437
TestDlOfdmaPhyTransmission::m_frequency
uint16_t m_frequency
frequency in MHz
Definition: wifi-phy-ofdma-test.cc:443
TestDlOfdmaPhyTransmission::DoSetup
void DoSetup() override
Implementation to do any local setup required for this TestCase.
Definition: wifi-phy-ofdma-test.cc:699
TestDlOfdmaPhyTransmission::m_channelWidth
uint16_t m_channelWidth
channel width in MHz
Definition: wifi-phy-ofdma-test.cc:444
TestDlOfdmaPhyTransmission::m_countRxFailureSta2
uint32_t m_countRxFailureSta2
count RX failure for STA 2
Definition: wifi-phy-ofdma-test.cc:431
TestDlOfdmaPhyTransmission::RxFailureSta2
void RxFailureSta2(Ptr< const WifiPsdu > psdu)
Receive failure function for STA 2.
Definition: wifi-phy-ofdma-test.cc:613
TestDlOfdmaPhyTransmission::RunOne
void RunOne()
Run one function.
Definition: wifi-phy-ofdma-test.cc:811
TestDlOfdmaPhyTransmission::m_countRxBytesSta2
uint32_t m_countRxBytesSta2
count RX bytes for STA 2
Definition: wifi-phy-ofdma-test.cc:434
TestDlOfdmaPhyTransmission::DoTeardown
void DoTeardown() override
Implementation to do any local setup required for this TestCase.
Definition: wifi-phy-ofdma-test.cc:796
TestDlOfdmaPhyTransmission::m_expectedPpduDuration
Time m_expectedPpduDuration
expected duration to send MU PPDU
Definition: wifi-phy-ofdma-test.cc:445
TestDlOfdmaPhyTransmission::GenerateInterference
void GenerateInterference(Ptr< SpectrumValue > interferencePsd, Time duration)
Generate interference function.
Definition: wifi-phy-ofdma-test.cc:554
TestDlOfdmaPhyTransmission::m_phyInterferer
Ptr< WaveformGenerator > m_phyInterferer
PHY of interferer.
Definition: wifi-phy-ofdma-test.cc:441
TestDlOfdmaPhyTransmission::m_countRxFailureSta3
uint32_t m_countRxFailureSta3
count RX failure for STA 3
Definition: wifi-phy-ofdma-test.cc:432
TestDlOfdmaPhyTransmission::m_countRxBytesSta1
uint32_t m_countRxBytesSta1
count RX bytes for STA 1
Definition: wifi-phy-ofdma-test.cc:433
TestDlOfdmaPhyTransmission::m_phySta2
Ptr< OfdmaSpectrumWifiPhy > m_phySta2
PHY of STA 2.
Definition: wifi-phy-ofdma-test.cc:439
TestDlOfdmaPhyTransmission::RxSuccessSta2
void RxSuccessSta2(Ptr< const WifiPsdu > psdu, RxSignalInfo rxSignalInfo, WifiTxVector txVector, std::vector< bool > statusPerMpdu)
Receive success function for STA 2.
Definition: wifi-phy-ofdma-test.cc:584
TestDlOfdmaPhyTransmission::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition: wifi-phy-ofdma-test.cc:1162
TestDlOfdmaPhyTransmission::m_phyAp
Ptr< SpectrumWifiPhy > m_phyAp
PHY of AP.
Definition: wifi-phy-ofdma-test.cc:437
TestDlOfdmaPhyTransmission::m_phySta1
Ptr< OfdmaSpectrumWifiPhy > m_phySta1
PHY of STA 1.
Definition: wifi-phy-ofdma-test.cc:438
TestDlOfdmaPhyTransmission::CheckResultsSta2
void CheckResultsSta2(uint32_t expectedRxSuccess, uint32_t expectedRxFailure, uint32_t expectedRxBytes)
Check the results for STA 2.
Definition: wifi-phy-ofdma-test.cc:643
TestDlOfdmaPhyTransmission::CheckPhyState
void CheckPhyState(Ptr< OfdmaSpectrumWifiPhy > phy, WifiPhyState expectedState)
Schedule now to check the PHY state.
Definition: wifi-phy-ofdma-test.cc:675
TestDlOfdmaPhyTransmission::m_countRxSuccessSta2
uint32_t m_countRxSuccessSta2
count RX success for STA 2
Definition: wifi-phy-ofdma-test.cc:428
TestDlOfdmaPhyTransmission::m_countRxFailureSta1
uint32_t m_countRxFailureSta1
count RX failure for STA 1
Definition: wifi-phy-ofdma-test.cc:430
TestDlOfdmaPhyTransmission::RxSuccessSta1
void RxSuccessSta1(Ptr< const WifiPsdu > psdu, RxSignalInfo rxSignalInfo, WifiTxVector txVector, std::vector< bool > statusPerMpdu)
Receive success function for STA 1.
Definition: wifi-phy-ofdma-test.cc:573
TestDlOfdmaPhyTransmission::CheckResultsSta1
void CheckResultsSta1(uint32_t expectedRxSuccess, uint32_t expectedRxFailure, uint32_t expectedRxBytes)
Check the results for STA 1.
Definition: wifi-phy-ofdma-test.cc:627
TestDlOfdmaPhyTransmission::m_phySta3
Ptr< OfdmaSpectrumWifiPhy > m_phySta3
PHY of STA 3.
Definition: wifi-phy-ofdma-test.cc:440
TestDlOfdmaPhyTransmission::RxSuccessSta3
void RxSuccessSta3(Ptr< const WifiPsdu > psdu, RxSignalInfo rxSignalInfo, WifiTxVector txVector, std::vector< bool > statusPerMpdu)
Receive success function for STA 3.
Definition: wifi-phy-ofdma-test.cc:595
TestDlOfdmaPhyTransmission::m_countRxSuccessSta3
uint32_t m_countRxSuccessSta3
count RX success for STA 3
Definition: wifi-phy-ofdma-test.cc:429
TestDlOfdmaPhyTransmission::DoCheckPhyState
void DoCheckPhyState(Ptr< OfdmaSpectrumWifiPhy > phy, WifiPhyState expectedState)
Check the PHY state now.
Definition: wifi-phy-ofdma-test.cc:683
TestDlOfdmaPhyTransmission::m_countRxBytesSta3
uint32_t m_countRxBytesSta3
count RX bytes for STA 3
Definition: wifi-phy-ofdma-test.cc:435
TestDlOfdmaPhyTransmission::RxFailureSta3
void RxFailureSta3(Ptr< const WifiPsdu > psdu)
Receive failure function for STA 3.
Definition: wifi-phy-ofdma-test.cc:620
TestDlOfdmaPhyTransmission::StopInterference
void StopInterference()
Stop interference function.
Definition: wifi-phy-ofdma-test.cc:563
TestDlOfdmaPhyTransmission::ResetResults
void ResetResults()
Reset the results.
Definition: wifi-phy-ofdma-test.cc:466
TestDlOfdmaPhyTransmission::RxFailureSta1
void RxFailureSta1(Ptr< const WifiPsdu > psdu)
Receive failure function for STA 1.
Definition: wifi-phy-ofdma-test.cc:606
TestDlOfdmaPhyTransmission::m_countRxSuccessSta1
uint32_t m_countRxSuccessSta1
count RX success for STA 1
Definition: wifi-phy-ofdma-test.cc:427
TestDlOfdmaPhyTransmission::CheckResultsSta3
void CheckResultsSta3(uint32_t expectedRxSuccess, uint32_t expectedRxFailure, uint32_t expectedRxBytes)
Check the results for STA 3.
Definition: wifi-phy-ofdma-test.cc:659
TestDlOfdmaPhyTransmission::SendMuPpdu
void SendMuPpdu(uint16_t rxStaId1, uint16_t rxStaId2)
Send MU-PPDU function.
Definition: wifi-phy-ofdma-test.cc:480
TestMultipleHeTbPreambles
UL-OFDMA multiple RX events test.
Definition: wifi-phy-ofdma-test.cc:2270
TestMultipleHeTbPreambles::m_trigVector
WifiTxVector m_trigVector
TRIGVECTOR.
Definition: wifi-phy-ofdma-test.cc:2334
TestMultipleHeTbPreambles::m_phy
Ptr< OfdmaSpectrumWifiPhy > m_phy
Phy.
Definition: wifi-phy-ofdma-test.cc:2331
TestMultipleHeTbPreambles::RxHeTbPpduOfdmaPart
void RxHeTbPpduOfdmaPart(Ptr< WifiSpectrumSignalParameters > rxParamsOfdma)
Receive OFDMA part of HE TB PPDU function.
Definition: wifi-phy-ofdma-test.cc:2493
TestMultipleHeTbPreambles::CheckHeTbPreambles
void CheckHeTbPreambles(size_t nEvents, std::vector< uint64_t > uids)
Check the received HE TB preambles.
Definition: wifi-phy-ofdma-test.cc:2375
TestMultipleHeTbPreambles::RxHeTbPpdu
void RxHeTbPpdu(uint64_t uid, uint16_t staId, double txPowerWatts, size_t payloadSize)
Receive HE TB PPDU function.
Definition: wifi-phy-ofdma-test.cc:2399
TestMultipleHeTbPreambles::m_totalBytesDropped
uint64_t m_totalBytesDropped
total number of dropped bytes
Definition: wifi-phy-ofdma-test.cc:2333
TestMultipleHeTbPreambles::CheckBytesDropped
void CheckBytesDropped(size_t expectedBytesDropped)
Check the number of bytes dropped.
Definition: wifi-phy-ofdma-test.cc:2391
TestMultipleHeTbPreambles::DoTeardown
void DoTeardown() override
Implementation to do any local setup required for this TestCase.
Definition: wifi-phy-ofdma-test.cc:2539
TestMultipleHeTbPreambles::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition: wifi-phy-ofdma-test.cc:2546
TestMultipleHeTbPreambles::RxDropped
void RxDropped(Ptr< const Packet > p, WifiPhyRxfailureReason reason)
RX dropped function.
Definition: wifi-phy-ofdma-test.cc:2368
TestMultipleHeTbPreambles::DoRxHeTbPpduOfdmaPart
void DoRxHeTbPpduOfdmaPart(Ptr< WifiSpectrumSignalParameters > rxParamsOfdma)
Receive OFDMA part of HE TB PPDU function.
Definition: wifi-phy-ofdma-test.cc:2499
TestMultipleHeTbPreambles::DoSetup
void DoSetup() override
Implementation to do any local setup required for this TestCase.
Definition: wifi-phy-ofdma-test.cc:2508
TestPhyPaddingExclusion
PHY padding exclusion test.
Definition: wifi-phy-ofdma-test.cc:4759
TestPhyPaddingExclusion::DoSetup
void DoSetup() override
Implementation to do any local setup required for this TestCase.
Definition: wifi-phy-ofdma-test.cc:5073
TestPhyPaddingExclusion::CheckRxFromSta1
void CheckRxFromSta1(uint32_t expectedSuccess, uint32_t expectedFailures, uint32_t expectedBytes)
Check the received PSDUs from STA1.
Definition: wifi-phy-ofdma-test.cc:4992
TestPhyPaddingExclusion::m_phySta2
Ptr< OfdmaSpectrumWifiPhy > m_phySta2
PHY of STA 2.
Definition: wifi-phy-ofdma-test.cc:4862
TestPhyPaddingExclusion::VerifyEventsCleared
void VerifyEventsCleared()
Verify all events are cleared at end of TX or RX.
Definition: wifi-phy-ofdma-test.cc:5026
TestPhyPaddingExclusion::DoCheckPhyState
void DoCheckPhyState(Ptr< OfdmaSpectrumWifiPhy > phy, WifiPhyState expectedState)
Check the PHY state.
Definition: wifi-phy-ofdma-test.cc:5048
TestPhyPaddingExclusion::DoTeardown
void DoTeardown() override
Implementation to do any local setup required for this TestCase.
Definition: wifi-phy-ofdma-test.cc:5177
TestPhyPaddingExclusion::GenerateInterference
void GenerateInterference(Ptr< SpectrumValue > interferencePsd, Time duration)
Generate interference function.
Definition: wifi-phy-ofdma-test.cc:4940
TestPhyPaddingExclusion::m_phyInterferer
Ptr< WaveformGenerator > m_phyInterferer
PHY of interferer.
Definition: wifi-phy-ofdma-test.cc:4864
TestPhyPaddingExclusion::m_countRxSuccessFromSta2
uint32_t m_countRxSuccessFromSta2
count RX success from STA 2
Definition: wifi-phy-ofdma-test.cc:4867
TestPhyPaddingExclusion::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition: wifi-phy-ofdma-test.cc:5218
TestPhyPaddingExclusion::RxFailure
void RxFailure(Ptr< const WifiPsdu > psdu)
Receive failure function.
Definition: wifi-phy-ofdma-test.cc:4978
TestPhyPaddingExclusion::m_countRxBytesFromSta1
uint32_t m_countRxBytesFromSta1
count RX bytes from STA 1
Definition: wifi-phy-ofdma-test.cc:4870
TestPhyPaddingExclusion::m_phyAp
Ptr< OfdmaSpectrumWifiPhy > m_phyAp
PHY of AP.
Definition: wifi-phy-ofdma-test.cc:4860
TestPhyPaddingExclusion::m_phySta1
Ptr< OfdmaSpectrumWifiPhy > m_phySta1
PHY of STA 1.
Definition: wifi-phy-ofdma-test.cc:4861
TestPhyPaddingExclusion::SendHeTbPpdu
void SendHeTbPpdu(uint16_t txStaId, std::size_t index, std::size_t payloadSize, Time txDuration)
Send HE TB PPDU function.
Definition: wifi-phy-ofdma-test.cc:4886
TestPhyPaddingExclusion::RxSuccess
void RxSuccess(Ptr< const WifiPsdu > psdu, RxSignalInfo rxSignalInfo, WifiTxVector txVector, std::vector< bool > statusPerMpdu)
Receive success function.
Definition: wifi-phy-ofdma-test.cc:4959
TestPhyPaddingExclusion::SetTrigVector
void SetTrigVector(Time ppduDuration)
Set TRIGVECTOR for HE TB PPDU.
Definition: wifi-phy-ofdma-test.cc:5190
TestPhyPaddingExclusion::Reset
void Reset()
Reset function.
Definition: wifi-phy-ofdma-test.cc:5059
TestPhyPaddingExclusion::m_countRxFailureFromSta1
uint32_t m_countRxFailureFromSta1
count RX failure from STA 1
Definition: wifi-phy-ofdma-test.cc:4868
TestPhyPaddingExclusion::m_countRxSuccessFromSta1
uint32_t m_countRxSuccessFromSta1
count RX success from STA 1
Definition: wifi-phy-ofdma-test.cc:4866
TestPhyPaddingExclusion::StopInterference
void StopInterference()
Stop interference function.
Definition: wifi-phy-ofdma-test.cc:4949
TestPhyPaddingExclusion::RunOne
void RunOne()
Run one function.
TestPhyPaddingExclusion::CheckRxFromSta2
void CheckRxFromSta2(uint32_t expectedSuccess, uint32_t expectedFailures, uint32_t expectedBytes)
Check the received PSDUs from STA2.
Definition: wifi-phy-ofdma-test.cc:5009
TestPhyPaddingExclusion::m_countRxFailureFromSta2
uint32_t m_countRxFailureFromSta2
count RX failure from STA 2
Definition: wifi-phy-ofdma-test.cc:4869
TestPhyPaddingExclusion::m_countRxBytesFromSta2
uint32_t m_countRxBytesFromSta2
count RX bytes from STA 2
Definition: wifi-phy-ofdma-test.cc:4871
TestPhyPaddingExclusion::CheckPhyState
void CheckPhyState(Ptr< OfdmaSpectrumWifiPhy > phy, WifiPhyState expectedState)
Check the PHY state.
Definition: wifi-phy-ofdma-test.cc:5040
TestUlOfdmaPhyTransmission::ScheduleTest
void ScheduleTest(Time delay, bool solicited, WifiPhyState expectedStateAtEnd, uint32_t expectedSuccessFromSta1, uint32_t expectedFailuresFromSta1, uint32_t expectedBytesFromSta1, uint32_t expectedSuccessFromSta2, uint32_t expectedFailuresFromSta2, uint32_t expectedBytesFromSta2, bool scheduleTxSta1=true, Time ulTimeDifference=Seconds(0), WifiPhyState expectedStateBeforeEnd=WifiPhyState::RX, TrigVectorInfo error=NONE)
Schedule test to perform.
Definition: wifi-phy-ofdma-test.cc:3859
TestUlOfdmaPhyTransmission::GenerateInterference
void GenerateInterference(Ptr< SpectrumValue > interferencePsd, Time duration)
Generate interference function.
Definition: wifi-phy-ofdma-test.cc:3454
TestUlOfdmaPhyTransmission::GetTxVectorForHeTbPpdu
WifiTxVector GetTxVectorForHeTbPpdu(uint16_t txStaId, std::size_t index, uint8_t bssColor) const
Get TXVECTOR for HE TB PPDU.
Definition: wifi-phy-ofdma-test.cc:3278
TestUlOfdmaPhyTransmission::m_countRxFailureFromSta1
uint32_t m_countRxFailureFromSta1
count RX failure from STA 1
Definition: wifi-phy-ofdma-test.cc:3198
TestUlOfdmaPhyTransmission::CheckOfdmaRxPower
void CheckOfdmaRxPower(Ptr< OfdmaSpectrumWifiPhy > phy, WifiSpectrumBand band, double expectedRxPower)
Check the received power for the OFDMA part of the HE TB PPDUs over the given band.
Definition: wifi-phy-ofdma-test.cc:3559
TestUlOfdmaPhyTransmission::DoCheckPhyState
void DoCheckPhyState(Ptr< OfdmaSpectrumWifiPhy > phy, WifiPhyState expectedState)
Check the PHY state.
Definition: wifi-phy-ofdma-test.cc:3616
TestUlOfdmaPhyTransmission::m_countRxBytesFromSta1
uint32_t m_countRxBytesFromSta1
count RX bytes from STA 1
Definition: wifi-phy-ofdma-test.cc:3200
TestUlOfdmaPhyTransmission::m_frequency
uint16_t m_frequency
frequency in MHz
Definition: wifi-phy-ofdma-test.cc:3203
TestUlOfdmaPhyTransmission::m_apPhyStateListener
std::unique_ptr< OfdmaTestPhyListener > m_apPhyStateListener
listener for AP PHY state transitions
Definition: wifi-phy-ofdma-test.cc:3192
TestUlOfdmaPhyTransmission::RxFailure
void RxFailure(Ptr< const WifiPsdu > psdu)
Receive failure function.
Definition: wifi-phy-ofdma-test.cc:3493
TestUlOfdmaPhyTransmission::CheckApRxStart
void CheckApRxStart(uint32_t expectedNotifications, Time expectedLastNotification)
Check the the number of RX start notifications at the AP as well as the last time a RX start has been...
Definition: wifi-phy-ofdma-test.cc:3632
TestUlOfdmaPhyTransmission::TrigVectorInfo
TrigVectorInfo
Erroneous info included in a TRIGVECTOR.
Definition: wifi-phy-ofdma-test.cc:2950
TestUlOfdmaPhyTransmission::SchedulePowerMeasurementChecks
void SchedulePowerMeasurementChecks(Time delay, double rxPowerNonOfdmaRu1, double rxPowerNonOfdmaRu2, double rxPowerOfdmaRu1, double rxPowerOfdmaRu2)
Schedule power measurement related checks.
Definition: wifi-phy-ofdma-test.cc:3984
TestUlOfdmaPhyTransmission::SetBssColor
void SetBssColor(Ptr< WifiPhy > phy, uint8_t bssColor)
Set the BSS color.
Definition: wifi-phy-ofdma-test.cc:3691
TestUlOfdmaPhyTransmission::m_phySta2
Ptr< OfdmaSpectrumWifiPhy > m_phySta2
PHY of STA 2.
Definition: wifi-phy-ofdma-test.cc:3188
TestUlOfdmaPhyTransmission::LogScenario
void LogScenario(std::string log) const
Log scenario description.
Definition: wifi-phy-ofdma-test.cc:3853
TestUlOfdmaPhyTransmission::CheckRxFromSta2
void CheckRxFromSta2(uint32_t expectedSuccess, uint32_t expectedFailures, uint32_t expectedBytes)
Check the received PSDUs from STA2.
Definition: wifi-phy-ofdma-test.cc:3524
TestUlOfdmaPhyTransmission::SendHeTbPpdu
void SendHeTbPpdu(uint16_t txStaId, std::size_t index, std::size_t payloadSize, uint64_t uid, uint8_t bssColor, bool incrementUid)
Send HE TB PPDU function.
Definition: wifi-phy-ofdma-test.cc:3402
TestUlOfdmaPhyTransmission::SetPsdLimit
void SetPsdLimit(Ptr< WifiPhy > phy, double psdLimit)
Set the PSD limit.
Definition: wifi-phy-ofdma-test.cc:3699
TestUlOfdmaPhyTransmission::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition: wifi-phy-ofdma-test.cc:4723
TestUlOfdmaPhyTransmission::DoSetup
void DoSetup() override
Implementation to do any local setup required for this TestCase.
Definition: wifi-phy-ofdma-test.cc:3706
TestUlOfdmaPhyTransmission::StopInterference
void StopInterference()
Stop interference function.
Definition: wifi-phy-ofdma-test.cc:3464
TestUlOfdmaPhyTransmission::m_countRxBytesFromSta2
uint32_t m_countRxBytesFromSta2
count RX bytes from STA 2
Definition: wifi-phy-ofdma-test.cc:3201
TestUlOfdmaPhyTransmission::DoTeardown
void DoTeardown() override
Implementation to do any local setup required for this TestCase.
Definition: wifi-phy-ofdma-test.cc:3838
TestUlOfdmaPhyTransmission::CheckPhyState
void CheckPhyState(Ptr< OfdmaSpectrumWifiPhy > phy, WifiPhyState expectedState)
Check the PHY state.
Definition: wifi-phy-ofdma-test.cc:3608
TestUlOfdmaPhyTransmission::m_phySta1
Ptr< OfdmaSpectrumWifiPhy > m_phySta1
PHY of STA 1.
Definition: wifi-phy-ofdma-test.cc:3187
TestUlOfdmaPhyTransmission::RxSuccess
void RxSuccess(Ptr< const WifiPsdu > psdu, RxSignalInfo rxSignalInfo, WifiTxVector txVector, std::vector< bool > statusPerMpdu)
Receive success function.
Definition: wifi-phy-ofdma-test.cc:3474
TestUlOfdmaPhyTransmission::CheckRxFromSta1
void CheckRxFromSta1(uint32_t expectedSuccess, uint32_t expectedFailures, uint32_t expectedBytes)
Check the received PSDUs from STA1.
Definition: wifi-phy-ofdma-test.cc:3507
TestUlOfdmaPhyTransmission::CheckNonOfdmaRxPower
void CheckNonOfdmaRxPower(Ptr< OfdmaSpectrumWifiPhy > phy, WifiSpectrumBand band, double expectedRxPower)
Check the received power for the non-OFDMA of the HE TB PPDUs over the given band.
Definition: wifi-phy-ofdma-test.cc:3541
TestUlOfdmaPhyTransmission::RunOne
void RunOne()
Run one function.
Definition: wifi-phy-ofdma-test.cc:4122
TestUlOfdmaPhyTransmission::m_countRxSuccessFromSta2
uint32_t m_countRxSuccessFromSta2
count RX success from STA 2
Definition: wifi-phy-ofdma-test.cc:3197
TestUlOfdmaPhyTransmission::m_phyInterferer
Ptr< WaveformGenerator > m_phyInterferer
PHY of interferer.
Definition: wifi-phy-ofdma-test.cc:3194
TestUlOfdmaPhyTransmission::CheckApRxEnd
void CheckApRxEnd(uint32_t expectedNotifications, Time expectedLastNotification, bool expectedSuccess)
Check the the number of RX end notifications at the AP as well as the last time a RX end has been not...
Definition: wifi-phy-ofdma-test.cc:3650
TestUlOfdmaPhyTransmission::m_phySta3
Ptr< OfdmaSpectrumWifiPhy > m_phySta3
PHY of STA 3.
Definition: wifi-phy-ofdma-test.cc:3189
TestUlOfdmaPhyTransmission::m_channelWidth
uint16_t m_channelWidth
channel width in MHz
Definition: wifi-phy-ofdma-test.cc:3204
TestUlOfdmaPhyTransmission::SendHeSuPpdu
void SendHeSuPpdu(uint16_t txStaId, std::size_t payloadSize, uint64_t uid, uint8_t bssColor)
Send HE SU PPDU function.
Definition: wifi-phy-ofdma-test.cc:3223
TestUlOfdmaPhyTransmission::m_countRxFailureFromSta2
uint32_t m_countRxFailureFromSta2
count RX failure from STA 2
Definition: wifi-phy-ofdma-test.cc:3199
TestUlOfdmaPhyTransmission::VerifyEventsCleared
void VerifyEventsCleared()
Verify all events are cleared at end of TX or RX.
Definition: wifi-phy-ofdma-test.cc:3594
TestUlOfdmaPhyTransmission::SetTrigVector
void SetTrigVector(uint8_t bssColor, TrigVectorInfo error)
Set TRIGVECTOR for HE TB PPDU.
Definition: wifi-phy-ofdma-test.cc:3331
TestUlOfdmaPhyTransmission::m_expectedPpduDuration
Time m_expectedPpduDuration
expected duration to send MU PPDU
Definition: wifi-phy-ofdma-test.cc:3205
TestUlOfdmaPhyTransmission::m_countRxSuccessFromSta1
uint32_t m_countRxSuccessFromSta1
count RX success from STA 1
Definition: wifi-phy-ofdma-test.cc:3196
TestUlOfdmaPhyTransmission::m_phyAp
Ptr< OfdmaSpectrumWifiPhy > m_phyAp
PHY of AP.
Definition: wifi-phy-ofdma-test.cc:3186
TestUlOfdmaPowerControl
UL-OFDMA power control test.
Definition: wifi-phy-ofdma-test.cc:5345
TestUlOfdmaPowerControl::m_requestedRssiSta1
double m_requestedRssiSta1
requested RSSI (in dBm) from STA 1 at AP for HE TB PPDUs
Definition: wifi-phy-ofdma-test.cc:5411
TestUlOfdmaPowerControl::m_txPowerStart
double m_txPowerStart
minimum transmission power (in dBm) for STAs
Definition: wifi-phy-ofdma-test.cc:5407
TestUlOfdmaPowerControl::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition: wifi-phy-ofdma-test.cc:5771
TestUlOfdmaPowerControl::m_rssiSta2
double m_rssiSta2
expected RSSI (in dBm) from STA 2 at AP for HE TB PPDUs
Definition: wifi-phy-ofdma-test.cc:5415
TestUlOfdmaPowerControl::m_sta2Dev
Ptr< WifiNetDevice > m_sta2Dev
network device of STA 2
Definition: wifi-phy-ofdma-test.cc:5402
TestUlOfdmaPowerControl::m_txPowerEnd
double m_txPowerEnd
maximum transmission power (in dBm) for STAs
Definition: wifi-phy-ofdma-test.cc:5408
TestUlOfdmaPowerControl::SetupBa
void SetupBa(Address destination)
Send a QoS Data packet to the destination station in order to set up a block Ack session (so that the...
Definition: wifi-phy-ofdma-test.cc:5444
TestUlOfdmaPowerControl::m_sta1Dev
Ptr< WifiNetDevice > m_sta1Dev
network device of STA 1
Definition: wifi-phy-ofdma-test.cc:5401
TestUlOfdmaPowerControl::m_tol
double m_tol
tolerance (in dB) between received and expected RSSIs
Definition: wifi-phy-ofdma-test.cc:5417
TestUlOfdmaPowerControl::m_apDev
Ptr< WifiNetDevice > m_apDev
network device of AP
Definition: wifi-phy-ofdma-test.cc:5400
TestUlOfdmaPowerControl::DoTeardown
void DoTeardown() override
Implementation to do any local setup required for this TestCase.
Definition: wifi-phy-ofdma-test.cc:5678
TestUlOfdmaPowerControl::ReceiveOkCallbackAtAp
void ReceiveOkCallbackAtAp(Ptr< const WifiPsdu > psdu, RxSignalInfo rxSignalInfo, WifiTxVector txVector, std::vector< bool > statusPerMpdu)
Receive OK callback function at AP.
Definition: wifi-phy-ofdma-test.cc:5564
TestUlOfdmaPowerControl::ReplaceReceiveOkCallbackOfAp
void ReplaceReceiveOkCallbackOfAp()
Replace the AP's callback on its PHY's ReceiveOkCallback by the ReceiveOkCallbackAtAp method.
Definition: wifi-phy-ofdma-test.cc:5599
TestUlOfdmaPowerControl::m_rssiSta1
double m_rssiSta1
expected RSSI (in dBm) from STA 1 at AP for HE TB PPDUs
Definition: wifi-phy-ofdma-test.cc:5414
TestUlOfdmaPowerControl::m_txPowerLevels
uint8_t m_txPowerLevels
number of transmission power levels for STAs
Definition: wifi-phy-ofdma-test.cc:5409
TestUlOfdmaPowerControl::m_requestedRssiSta2
double m_requestedRssiSta2
requested RSSI (in dBm) from STA 2 at AP for HE TB PPDUs
Definition: wifi-phy-ofdma-test.cc:5412
TestUlOfdmaPowerControl::m_txPowerAp
double m_txPowerAp
transmit power (in dBm) of AP
Definition: wifi-phy-ofdma-test.cc:5406
TestUlOfdmaPowerControl::RunOne
void RunOne(bool setupBa)
Run one simulation with an optional BA session set up phase.
Definition: wifi-phy-ofdma-test.cc:5691
TestUlOfdmaPowerControl::DoSetup
void DoSetup() override
Implementation to do any local setup required for this TestCase.
Definition: wifi-phy-ofdma-test.cc:5607
TestUlOfdmaPowerControl::m_phyAp
Ptr< SpectrumWifiPhy > m_phyAp
PHY of AP.
Definition: wifi-phy-ofdma-test.cc:5404
TestUlOfdmaPowerControl::SendMuBar
void SendMuBar(std::vector< uint16_t > staIds)
Send a MU BAR through the AP to the STAs listed in the provided vector.
Definition: wifi-phy-ofdma-test.cc:5452
TestUlOfdmaPpduUid
UL-OFDMA PPDU UID attribution test.
Definition: wifi-phy-ofdma-test.cc:1833
TestUlOfdmaPpduUid::TxPpduSta1
void TxPpduSta1(uint64_t uid)
Transmitted PPDU information function for STA 1.
Definition: wifi-phy-ofdma-test.cc:2034
TestUlOfdmaPpduUid::ResetPpduUid
void ResetPpduUid()
Reset the global PPDU UID counter in WifiPhy.
Definition: wifi-phy-ofdma-test.cc:2048
TestUlOfdmaPpduUid::CheckUid
void CheckUid(uint16_t staId, uint64_t expectedUid)
Check the UID of the transmitted PPDU.
Definition: wifi-phy-ofdma-test.cc:1999
TestUlOfdmaPpduUid::TxPpduAp
void TxPpduAp(uint64_t uid)
Transmitted PPDU information function for AP.
Definition: wifi-phy-ofdma-test.cc:2027
TestUlOfdmaPpduUid::TxPpduSta2
void TxPpduSta2(uint64_t uid)
Transmitted PPDU information function for STA 2.
Definition: wifi-phy-ofdma-test.cc:2041
TestUlOfdmaPpduUid::m_phySta2
Ptr< OfdmaSpectrumWifiPhy > m_phySta2
PHY of STA 2.
Definition: wifi-phy-ofdma-test.cc:1886
TestUlOfdmaPpduUid::m_ppduUidAp
uint64_t m_ppduUidAp
UID of PPDU transmitted by AP.
Definition: wifi-phy-ofdma-test.cc:1888
TestUlOfdmaPpduUid::m_ppduUidSta1
uint64_t m_ppduUidSta1
UID of PPDU transmitted by STA1.
Definition: wifi-phy-ofdma-test.cc:1889
TestUlOfdmaPpduUid::m_ppduUidSta2
uint64_t m_ppduUidSta2
UID of PPDU transmitted by STA2.
Definition: wifi-phy-ofdma-test.cc:1890
TestUlOfdmaPpduUid::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition: wifi-phy-ofdma-test.cc:2224
TestUlOfdmaPpduUid::DoTeardown
void DoTeardown() override
Implementation to do any local setup required for this TestCase.
Definition: wifi-phy-ofdma-test.cc:1988
TestUlOfdmaPpduUid::SendMuPpdu
void SendMuPpdu()
Send MU-PPDU toward both STAs.
Definition: wifi-phy-ofdma-test.cc:2055
TestUlOfdmaPpduUid::m_phySta1
Ptr< OfdmaSpectrumWifiPhy > m_phySta1
PHY of STA 1.
Definition: wifi-phy-ofdma-test.cc:1885
TestUlOfdmaPpduUid::DoSetup
void DoSetup() override
Implementation to do any local setup required for this TestCase.
Definition: wifi-phy-ofdma-test.cc:1906
TestUlOfdmaPpduUid::SendTbPpdu
void SendTbPpdu()
Send TB-PPDU from both STAs.
Definition: wifi-phy-ofdma-test.cc:2105
TestUlOfdmaPpduUid::m_phyAp
Ptr< OfdmaSpectrumWifiPhy > m_phyAp
PHY of AP.
Definition: wifi-phy-ofdma-test.cc:1884
TestUlOfdmaPpduUid::SendSuPpdu
void SendSuPpdu(uint16_t txStaId)
Send SU-PPDU function.
Definition: wifi-phy-ofdma-test.cc:2184
WifiPhyOfdmaTestSuite
wifi PHY OFDMA Test Suite
Definition: wifi-phy-ofdma-test.cc:5850
ns3::Address
a polymophic address class
Definition: address.h:100
ns3::BooleanValue
AttributeValue implementation for Boolean.
Definition: boolean.h:37
ns3::CtrlBAckRequestHeader
Headers for BlockAckRequest.
Definition: ctrl-headers.h:52
ns3::CtrlBAckRequestHeader::SetType
void SetType(BlockAckReqType type)
Set the BlockAckRequest type.
Definition: ctrl-headers.cc:203
ns3::CtrlBAckRequestHeader::SetStartingSequence
void SetStartingSequence(uint16_t seq)
Set the starting sequence number from the given raw sequence control field.
Definition: ctrl-headers.cc:221
ns3::CtrlBAckRequestHeader::SetTidInfo
void SetTidInfo(uint8_t tid)
Set Traffic ID (TID).
Definition: ctrl-headers.cc:215
ns3::CtrlTriggerHeader
Headers for Trigger frames.
Definition: ctrl-headers.h:945
ns3::CtrlTriggerHeader::AddUserInfoField
CtrlTriggerUserInfoField & AddUserInfoField()
Append a new User Info field to this Trigger frame and return a non-const reference to it.
Definition: ctrl-headers.cc:2125
ns3::CtrlTriggerHeader::SetApTxPower
void SetApTxPower(int8_t power)
Set the AP TX Power subfield of the Common Info field.
Definition: ctrl-headers.cc:2088
ns3::CtrlTriggerHeader::GetHeTbTxVector
WifiTxVector GetHeTbTxVector(uint16_t staId) const
Get the TX vector that the station with the given STA-ID will use to send the HE TB PPDU solicited by...
Definition: ctrl-headers.cc:1957
ns3::CtrlTriggerHeader::SetUlBandwidth
void SetUlBandwidth(uint16_t bw)
Set the bandwidth of the solicited HE TB PPDU.
Definition: ctrl-headers.cc:2000
ns3::CtrlTriggerHeader::SetType
void SetType(TriggerFrameType type)
Set the Trigger frame type.
Definition: ctrl-headers.cc:1855
ns3::CtrlTriggerHeader::SetCsRequired
void SetCsRequired(bool cs)
Set the CS Required subfield of the Common Info field.
Definition: ctrl-headers.cc:1988
ns3::CtrlTriggerHeader::SetGiAndLtfType
void SetGiAndLtfType(uint16_t guardInterval, uint8_t ltfType)
Set the GI And LTF Type subfield of the Common Info field.
Definition: ctrl-headers.cc:2029
ns3::CtrlTriggerHeader::SetUlSpatialReuse
void SetUlSpatialReuse(uint16_t sr)
Set the UL Spatial Reuse subfield of the Common Info field.
Definition: ctrl-headers.cc:2104
ns3::CtrlTriggerHeader::SetUlLength
void SetUlLength(uint16_t len)
Set the UL Length subfield of the Common Info field.
Definition: ctrl-headers.cc:1945
ns3::CtrlTriggerHeader::SetMoreTF
void SetMoreTF(bool more)
Set the More TF subfield of the Common Info field.
Definition: ctrl-headers.cc:1976
ns3::CtrlTriggerUserInfoField
User Info field of Trigger frames.
Definition: ctrl-headers.h:590
ns3::CtrlTriggerUserInfoField::SetAid12
void SetAid12(uint16_t aid)
Set the AID12 subfield, which carries the 12 LSBs of the AID of the station for which this User Info ...
Definition: ctrl-headers.cc:1281
ns3::CtrlTriggerUserInfoField::SetUlFecCodingType
void SetUlFecCodingType(bool ldpc)
Set the UL FEC Coding Type subfield, which indicates whether BCC or LDPC is used.
Definition: ctrl-headers.cc:1438
ns3::CtrlTriggerUserInfoField::SetUlMcs
void SetUlMcs(uint8_t mcs)
Set the UL MCS subfield, which indicates the MCS of the solicited HE TB PPDU.
Definition: ctrl-headers.cc:1450
ns3::CtrlTriggerUserInfoField::SetMuBarTriggerDepUserInfo
void SetMuBarTriggerDepUserInfo(const CtrlBAckRequestHeader &bar)
Set the Trigger Dependent User Info subfield for the MU-BAR variant of Trigger frames,...
Definition: ctrl-headers.cc:1599
ns3::CtrlTriggerUserInfoField::SetUlDcm
void SetUlDcm(bool dcm)
Set the UL DCM subfield, which indicates whether or not DCM is used.
Definition: ctrl-headers.cc:1463
ns3::CtrlTriggerUserInfoField::SetSsAllocation
void SetSsAllocation(uint8_t startingSs, uint8_t nSs)
Set the SS Allocation subfield, which is present when the AID12 subfield is neither 0 nor 2045.
Definition: ctrl-headers.cc:1477
ns3::CtrlTriggerUserInfoField::SetUlTargetRssi
void SetUlTargetRssi(int8_t dBm)
Set the UL Target RSSI subfield to indicate the expected receive signal power in dBm.
Definition: ctrl-headers.cc:1540
ns3::CtrlTriggerUserInfoField::SetRuAllocation
void SetRuAllocation(HeRu::RuSpec ru)
Set the RU Allocation subfield according to the specified RU.
Definition: ctrl-headers.cc:1305
ns3::DoubleValue
This class can be used to hold variables of floating point type such as 'double' or 'float'.
Definition: double.h:42
ns3::HePhy
PHY entity for HE (11ax)
Definition: he-phy.h:68
ns3::HeRu::RuSpec
RU Specification.
Definition: he-ru.h:66
ns3::HeRu::RuSpec::GetRuType
RuType GetRuType() const
Get the RU type.
Definition: he-ru.cc:435
ns3::HeRu::RuType
RuType
The different HE Resource Unit (RU) types.
Definition: he-ru.h:41
ns3::Mac48Address
an EUI-48 address
Definition: mac48-address.h:46
ns3::MobilityHelper
Helper class used to assign positions and mobility models to nodes.
Definition: mobility-helper.h:44
ns3::MobilityModel
Keep track of the current position and velocity of an object.
Definition: mobility-model.h:40
ns3::NetDeviceContainer
holds a vector of ns3::NetDevice pointers
Definition: net-device-container.h:43
ns3::NetDeviceContainer::Get
Ptr< NetDevice > Get(uint32_t i) const
Get the Ptr<NetDevice> stored in this container at a given index.
Definition: net-device-container.cc:67
ns3::NodeContainer
keep track of a set of node pointers.
Definition: node-container.h:40
ns3::NodeContainer::Create
void Create(uint32_t n)
Create n nodes and append pointers to them to the end of this NodeContainer.
Definition: node-container.cc:84
ns3::NodeContainer::Get
Ptr< Node > Get(uint32_t i) const
Get the Ptr<Node> stored in this container at a given index.
Definition: node-container.cc:78
ns3::Node::AddDevice
uint32_t AddDevice(Ptr< NetDevice > device)
Associate a NetDevice to this node.
Definition: node.cc:138
ns3::ObjectBase::TraceConnectWithoutContext
bool TraceConnectWithoutContext(std::string name, const CallbackBase &cb)
Connect a TraceSource to a Callback without a context.
Definition: object-base.cc:311
ns3::ObjectBase::SetAttribute
void SetAttribute(std::string name, const AttributeValue &value)
Set a single attribute, raising fatal errors if unsuccessful.
Definition: object-base.cc:200
ns3::Object::GetObject
Ptr< T > GetObject() const
Get a pointer to the requested aggregated Object.
Definition: object.h:471
ns3::Object::AggregateObject
void AggregateObject(Ptr< Object > other)
Aggregate two Objects together.
Definition: object.cc:259
ns3::Object::Dispose
void Dispose()
Dispose of this Object.
Definition: object.cc:219
ns3::Packet::AddHeader
void AddHeader(const Header &header)
Add header to this packet.
Definition: packet.cc:268
ns3::Packet::GetSize
uint32_t GetSize() const
Returns the the size in bytes of the packet (including the zero-filled initial payload).
Definition: packet.h:863
ns3::PhyEntity::SetOwner
void SetOwner(Ptr< WifiPhy > wifiPhy)
Set the WifiPhy owning this PHY entity.
Definition: phy-entity.cc:89
ns3::PhyEntity::m_globalPpduUid
static uint64_t m_globalPpduUid
Global counter of the PPDU UID.
Definition: phy-entity.h:987
ns3::PointerValue
Hold objects of type Ptr<T>.
Definition: pointer.h:37
ns3::PointerValue::Get
Ptr< T > Get() const
Definition: pointer.h:206
ns3::Ptr
Smart pointer class similar to boost::intrusive_ptr.
Definition: ptr.h:78
ns3::SpectrumWifiPhyHelper
Make it easy to create and manage PHY objects for the spectrum model.
Definition: spectrum-wifi-helper.h:38
ns3::SpectrumWifiPhyHelper::SetChannel
void SetChannel(Ptr< SpectrumChannel > channel)
Definition: spectrum-wifi-helper.cc:52
ns3::SpectrumWifiPhy
802.11 PHY layer model
Definition: spectrum-wifi-phy.h:57
ns3::SpectrumWifiPhy::SetChannel
void SetChannel(const Ptr< SpectrumChannel > channel)
Set the SpectrumChannel this SpectrumWifiPhy is to be connected to.
Definition: spectrum-wifi-phy.cc:236
ns3::SpectrumWifiPhy::GetGuardBandwidth
uint16_t GetGuardBandwidth(uint16_t currentChannelWidth) const override
Definition: spectrum-wifi-phy.cc:509
ns3::SpectrumWifiPhy::StartRx
void StartRx(Ptr< SpectrumSignalParameters > rxParams)
Input method for delivering a signal from the spectrum channel and low-level PHY interface to this Sp...
Definition: spectrum-wifi-phy.cc:277
ns3::SpectrumWifiPhy::CreateWifiSpectrumPhyInterface
void CreateWifiSpectrumPhyInterface(Ptr< NetDevice > device)
Method to encapsulate the creation of the WifiSpectrumPhyInterface object (used to bind the WifiSpect...
Definition: spectrum-wifi-phy.cc:441
ns3::StringValue
Hold variables of type string.
Definition: string.h:56
ns3::TestCase
encapsulates test code
Definition: test.h:1060
ns3::TestCase::AddTestCase
void AddTestCase(TestCase *testCase, TestDuration duration=QUICK)
Add an individual child TestCase to this test suite.
Definition: test.cc:305
ns3::TestSuite
A suite of tests to run.
Definition: test.h:1256
ns3::Time
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:105
ns3::TimeValue
AttributeValue implementation for Time.
Definition: nstime.h:1423
ns3::TypeId
a unique identifier for an interface.
Definition: type-id.h:60
ns3::TypeId::SetParent
TypeId SetParent(TypeId tid)
Set the parent TypeId.
Definition: type-id.cc:935
ns3::UintegerValue
Hold an unsigned integer type.
Definition: uinteger.h:45
ns3::WaveformGenerator::SetDevice
void SetDevice(Ptr< NetDevice > d) override
Set the associated NetDevice instance.
Definition: waveform-generator.cc:114
ns3::WaveformGenerator::SetChannel
void SetChannel(Ptr< SpectrumChannel > c) override
Set the channel attached to this device.
Definition: waveform-generator.cc:126
ns3::WaveformGenerator::Start
virtual void Start()
Start the waveform generator.
Definition: waveform-generator.cc:202
ns3::WaveformGenerator::SetTxPowerSpectralDensity
void SetTxPowerSpectralDensity(Ptr< SpectrumValue > txs)
Set the Power Spectral Density used for outgoing waveforms.
Definition: waveform-generator.cc:139
ns3::WaveformGenerator::SetDutyCycle
void SetDutyCycle(double value)
Definition: waveform-generator.cc:171
ns3::WaveformGenerator::SetPeriod
void SetPeriod(Time period)
Set the period according to which the WaveformGenerator switches on and off.
Definition: waveform-generator.cc:159
ns3::WaveformGenerator::Stop
virtual void Stop()
Stop the waveform generator.
Definition: waveform-generator.cc:214
ns3::WifiHelper
helps to create WifiNetDevice objects
Definition: wifi-helper.h:325
ns3::WifiMacHeader
Implements the IEEE 802.11 MAC header.
Definition: wifi-mac-header.h:97
ns3::WifiMacHeader::GetType
WifiMacType GetType() const
Return the type (enum WifiMacType)
Definition: wifi-mac-header.cc:469
ns3::WifiMacHeader::SetNoMoreFragments
void SetNoMoreFragments()
Un-set the More Fragment bit in the Frame Control Field.
Definition: wifi-mac-header.cc:330
ns3::WifiMacHeader::SetSequenceNumber
void SetSequenceNumber(uint16_t seq)
Set the sequence number of the header.
Definition: wifi-mac-header.cc:318
ns3::WifiMacHeader::SetAddr1
void SetAddr1(Mac48Address address)
Fill the Address 1 field with the given address.
Definition: wifi-mac-header.cc:109
ns3::WifiMacHeader::SetType
void SetType(WifiMacType type, bool resetToDsFromDs=true)
Set Type/Subtype values with the correct values depending on the given type.
Definition: wifi-mac-header.cc:133
ns3::WifiMacHeader::GetAddr2
Mac48Address GetAddr2() const
Return the address in the Address 2 field.
Definition: wifi-mac-header.cc:451
ns3::WifiMacHeader::SetQosTid
void SetQosTid(uint8_t tid)
Set the TID for the QoS header.
Definition: wifi-mac-header.cc:366
ns3::WifiMacHeader::SetDsFrom
void SetDsFrom()
Set the From DS bit in the Frame Control field.
Definition: wifi-mac-header.cc:85
ns3::WifiMacHeader::SetAddr2
void SetAddr2(Mac48Address address)
Fill the Address 2 field with the given address.
Definition: wifi-mac-header.cc:115
ns3::WifiMacHeader::SetAddr3
void SetAddr3(Mac48Address address)
Fill the Address 3 field with the given address.
Definition: wifi-mac-header.cc:121
ns3::WifiMacHeader::SetDsNotTo
void SetDsNotTo()
Un-set the To DS bit in the Frame Control field.
Definition: wifi-mac-header.cc:103
ns3::WifiMacHeader::SetNoRetry
void SetNoRetry()
Un-set the Retry bit in the Frame Control field.
Definition: wifi-mac-header.cc:360
ns3::WifiMacHelper
create MAC layers for a ns3::WifiNetDevice.
Definition: wifi-mac-helper.h:48
ns3::WifiMac::SetWifiPhys
virtual void SetWifiPhys(const std::vector< Ptr< WifiPhy >> &phys)
Definition: wifi-mac.cc:925
ns3::WifiNetDevice::SetMac
void SetMac(const Ptr< WifiMac > mac)
Definition: wifi-net-device.cc:246
ns3::WifiNetDevice::SetHeConfiguration
void SetHeConfiguration(Ptr< HeConfiguration > heConfiguration)
Definition: wifi-net-device.cc:636
ns3::WifiNetDevice::GetMac
Ptr< WifiMac > GetMac() const
Definition: wifi-net-device.cc:289
ns3::WifiNetDevice::Send
bool Send(Ptr< Packet > packet, const Address &dest, uint16_t protocolNumber) override
Definition: wifi-net-device.cc:478
ns3::WifiNetDevice::GetHeConfiguration
Ptr< HeConfiguration > GetHeConfiguration() const
Definition: wifi-net-device.cc:642
ns3::WifiNetDevice::SetStandard
void SetStandard(WifiStandard standard)
Set the Wifi standard.
Definition: wifi-net-device.cc:233
ns3::WifiNetDevice::GetPhy
Ptr< WifiPhy > GetPhy() const
Definition: wifi-net-device.cc:295
ns3::WifiNetDevice::SetPhy
void SetPhy(const Ptr< WifiPhy > phy)
Definition: wifi-net-device.cc:253
ns3::WifiNetDevice::GetAddress
Address GetAddress() const override
Definition: wifi-net-device.cc:377
ns3::WifiPhyHelper::Set
void Set(std::string name, const AttributeValue &v)
Definition: wifi-helper.cc:163
ns3::WifiPhyHelper::SetErrorRateModel
void SetErrorRateModel(std::string type, Args &&... args)
Helper function used to set the error rate model.
Definition: wifi-helper.h:551
ns3::WifiPhy::SetInterferenceHelper
virtual void SetInterferenceHelper(const Ptr< InterferenceHelper > helper)
Sets the interference helper.
Definition: wifi-phy.cc:624
ns3::WifiPhy::Send
void Send(Ptr< const WifiPsdu > psdu, const WifiTxVector &txVector)
This function is a wrapper for the Send variant that accepts a WifiConstPsduMap as first argument.
Definition: wifi-phy.cc:1693
ns3::WifiPhy::SetErrorRateModel
void SetErrorRateModel(const Ptr< ErrorRateModel > model)
Sets the error rate model.
Definition: wifi-phy.cc:632
ns3::WifiPhy::m_currentPreambleEvents
std::map< std::pair< uint64_t, WifiPreamble >, Ptr< Event > > m_currentPreambleEvents
store event associated to a PPDU (that has a unique ID and preamble combination) whose preamble is be...
Definition: wifi-phy.h:1221
ns3::WifiPhy::GetSifs
Time GetSifs() const
Return the Short Interframe Space (SIFS) for this PHY.
Definition: wifi-phy.cc:774
ns3::WifiPhy::SetReceiveErrorCallback
void SetReceiveErrorCallback(RxErrorCallback callback)
Definition: wifi-phy.cc:448
ns3::WifiPhy::ConfigureStandard
virtual void ConfigureStandard(WifiStandard standard)
Configure the PHY-level parameters for different Wi-Fi standard.
Definition: wifi-phy.cc:941
ns3::WifiPhy::CalculateTxDuration
static Time CalculateTxDuration(uint32_t size, const WifiTxVector &txVector, WifiPhyBand band, uint16_t staId=SU_STA_ID)
Definition: wifi-phy.cc:1480
ns3::WifiPhy::m_phyEntities
std::map< WifiModulationClass, Ptr< PhyEntity > > m_phyEntities
This map holds the supported PHY entities.
Definition: wifi-phy.h:1244
ns3::WifiPhy::SetOperatingChannel
void SetOperatingChannel(const ChannelTuple &channelTuple)
If the standard for this object has not been set yet, store the given channel settings.
Definition: wifi-phy.cc:1062
ns3::WifiPhy::GetPhyBand
WifiPhyBand GetPhyBand() const
Get the configured Wi-Fi band.
Definition: wifi-phy.cc:996
ns3::WifiPhy::m_currentEvent
Ptr< Event > m_currentEvent
Hold the current event.
Definition: wifi-phy.h:1219
ns3::WifiPhy::GetPhyEntity
Ptr< PhyEntity > GetPhyEntity(WifiModulationClass modulation) const
Get the supported PHY entity corresponding to the modulation class.
Definition: wifi-phy.cc:704
ns3::WifiPhy::m_previouslyRxPpduUid
uint64_t m_previouslyRxPpduUid
UID of the previously received PPDU, reset to UINT64_MAX upon transmission.
Definition: wifi-phy.h:1224
ns3::WifiPhy::SetDevice
void SetDevice(const Ptr< WifiNetDevice > device)
Sets the device this PHY is associated with.
Definition: wifi-phy.cc:600
ns3::WifiPhy::SetPreambleDetectionModel
void SetPreambleDetectionModel(const Ptr< PreambleDetectionModel > preambleDetectionModel)
Sets the preamble detection model.
Definition: wifi-phy.cc:652
ns3::WifiPhy::SetMobility
void SetMobility(const Ptr< MobilityModel > mobility)
assign a mobility model to this device
Definition: wifi-phy.cc:612
ns3::WifiPhy::RegisterListener
void RegisterListener(WifiPhyListener *listener)
Definition: wifi-phy.cc:454
ns3::WifiPhy::m_interference
Ptr< InterferenceHelper > m_interference
Pointer to a helper responsible for interference computations.
Definition: wifi-phy.h:1206
ns3::WifiPhy::SetReceiveOkCallback
void SetReceiveOkCallback(RxOkCallback callback)
Definition: wifi-phy.cc:442
ns3::WifiPhy::Reset
void Reset()
Reset data upon end of TX or RX.
Definition: wifi-phy.cc:1804
ns3::WifiPhy::ChannelTuple
std::tuple< uint8_t, uint16_t, int, uint8_t > ChannelTuple
Tuple identifying an operating channel.
Definition: wifi-phy.h:870
ns3::WifiPhy::GetLatestPhyEntity
Ptr< PhyEntity > GetLatestPhyEntity() const
Get the latest PHY entity supported by this PHY instance.
Definition: wifi-phy.cc:719
ns3::WifiPhy::AssignStreams
virtual int64_t AssignStreams(int64_t stream)
Assign a fixed random variable stream number to the random variables used by this model.
Definition: wifi-phy.cc:2184
ns3::WifiPhyListener
receive notifications about PHY events.
Definition: wifi-phy-listener.h:35
ns3::WifiPhyStateHelper
This objects implements the PHY state machine of the Wifi device.
Definition: wifi-phy-state-helper.h:69
ns3::WifiPsdu::GetHeader
const WifiMacHeader & GetHeader(std::size_t i) const
Get the header of the i-th MPDU.
Definition: wifi-psdu.cc:279
ns3::WifiPsdu::GetAddr2
Mac48Address GetAddr2() const
Get the Transmitter Address (TA), which is common to all the MPDUs.
Definition: wifi-psdu.cc:128
ns3::WifiPsdu::GetSize
uint32_t GetSize() const
Return the size of the PSDU in bytes.
Definition: wifi-psdu.cc:273
ns3::WifiPsdu::SetDuration
void SetDuration(Time duration)
Set the Duration/ID field on all the MPDUs.
Definition: wifi-psdu.cc:168
ns3::WifiPsdu::GetNMpdus
std::size_t GetNMpdus() const
Return the number of MPDUs constituting the PSDU.
Definition: wifi-psdu.cc:327
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:101
ns3::WifiTxVector::SetInactiveSubchannels
void SetInactiveSubchannels(const std::vector< bool > &inactiveSubchannels)
Set the 20 MHz subchannels that are punctured.
Definition: wifi-tx-vector.cc:579
ns3::WifiTxVector::SetHeMuUserInfo
void SetHeMuUserInfo(uint16_t staId, HeMuUserInfo userInfo)
Set the HE MU user-specific transmission information for the given STA-ID.
Definition: wifi-tx-vector.cc:506
ns3::WifiTxVector::GetPreambleType
WifiPreamble GetPreambleType() const
Definition: wifi-tx-vector.cc:179
ns3::WifiTxVector::GetRu
HeRu::RuSpec GetRu(uint16_t staId) const
Get the RU specification for the STA-ID.
Definition: wifi-tx-vector.cc:483
ns3::WifiTxVector::SetRuAllocation
void SetRuAllocation(const RuAllocation &ruAlloc)
Set RU Allocation of SIG-B common field.
Definition: wifi-tx-vector.cc:396
ns3::WifiTxVector::GetHeMuUserInfoMap
const HeMuUserInfoMap & GetHeMuUserInfoMap() const
Get a const reference to the map HE MU user-specific transmission information indexed by STA-ID.
Definition: wifi-tx-vector.cc:516
ns3::WifiTxVector::SetRu
void SetRu(HeRu::RuSpec ru, uint16_t staId)
Set the RU specification for the STA-ID.
Definition: wifi-tx-vector.cc:491
ns3::WifiTxVector::SetLength
void SetLength(uint16_t length)
Set the LENGTH field of the L-SIG.
Definition: wifi-tx-vector.cc:360
ns3::WifiTxVector::SetSigBMode
void SetSigBMode(const WifiMode &mode)
Set the MCS used for SIG-B.
Definition: wifi-tx-vector.cc:384
ns3::WifiTxVector::SetMode
void SetMode(WifiMode mode)
Sets the selected payload transmission mode.
Definition: wifi-tx-vector.cc:264
ns3::WifiTxVector::SetNss
void SetNss(uint8_t nss)
Sets the number of Nss.
Definition: wifi-tx-vector.cc:310
NS_ASSERT
#define NS_ASSERT(condition)
At runtime, in debugging builds, if this condition is not true, the program prints the source file,...
Definition: assert.h:66
NS_ASSERT_MSG
#define NS_ASSERT_MSG(condition, message)
At runtime, in debugging builds, if this condition is not true, the program prints the message to out...
Definition: assert.h:86
ns3::Config::Reset
void Reset()
Reset the initial value of every attribute as well as the value of every global to what they were bef...
Definition: config.cc:856
NS_ABORT_MSG
#define NS_ABORT_MSG(msg)
Unconditional abnormal program termination with a message.
Definition: abort.h:49
NS_LOG_COMPONENT_DEFINE
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:202
NS_LOG_DEBUG
#define NS_LOG_DEBUG(msg)
Use NS_LOG to output a message of level LOG_DEBUG.
Definition: log.h:268
NS_LOG_FUNCTION
#define NS_LOG_FUNCTION(parameters)
If log level LOG_FUNCTION is enabled, this macro will output all input parameters separated by ",...
Definition: log-macros-enabled.h:238
NS_LOG_INFO
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Definition: log.h:275
ns3::Now
Time Now()
create an ns3::Time instance which contains the current simulation time.
Definition: simulator.cc:296
NS_TEST_ASSERT_MSG_EQ
#define NS_TEST_ASSERT_MSG_EQ(actual, limit, msg)
Test that an actual and expected (limit) value are equal and report and abort if not.
Definition: test.h:144
NS_TEST_ASSERT_MSG_EQ_TOL
#define NS_TEST_ASSERT_MSG_EQ_TOL(actual, limit, tol, msg)
Test that actual and expected (limit) values are equal to plus or minus some tolerance and report and...
Definition: test.h:337
ns3::MicroSeconds
Time MicroSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:1360
ns3::NanoSeconds
Time NanoSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:1372
ns3::Seconds
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1336
ns3::MilliSeconds
Time MilliSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:1348
ns3::MakeTraceSourceAccessor
Ptr< const TraceSourceAccessor > MakeTraceSourceAccessor(T a)
Create a TraceSourceAccessor which will control access to the underlying trace source.
Definition: trace-source-accessor.h:209
ns3::WifiPhyRxfailureReason
WifiPhyRxfailureReason
Enumeration of the possible reception failure reasons.
Definition: wifi-phy-common.h:314
ns3::WifiPhyBand
WifiPhyBand
Identifies the PHY band.
Definition: wifi-phy-band.h:33
ns3::WifiChannelListType
WifiChannelListType
Enumeration of the possible channel-list parameter elements defined in Table 8-5 of IEEE 802....
Definition: wifi-phy-common.h:412
ns3::WIFI_STANDARD_80211ax
@ WIFI_STANDARD_80211ax
Definition: wifi-standards.h:47
ns3::WIFI_PREAMBLE_HE_TB
@ WIFI_PREAMBLE_HE_TB
Definition: wifi-phy-common.h:91
ns3::WIFI_PREAMBLE_HE_MU
@ WIFI_PREAMBLE_HE_MU
Definition: wifi-phy-common.h:90
ns3::WIFI_PREAMBLE_HE_SU
@ WIFI_PREAMBLE_HE_SU
Definition: wifi-phy-common.h:88
ns3::WIFI_PHY_BAND_5GHZ
@ WIFI_PHY_BAND_5GHZ
The 5 GHz band.
Definition: wifi-phy-band.h:37
ns3::WIFI_PPDU_TYPE_DL_MU
@ WIFI_PPDU_TYPE_DL_MU
Definition: wifi-phy-common.h:281
ns3::WIFI_MOD_CLASS_HE
@ WIFI_MOD_CLASS_HE
HE (Clause 27)
Definition: wifi-phy-common.h:163
first
Definition: first.py:1
ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.
ns3::WifiConstPsduMap
std::unordered_map< uint16_t, Ptr< const WifiPsdu > > WifiConstPsduMap
Map of const PSDUs indexed by STA-ID.
Definition: he-frame-exchange-manager.h:45
ns3::MakeCallback
Callback< R, Args... > MakeCallback(R(T::*memPtr)(Args...), OBJ objPtr)
Build Callbacks for class method members which take varying numbers of arguments and potentially retu...
Definition: callback.h:707
ns3::WifiSpectrumBand
std::pair< uint32_t, uint32_t > WifiSpectrumBand
typedef for a pair of start and stop sub-band indexes
Definition: wifi-spectrum-value-helper.h:33
ns3::Bands
std::vector< BandInfo > Bands
Container of BandInfo.
Definition: spectrum-model.h:59
ns3::DbmToW
double DbmToW(double dBm)
Convert from dBm to Watts.
Definition: wifi-utils.cc:40
ns3::WIFI_MAC_CTL_TRIGGER
@ WIFI_MAC_CTL_TRIGGER
Definition: wifi-mac-header.h:38
ns3::WIFI_MAC_CTL_BACKRESP
@ WIFI_MAC_CTL_BACKRESP
Definition: wifi-mac-header.h:44
ns3::WIFI_MAC_QOSDATA
@ WIFI_MAC_QOSDATA
Definition: wifi-mac-header.h:80
ns3::GetBlockAckSize
uint32_t GetBlockAckSize(BlockAckType type)
Return the total BlockAck size (including FCS trailer).
Definition: wifi-utils.cc:66
third.mac
mac
Definition: third.py:85
third.wifi
wifi
Definition: third.py:88
third.mobility
mobility
Definition: third.py:96
third.phy
phy
Definition: third.py:82
ns3::BandInfo
The building block of a SpectrumModel.
Definition: spectrum-model.h:52
ns3::BandInfo::fc
double fc
center frequency
Definition: spectrum-model.h:54
ns3::BandInfo::fl
double fl
lower limit of subband
Definition: spectrum-model.h:53
ns3::BandInfo::fh
double fh
upper limit of subband
Definition: spectrum-model.h:55
ns3::RxSignalInfo
RxSignalInfo structure containing info on the received signal.
Definition: phy-entity.h:70
ns3::RxSignalInfo::rssi
double rssi
RSSI in dBm.
Definition: phy-entity.h:72
SU_STA_ID
#define SU_STA_ID
Definition: wifi-mode.h:34
DEFAULT_CHANNEL_WIDTH
static const uint16_t DEFAULT_CHANNEL_WIDTH
Definition: wifi-phy-ofdma-test.cc:64
wifiPhyOfdmaTestSuite
static WifiPhyOfdmaTestSuite wifiPhyOfdmaTestSuite
the test suite
Definition: wifi-phy-ofdma-test.cc:5867
DEFAULT_CHANNEL_NUMBER
static const uint8_t DEFAULT_CHANNEL_NUMBER
Definition: wifi-phy-ofdma-test.cc:61
DEFAULT_WIFI_BAND
static const WifiPhyBand DEFAULT_WIFI_BAND
Definition: wifi-phy-ofdma-test.cc:63
DEFAULT_GUARD_WIDTH
static const uint16_t DEFAULT_GUARD_WIDTH
Definition: wifi-phy-ofdma-test.cc:65
DEFAULT_FREQUENCY
static const uint32_t DEFAULT_FREQUENCY
Definition: wifi-phy-ofdma-test.cc:62
WifiPhyState
WifiPhyState
The state of the PHY layer.
Definition: wifi-phy-state.h:31
CCA_BUSY
@ CCA_BUSY
The PHY layer has sense the medium busy through the CCA mechanism.
Definition: wifi-phy-state.h:39
RX
@ RX
The PHY layer is receiving a packet.
Definition: wifi-phy-state.h:47
IDLE
@ IDLE
The PHY layer is IDLE.
Definition: wifi-phy-state.h:35