A Discrete-Event Network Simulator
API
wifi-phy-reception-test.cc
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2018 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/ampdu-tag.h"
21 #include "ns3/ap-wifi-mac.h"
22 #include "ns3/boolean.h"
23 #include "ns3/config.h"
24 #include "ns3/double.h"
25 #include "ns3/he-phy.h"
26 #include "ns3/he-ppdu.h"
27 #include "ns3/interference-helper.h"
28 #include "ns3/log.h"
29 #include "ns3/mobility-helper.h"
30 #include "ns3/mpdu-aggregator.h"
31 #include "ns3/multi-model-spectrum-channel.h"
32 #include "ns3/nist-error-rate-model.h"
33 #include "ns3/packet-socket-address.h"
34 #include "ns3/packet-socket-client.h"
35 #include "ns3/packet-socket-helper.h"
36 #include "ns3/packet-socket-server.h"
37 #include "ns3/pointer.h"
38 #include "ns3/rng-seed-manager.h"
39 #include "ns3/simple-frame-capture-model.h"
40 #include "ns3/spectrum-wifi-helper.h"
41 #include "ns3/spectrum-wifi-phy.h"
42 #include "ns3/test.h"
43 #include "ns3/threshold-preamble-detection-model.h"
44 #include "ns3/wifi-mac-header.h"
45 #include "ns3/wifi-mpdu.h"
46 #include "ns3/wifi-net-device.h"
47 #include "ns3/wifi-psdu.h"
48 #include "ns3/wifi-spectrum-signal-parameters.h"
49 #include "ns3/wifi-spectrum-value-helper.h"
50 #include "ns3/wifi-utils.h"
51 
52 #include <optional>
53 
54 using namespace ns3;
55 
56 NS_LOG_COMPONENT_DEFINE("WifiPhyReceptionTest");
57 
58 static const uint8_t CHANNEL_NUMBER = 36;
59 static const uint32_t FREQUENCY = 5180; // MHz
60 static const uint16_t CHANNEL_WIDTH = 20; // MHz
61 static const uint16_t GUARD_WIDTH =
62  CHANNEL_WIDTH; // MHz (expanded to channel width to model spectrum mask)
63 
70 class TestThresholdPreambleDetectionWithoutFrameCapture : public TestCase
71 {
72  public:
73  TestThresholdPreambleDetectionWithoutFrameCapture();
74  ~TestThresholdPreambleDetectionWithoutFrameCapture() override;
75 
76  protected:
77  void DoSetup() override;
78  void DoTeardown() override;
79  Ptr<SpectrumWifiPhy> m_phy;
84  void SendPacket(double rxPowerDbm);
92  void RxSuccess(Ptr<const WifiPsdu> psdu,
93  RxSignalInfo rxSignalInfo,
94  WifiTxVector txVector,
95  std::vector<bool> statusPerMpdu);
100  void RxFailure(Ptr<const WifiPsdu> psdu);
101  uint32_t m_countRxSuccess;
102  uint32_t m_countRxFailure;
103 
104  private:
105  void DoRun() override;
106 
111  void CheckPhyState(WifiPhyState expectedState);
116  void DoCheckPhyState(WifiPhyState expectedState);
122  void CheckRxPacketCount(uint32_t expectedSuccessCount, uint32_t expectedFailureCount);
123 
124  uint64_t m_uid;
125 };
126 
127 TestThresholdPreambleDetectionWithoutFrameCapture::
128  TestThresholdPreambleDetectionWithoutFrameCapture()
129  : TestCase("Threshold preamble detection model test when no frame capture model is applied"),
130  m_countRxSuccess(0),
131  m_countRxFailure(0),
132  m_uid(0)
133 {
134 }
135 
136 void
137 TestThresholdPreambleDetectionWithoutFrameCapture::SendPacket(double rxPowerDbm)
138 {
139  WifiTxVector txVector =
140  WifiTxVector(HePhy::GetHeMcs7(), 0, WIFI_PREAMBLE_HE_SU, 800, 1, 1, 0, 20, false);
141 
142  Ptr<Packet> pkt = Create<Packet>(1000);
143  WifiMacHeader hdr;
144 
145  hdr.SetType(WIFI_MAC_QOSDATA);
146  hdr.SetQosTid(0);
147 
148  Ptr<WifiPsdu> psdu = Create<WifiPsdu>(pkt, hdr);
149  Time txDuration = m_phy->CalculateTxDuration(psdu->GetSize(), txVector, m_phy->GetPhyBand());
150 
151  Ptr<WifiPpdu> ppdu =
152  Create<HePpdu>(psdu, txVector, FREQUENCY, txDuration, WIFI_PHY_BAND_5GHZ, m_uid++);
153 
154  Ptr<SpectrumValue> txPowerSpectrum =
155  WifiSpectrumValueHelper::CreateHeOfdmTxPowerSpectralDensity(FREQUENCY,
156  CHANNEL_WIDTH,
157  DbmToW(rxPowerDbm),
158  GUARD_WIDTH);
159 
160  Ptr<WifiSpectrumSignalParameters> txParams = Create<WifiSpectrumSignalParameters>();
161  txParams->psd = txPowerSpectrum;
162  txParams->txPhy = nullptr;
163  txParams->duration = txDuration;
164  txParams->ppdu = ppdu;
165  txParams->txWidth = CHANNEL_WIDTH;
166 
167  m_phy->StartRx(txParams);
168 }
169 
170 void
171 TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState(WifiPhyState expectedState)
172 {
173  // This is needed to make sure PHY state will be checked as the last event if a state change
174  // occurred at the exact same time as the check
175  Simulator::ScheduleNow(&TestThresholdPreambleDetectionWithoutFrameCapture::DoCheckPhyState,
176  this,
177  expectedState);
178 }
179 
180 void
181 TestThresholdPreambleDetectionWithoutFrameCapture::DoCheckPhyState(WifiPhyState expectedState)
182 {
183  WifiPhyState currentState;
184  PointerValue ptr;
185  m_phy->GetAttribute("State", ptr);
186  Ptr<WifiPhyStateHelper> state = DynamicCast<WifiPhyStateHelper>(ptr.Get<WifiPhyStateHelper>());
187  currentState = state->GetState();
188  NS_LOG_FUNCTION(this << currentState);
189  NS_TEST_ASSERT_MSG_EQ(currentState,
190  expectedState,
191  "PHY State " << currentState << " does not match expected state "
192  << expectedState << " at " << Simulator::Now());
193 }
194 
195 void
196 TestThresholdPreambleDetectionWithoutFrameCapture::CheckRxPacketCount(uint32_t expectedSuccessCount,
197  uint32_t expectedFailureCount)
198 {
199  NS_TEST_ASSERT_MSG_EQ(m_countRxSuccess,
200  expectedSuccessCount,
201  "Didn't receive right number of successful packets");
202  NS_TEST_ASSERT_MSG_EQ(m_countRxFailure,
203  expectedFailureCount,
204  "Didn't receive right number of unsuccessful packets");
205 }
206 
207 void
208 TestThresholdPreambleDetectionWithoutFrameCapture::RxSuccess(Ptr<const WifiPsdu> psdu,
209  RxSignalInfo rxSignalInfo,
210  WifiTxVector txVector,
211  std::vector<bool> statusPerMpdu)
212 {
213  NS_LOG_FUNCTION(this << *psdu << rxSignalInfo << txVector);
214  m_countRxSuccess++;
215 }
216 
217 void
218 TestThresholdPreambleDetectionWithoutFrameCapture::RxFailure(Ptr<const WifiPsdu> psdu)
219 {
220  NS_LOG_FUNCTION(this << *psdu);
221  m_countRxFailure++;
222 }
223 
224 TestThresholdPreambleDetectionWithoutFrameCapture::
225  ~TestThresholdPreambleDetectionWithoutFrameCapture()
226 {
227  m_phy = nullptr;
228 }
229 
230 void
231 TestThresholdPreambleDetectionWithoutFrameCapture::DoSetup()
232 {
233  m_phy = CreateObject<SpectrumWifiPhy>();
234  m_phy->ConfigureStandard(WIFI_STANDARD_80211ax);
235  Ptr<InterferenceHelper> interferenceHelper = CreateObject<InterferenceHelper>();
236  m_phy->SetInterferenceHelper(interferenceHelper);
237  Ptr<ErrorRateModel> error = CreateObject<NistErrorRateModel>();
238  m_phy->SetErrorRateModel(error);
239  m_phy->SetOperatingChannel(WifiPhy::ChannelTuple{CHANNEL_NUMBER, 0, WIFI_PHY_BAND_5GHZ, 0});
240  m_phy->SetReceiveOkCallback(
241  MakeCallback(&TestThresholdPreambleDetectionWithoutFrameCapture::RxSuccess, this));
242  m_phy->SetReceiveErrorCallback(
243  MakeCallback(&TestThresholdPreambleDetectionWithoutFrameCapture::RxFailure, this));
244 
245  Ptr<ThresholdPreambleDetectionModel> preambleDetectionModel =
246  CreateObject<ThresholdPreambleDetectionModel>();
247  preambleDetectionModel->SetAttribute("Threshold", DoubleValue(4));
248  preambleDetectionModel->SetAttribute("MinimumRssi", DoubleValue(-82));
249  m_phy->SetPreambleDetectionModel(preambleDetectionModel);
250 }
251 
252 void
253 TestThresholdPreambleDetectionWithoutFrameCapture::DoTeardown()
254 {
255  m_phy->Dispose();
256  m_phy = nullptr;
257 }
258 
259 void
260 TestThresholdPreambleDetectionWithoutFrameCapture::DoRun()
261 {
262  RngSeedManager::SetSeed(1);
263  RngSeedManager::SetRun(1);
264  int64_t streamNumber = 0;
265  m_phy->AssignStreams(streamNumber);
266 
267  // RX power > CCA-ED > CCA-PD
268  double rxPowerDbm = -50;
269 
270  // CASE 1: send one packet and check PHY state:
271  // All reception stages should succeed and PHY state should be RX for the duration of the packet
272  // minus the time to detect the preamble, otherwise it should be IDLE.
273 
274  Simulator::Schedule(Seconds(1.0),
275  &TestThresholdPreambleDetectionWithoutFrameCapture::SendPacket,
276  this,
277  rxPowerDbm);
278  // At 4us, preamble should be successfully detected and STA PHY STATE should move from IDLE to
279  // CCA_BUSY
280  Simulator::Schedule(Seconds(1.0) + NanoSeconds(3999),
281  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState,
282  this,
283  WifiPhyState::IDLE);
284  Simulator::Schedule(Seconds(1.0) + NanoSeconds(4000),
285  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState,
286  this,
287  WifiPhyState::CCA_BUSY);
288  // At 44us, PHY header should be successfully received and STA PHY STATE should move from
289  // CCA_BUSY to RX
290  Simulator::Schedule(Seconds(1.0) + NanoSeconds(43999),
291  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState,
292  this,
293  WifiPhyState::CCA_BUSY);
294  Simulator::Schedule(Seconds(1.0) + NanoSeconds(44000),
295  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState,
296  this,
297  WifiPhyState::RX);
298  // Since it takes 152.8us to transmit the packet, PHY should be back to IDLE at time 152.8us
299  Simulator::Schedule(Seconds(1.0) + NanoSeconds(152799),
300  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState,
301  this,
302  WifiPhyState::RX);
303  Simulator::Schedule(Seconds(1.0) + NanoSeconds(152800),
304  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState,
305  this,
306  WifiPhyState::IDLE);
307  // Packet should have been successfully received
308  Simulator::Schedule(Seconds(1.1),
309  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckRxPacketCount,
310  this,
311  1,
312  0);
313 
314  // CASE 2: send two packets with same power within the 4us window and check PHY state:
315  // PHY preamble detection should fail because SNR is too low (around 0 dB, which is lower than
316  // the threshold of 4 dB), and PHY state should be CCA_BUSY since the total energy is above
317  // CCA-ED (-62 dBm). CCA_BUSY state should last for the duration of the two packets minus the
318  // time to detect the preamble.
319 
320  Simulator::Schedule(Seconds(2.0),
321  &TestThresholdPreambleDetectionWithoutFrameCapture::SendPacket,
322  this,
323  rxPowerDbm);
324  Simulator::Schedule(Seconds(2.0) + MicroSeconds(2.0),
325  &TestThresholdPreambleDetectionWithoutFrameCapture::SendPacket,
326  this,
327  rxPowerDbm);
328  // At 4us, no preamble is successfully detected and STA PHY STATE should move from IDLE to
329  // CCA_BUSY
330  Simulator::Schedule(Seconds(2.0) + NanoSeconds(3999),
331  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState,
332  this,
333  WifiPhyState::IDLE);
334  Simulator::Schedule(Seconds(2.0) + NanoSeconds(4000),
335  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState,
336  this,
337  WifiPhyState::CCA_BUSY);
338  // Since it takes 152.8us to transmit each packet, PHY should be back to IDLE at time 152.8 + 2
339  // = 154.8us
340  Simulator::Schedule(Seconds(2.0) + NanoSeconds(154799),
341  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState,
342  this,
343  WifiPhyState::CCA_BUSY);
344  Simulator::Schedule(Seconds(2.0) + NanoSeconds(154800),
345  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState,
346  this,
347  WifiPhyState::IDLE);
348  // No more packet should have been successfully received, and since preamble detection did not
349  // pass, the packet should not have been counted as a failure
350  Simulator::Schedule(Seconds(2.1),
351  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckRxPacketCount,
352  this,
353  1,
354  0);
355 
356  // CASE 3: send two packets with second one 3 dB weaker within the 4us window and check PHY
357  // state: PHY preamble detection should fail because SNR is too low (around 3 dB, which is lower
358  // than the threshold of 4 dB), and PHY state should be CCA_BUSY since the total energy is above
359  // CCA-ED (-62 dBm). CCA_BUSY state should last for the duration of the two packets minus the
360  // time to detect the preamble.
361 
362  Simulator::Schedule(Seconds(3.0),
363  &TestThresholdPreambleDetectionWithoutFrameCapture::SendPacket,
364  this,
365  rxPowerDbm);
366  Simulator::Schedule(Seconds(3.0) + MicroSeconds(2.0),
367  &TestThresholdPreambleDetectionWithoutFrameCapture::SendPacket,
368  this,
369  rxPowerDbm - 3);
370  // At 4us, no preamble is successfully detected, hence STA PHY STATE should move from IDLE to
371  // CCA_BUSY
372  Simulator::Schedule(Seconds(3.0) + NanoSeconds(3999),
373  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState,
374  this,
375  WifiPhyState::IDLE);
376  Simulator::Schedule(Seconds(3.0) + NanoSeconds(4000),
377  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState,
378  this,
379  WifiPhyState::CCA_BUSY);
380  // Since it takes 152.8us to transmit each packet, PHY should be back to IDLE at time 152.8 + 2
381  // = 154.8us
382  Simulator::Schedule(Seconds(3.0) + NanoSeconds(154799),
383  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState,
384  this,
385  WifiPhyState::CCA_BUSY);
386  Simulator::Schedule(Seconds(3.0) + NanoSeconds(154800),
387  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState,
388  this,
389  WifiPhyState::IDLE);
390  // No more packet should have been successfully received, and since preamble detection did not
391  // pass the packet should not have been counted as a failure
392  Simulator::Schedule(Seconds(3.1),
393  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckRxPacketCount,
394  this,
395  1,
396  0);
397 
398  // CASE 4: send two packets with second one 6 dB weaker within the 4us window and check PHY
399  // state: PHY preamble detection should succeed because SNR is high enough (around 6 dB, which
400  // is higher than the threshold of 4 dB), but payload reception should fail (SNR too low to
401  // decode the modulation).
402 
403  Simulator::Schedule(Seconds(4.0),
404  &TestThresholdPreambleDetectionWithoutFrameCapture::SendPacket,
405  this,
406  rxPowerDbm);
407  Simulator::Schedule(Seconds(4.0) + MicroSeconds(2.0),
408  &TestThresholdPreambleDetectionWithoutFrameCapture::SendPacket,
409  this,
410  rxPowerDbm - 6);
411  // At 4us, preamble should be successfully detected and STA PHY STATE should move from IDLE to
412  // CCA_BUSY
413  Simulator::Schedule(Seconds(4.0) + NanoSeconds(3999),
414  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState,
415  this,
416  WifiPhyState::IDLE);
417  Simulator::Schedule(Seconds(4.0) + NanoSeconds(4000),
418  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState,
419  this,
420  WifiPhyState::CCA_BUSY);
421  // At 44us, PHY header should be successfully received and STA PHY STATE should move from
422  // CCA_BUSY to RX
423  Simulator::Schedule(Seconds(4.0) + NanoSeconds(43999),
424  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState,
425  this,
426  WifiPhyState::CCA_BUSY);
427  Simulator::Schedule(Seconds(4.0) + NanoSeconds(44000),
428  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState,
429  this,
430  WifiPhyState::RX);
431  // Since it takes 152.8us to transmit the packet, PHY should be back to IDLE at time 152.8us.
432  // However, since there is a second packet transmitted with a power above CCA-ED (-62 dBm), PHY
433  // should first be seen as CCA_BUSY for 2us.
434  Simulator::Schedule(Seconds(4.0) + NanoSeconds(152799),
435  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState,
436  this,
437  WifiPhyState::RX);
438  Simulator::Schedule(Seconds(4.0) + NanoSeconds(152800),
439  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState,
440  this,
441  WifiPhyState::CCA_BUSY);
442  Simulator::Schedule(Seconds(4.0) + NanoSeconds(154799),
443  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState,
444  this,
445  WifiPhyState::CCA_BUSY);
446  Simulator::Schedule(Seconds(4.0) + NanoSeconds(154800),
447  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState,
448  this,
449  WifiPhyState::IDLE);
450  // In this case, the first packet should be marked as a failure
451  Simulator::Schedule(Seconds(4.1),
452  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckRxPacketCount,
453  this,
454  1,
455  1);
456 
457  // CASE 5: send two packets with second one 3 dB higher within the 4us window and check PHY
458  // state: PHY preamble detection should fail because SNR is too low (around -3 dB, which is
459  // lower than the threshold of 4 dB), and PHY state should be CCA_BUSY since the total energy is
460  // above CCA-ED (-62 dBm). CCA_BUSY state should last for the duration of the two packets minus
461  // the time to detect the preamble.
462 
463  Simulator::Schedule(Seconds(5.0),
464  &TestThresholdPreambleDetectionWithoutFrameCapture::SendPacket,
465  this,
466  rxPowerDbm);
467  Simulator::Schedule(Seconds(5.0) + MicroSeconds(2.0),
468  &TestThresholdPreambleDetectionWithoutFrameCapture::SendPacket,
469  this,
470  rxPowerDbm + 3);
471  // At 6us (hence 4us after the last signal is received), no preamble is successfully detected,
472  // hence STA PHY STATE should move from IDLE to CCA_BUSY
473  Simulator::Schedule(Seconds(5.0) + NanoSeconds(5999),
474  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState,
475  this,
476  WifiPhyState::IDLE);
477  Simulator::Schedule(Seconds(5.0) + NanoSeconds(6000),
478  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState,
479  this,
480  WifiPhyState::CCA_BUSY);
481  // Since it takes 152.8us to transmit each packet, PHY should be back to IDLE at time 152.8 + 2
482  // = 154.8us
483  Simulator::Schedule(Seconds(5.0) + NanoSeconds(154799),
484  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState,
485  this,
486  WifiPhyState::CCA_BUSY);
487  Simulator::Schedule(Seconds(5.0) + NanoSeconds(154800),
488  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState,
489  this,
490  WifiPhyState::IDLE);
491  // No more packet should have been successfully received, and since preamble detection did not
492  // pass the packet should not have been counted as a failure
493  Simulator::Schedule(Seconds(5.1),
494  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckRxPacketCount,
495  this,
496  1,
497  1);
498 
499  // CCA-PD < RX power < CCA-ED
500  rxPowerDbm = -70;
501 
502  // CASE 6: send one packet and check PHY state:
503  // All reception stages should succeed and PHY state should be RX for the duration of the packet
504  // minus the time to detect the preamble, otherwise it should be IDLE.
505 
506  Simulator::Schedule(Seconds(6.0),
507  &TestThresholdPreambleDetectionWithoutFrameCapture::SendPacket,
508  this,
509  rxPowerDbm);
510  // At 4us, preamble should be successfully detected and STA PHY STATE should move from IDLE to
511  // CCA_BUSY
512  Simulator::Schedule(Seconds(6.0) + NanoSeconds(3999),
513  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState,
514  this,
515  WifiPhyState::IDLE);
516  Simulator::Schedule(Seconds(6.0) + NanoSeconds(4000),
517  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState,
518  this,
519  WifiPhyState::CCA_BUSY);
520  // At 44us, PHY header should be successfully received and STA PHY STATE should move from
521  // CCA_BUSY to RX
522  Simulator::Schedule(Seconds(6.0) + NanoSeconds(43999),
523  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState,
524  this,
525  WifiPhyState::CCA_BUSY);
526  Simulator::Schedule(Seconds(6.0) + NanoSeconds(44000),
527  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState,
528  this,
529  WifiPhyState::RX);
530  // Since it takes 152.8us to transmit the packet, PHY should be back to IDLE at time 152.8us
531  Simulator::Schedule(Seconds(6.0) + NanoSeconds(152799),
532  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState,
533  this,
534  WifiPhyState::RX);
535  Simulator::Schedule(Seconds(6.0) + NanoSeconds(152800),
536  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState,
537  this,
538  WifiPhyState::IDLE);
539  // Packet should have been successfully received
540  Simulator::Schedule(Seconds(6.1),
541  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckRxPacketCount,
542  this,
543  2,
544  1);
545 
546  // CASE 7: send two packets with same power within the 4us window and check PHY state:
547  // PHY preamble detection should fail because SNR is too low (around 0 dB, which is lower than
548  // the threshold of 4 dB), and PHY state should be CCA_BUSY since it should detect the start of
549  // a valid OFDM transmission at a receive level greater than or equal to the minimum modulation
550  // and coding rate sensitivity (–82 dBm for 20 MHz channel spacing).
551 
552  Simulator::Schedule(Seconds(7.0),
553  &TestThresholdPreambleDetectionWithoutFrameCapture::SendPacket,
554  this,
555  rxPowerDbm);
556  Simulator::Schedule(Seconds(7.0) + MicroSeconds(2.0),
557  &TestThresholdPreambleDetectionWithoutFrameCapture::SendPacket,
558  this,
559  rxPowerDbm);
560  // At 4us, STA PHY STATE should stay IDLE
561  Simulator::Schedule(Seconds(7.0) + MicroSeconds(4.0),
562  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState,
563  this,
564  WifiPhyState::CCA_BUSY);
565  // No more packet should have been successfully received, and since preamble detection did not
566  // pass the packet should not have been counted as a failure
567  Simulator::Schedule(Seconds(7.1),
568  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckRxPacketCount,
569  this,
570  2,
571  1);
572 
573  // CASE 8: send two packets with second one 3 dB weaker within the 4us window and check PHY
574  // state: PHY preamble detection should fail PHY preamble detection should fail because SNR is
575  // too low (around 3 dB, which is lower than the threshold of 4 dB), and PHY state should be
576  // CCA_BUSY since it should detect the start of a valid OFDM transmission at a receive level
577  // greater than or equal to the minimum modulation and coding rate sensitivity (–82 dBm for 20
578  // MHz channel spacing).
579 
580  Simulator::Schedule(Seconds(8.0),
581  &TestThresholdPreambleDetectionWithoutFrameCapture::SendPacket,
582  this,
583  rxPowerDbm);
584  Simulator::Schedule(Seconds(8.0) + MicroSeconds(2.0),
585  &TestThresholdPreambleDetectionWithoutFrameCapture::SendPacket,
586  this,
587  rxPowerDbm - 3);
588  // At 4us, STA PHY STATE should stay IDLE
589  Simulator::Schedule(Seconds(8.0) + MicroSeconds(4.0),
590  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState,
591  this,
592  WifiPhyState::CCA_BUSY);
593  // No more packet should have been successfully received, and since preamble detection did not
594  // pass the packet should not have been counted as a failure
595  Simulator::Schedule(Seconds(8.1),
596  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckRxPacketCount,
597  this,
598  2,
599  1);
600 
601  // CASE 9: send two packets with second one 6 dB weaker within the 4us window and check PHY
602  // state: PHY preamble detection should succeed because SNR is high enough (around 6 dB, which
603  // is higher than the threshold of 4 dB), but payload reception should fail (SNR too low to
604  // decode the modulation).
605 
606  Simulator::Schedule(Seconds(9.0),
607  &TestThresholdPreambleDetectionWithoutFrameCapture::SendPacket,
608  this,
609  rxPowerDbm);
610  Simulator::Schedule(Seconds(9.0) + MicroSeconds(2.0),
611  &TestThresholdPreambleDetectionWithoutFrameCapture::SendPacket,
612  this,
613  rxPowerDbm - 6);
614  // At 4us, preamble should be successfully detected and STA PHY STATE should move from IDLE to
615  // CCA_BUSY
616  Simulator::Schedule(Seconds(9.0) + NanoSeconds(3999),
617  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState,
618  this,
619  WifiPhyState::IDLE);
620  Simulator::Schedule(Seconds(9.0) + NanoSeconds(4000),
621  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState,
622  this,
623  WifiPhyState::CCA_BUSY);
624  // At 44us, PHY header should be successfully received and STA PHY STATE should move from
625  // CCA_BUSY to RX
626  Simulator::Schedule(Seconds(9.0) + NanoSeconds(43999),
627  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState,
628  this,
629  WifiPhyState::CCA_BUSY);
630  Simulator::Schedule(Seconds(9.0) + NanoSeconds(44000),
631  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState,
632  this,
633  WifiPhyState::RX);
634  // Since it takes 152.8us to transmit the packet, PHY should be back to CCA_BUSY at time
635  // 152.8us.
636  Simulator::Schedule(Seconds(9.0) + NanoSeconds(152799),
637  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState,
638  this,
639  WifiPhyState::RX);
640  Simulator::Schedule(Seconds(9.0) + NanoSeconds(152800),
641  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState,
642  this,
643  WifiPhyState::CCA_BUSY);
644  // In this case, the first packet should be marked as a failure
645  Simulator::Schedule(Seconds(9.1),
646  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckRxPacketCount,
647  this,
648  2,
649  2);
650 
651  // CASE 10: send two packets with second one 3 dB higher within the 4us window and check PHY
652  // state: PHY preamble detection should fail because SNR is too low (around -3 dB, which is
653  // lower than the threshold of 4 dB), and PHY state should stay IDLE since the total energy is
654  // below CCA-ED (-62 dBm).
655 
656  Simulator::Schedule(Seconds(10.0),
657  &TestThresholdPreambleDetectionWithoutFrameCapture::SendPacket,
658  this,
659  rxPowerDbm);
660  Simulator::Schedule(Seconds(10.0) + MicroSeconds(2.0),
661  &TestThresholdPreambleDetectionWithoutFrameCapture::SendPacket,
662  this,
663  rxPowerDbm + 3);
664  // At 4us, STA PHY STATE should stay IDLE
665  Simulator::Schedule(Seconds(10.0) + MicroSeconds(4.0),
666  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState,
667  this,
668  WifiPhyState::IDLE);
669  // No more packet should have been successfully received, and since preamble detection did not
670  // pass the packet should not have been counted as a failure
671  Simulator::Schedule(Seconds(10.1),
672  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckRxPacketCount,
673  this,
674  2,
675  2);
676 
677  // CASE 11: send one packet with a power slightly above the minimum RSSI needed for the preamble
678  // detection (-82 dBm) and check PHY state: preamble detection should succeed and PHY state
679  // should move to RX.
680 
681  rxPowerDbm = -81;
682 
683  Simulator::Schedule(Seconds(11.0),
684  &TestThresholdPreambleDetectionWithoutFrameCapture::SendPacket,
685  this,
686  rxPowerDbm);
687  // At 4us, preamble should be successfully detected and STA PHY STATE should move from IDLE to
688  // CCA_BUSY
689  Simulator::Schedule(Seconds(11.0) + NanoSeconds(3999),
690  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState,
691  this,
692  WifiPhyState::IDLE);
693  Simulator::Schedule(Seconds(11.0) + NanoSeconds(4000),
694  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState,
695  this,
696  WifiPhyState::CCA_BUSY);
697  // At 44us, PHY header should be successfully received and STA PHY STATE should move from
698  // CCA_BUSY to RX
699  Simulator::Schedule(Seconds(11.0) + NanoSeconds(43999),
700  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState,
701  this,
702  WifiPhyState::CCA_BUSY);
703  Simulator::Schedule(Seconds(11.0) + NanoSeconds(44000),
704  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState,
705  this,
706  WifiPhyState::RX);
707  // Since it takes 152.8us to transmit the packet, PHY should be back to IDLE at time 152.8us.
708  Simulator::Schedule(Seconds(11.0) + NanoSeconds(152799),
709  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState,
710  this,
711  WifiPhyState::RX);
712  Simulator::Schedule(Seconds(11.0) + NanoSeconds(152800),
713  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState,
714  this,
715  WifiPhyState::IDLE);
716 
717  // RX power < CCA-PD < CCA-ED
718  rxPowerDbm = -83;
719 
720  // CASE 12: send one packet with a power slightly below the minimum RSSI needed for the preamble
721  // detection (-82 dBm) and check PHY state: preamble detection should fail and PHY should be
722  // kept in IDLE state.
723 
724  Simulator::Schedule(Seconds(12.0),
725  &TestThresholdPreambleDetectionWithoutFrameCapture::SendPacket,
726  this,
727  rxPowerDbm);
728  // At 4us, STA PHY state should be IDLE
729  Simulator::Schedule(Seconds(12.0) + MicroSeconds(4.0),
730  &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState,
731  this,
732  WifiPhyState::IDLE);
733 
734  Simulator::Run();
735  Simulator::Destroy();
736 }
737 
744 class TestThresholdPreambleDetectionWithFrameCapture : public TestCase
745 {
746  public:
747  TestThresholdPreambleDetectionWithFrameCapture();
748  ~TestThresholdPreambleDetectionWithFrameCapture() override;
749 
750  protected:
751  void DoSetup() override;
752  void DoTeardown() override;
753  Ptr<SpectrumWifiPhy> m_phy;
758  void SendPacket(double rxPowerDbm);
766  void RxSuccess(Ptr<const WifiPsdu> psdu,
767  RxSignalInfo rxSignalInfo,
768  WifiTxVector txVector,
769  std::vector<bool> statusPerMpdu);
774  void RxFailure(Ptr<const WifiPsdu> psdu);
775  uint32_t m_countRxSuccess;
776  uint32_t m_countRxFailure;
777 
778  private:
779  void DoRun() override;
780 
785  void CheckPhyState(WifiPhyState expectedState);
790  void DoCheckPhyState(WifiPhyState expectedState);
796  void CheckRxPacketCount(uint32_t expectedSuccessCount, uint32_t expectedFailureCount);
797 
798  uint64_t m_uid;
799 };
800 
801 TestThresholdPreambleDetectionWithFrameCapture::TestThresholdPreambleDetectionWithFrameCapture()
802  : TestCase(
803  "Threshold preamble detection model test when simple frame capture model is applied"),
804  m_countRxSuccess(0),
805  m_countRxFailure(0),
806  m_uid(0)
807 {
808 }
809 
810 void
811 TestThresholdPreambleDetectionWithFrameCapture::SendPacket(double rxPowerDbm)
812 {
813  WifiTxVector txVector =
814  WifiTxVector(HePhy::GetHeMcs7(), 0, WIFI_PREAMBLE_HE_SU, 800, 1, 1, 0, 20, false);
815 
816  Ptr<Packet> pkt = Create<Packet>(1000);
817  WifiMacHeader hdr;
818 
819  hdr.SetType(WIFI_MAC_QOSDATA);
820  hdr.SetQosTid(0);
821 
822  Ptr<WifiPsdu> psdu = Create<WifiPsdu>(pkt, hdr);
823  Time txDuration = m_phy->CalculateTxDuration(psdu->GetSize(), txVector, m_phy->GetPhyBand());
824 
825  Ptr<WifiPpdu> ppdu =
826  Create<HePpdu>(psdu, txVector, FREQUENCY, txDuration, WIFI_PHY_BAND_5GHZ, m_uid++);
827 
828  Ptr<SpectrumValue> txPowerSpectrum =
829  WifiSpectrumValueHelper::CreateHeOfdmTxPowerSpectralDensity(FREQUENCY,
830  CHANNEL_WIDTH,
831  DbmToW(rxPowerDbm),
832  GUARD_WIDTH);
833 
834  Ptr<WifiSpectrumSignalParameters> txParams = Create<WifiSpectrumSignalParameters>();
835  txParams->psd = txPowerSpectrum;
836  txParams->txPhy = nullptr;
837  txParams->duration = txDuration;
838  txParams->ppdu = ppdu;
839 
840  m_phy->StartRx(txParams);
841 }
842 
843 void
844 TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState(WifiPhyState expectedState)
845 {
846  // This is needed to make sure PHY state will be checked as the last event if a state change
847  // occurred at the exact same time as the check
848  Simulator::ScheduleNow(&TestThresholdPreambleDetectionWithFrameCapture::DoCheckPhyState,
849  this,
850  expectedState);
851 }
852 
853 void
854 TestThresholdPreambleDetectionWithFrameCapture::DoCheckPhyState(WifiPhyState expectedState)
855 {
856  WifiPhyState currentState;
857  PointerValue ptr;
858  m_phy->GetAttribute("State", ptr);
859  Ptr<WifiPhyStateHelper> state = DynamicCast<WifiPhyStateHelper>(ptr.Get<WifiPhyStateHelper>());
860  currentState = state->GetState();
861  NS_LOG_FUNCTION(this << currentState);
862  NS_TEST_ASSERT_MSG_EQ(currentState,
863  expectedState,
864  "PHY State " << currentState << " does not match expected state "
865  << expectedState << " at " << Simulator::Now());
866 }
867 
868 void
869 TestThresholdPreambleDetectionWithFrameCapture::CheckRxPacketCount(uint32_t expectedSuccessCount,
870  uint32_t expectedFailureCount)
871 {
872  NS_TEST_ASSERT_MSG_EQ(m_countRxSuccess,
873  expectedSuccessCount,
874  "Didn't receive right number of successful packets");
875  NS_TEST_ASSERT_MSG_EQ(m_countRxFailure,
876  expectedFailureCount,
877  "Didn't receive right number of unsuccessful packets");
878 }
879 
880 void
881 TestThresholdPreambleDetectionWithFrameCapture::RxSuccess(Ptr<const WifiPsdu> psdu,
882  RxSignalInfo rxSignalInfo,
883  WifiTxVector txVector,
884  std::vector<bool> statusPerMpdu)
885 {
886  NS_LOG_FUNCTION(this << *psdu << txVector);
887  m_countRxSuccess++;
888 }
889 
890 void
891 TestThresholdPreambleDetectionWithFrameCapture::RxFailure(Ptr<const WifiPsdu> psdu)
892 {
893  NS_LOG_FUNCTION(this << *psdu);
894  m_countRxFailure++;
895 }
896 
897 TestThresholdPreambleDetectionWithFrameCapture::~TestThresholdPreambleDetectionWithFrameCapture()
898 {
899  m_phy = nullptr;
900 }
901 
902 void
903 TestThresholdPreambleDetectionWithFrameCapture::DoSetup()
904 {
905  m_phy = CreateObject<SpectrumWifiPhy>();
906  m_phy->ConfigureStandard(WIFI_STANDARD_80211ax);
907  Ptr<InterferenceHelper> interferenceHelper = CreateObject<InterferenceHelper>();
908  m_phy->SetInterferenceHelper(interferenceHelper);
909  Ptr<ErrorRateModel> error = CreateObject<NistErrorRateModel>();
910  m_phy->SetErrorRateModel(error);
911  m_phy->SetOperatingChannel(WifiPhy::ChannelTuple{CHANNEL_NUMBER, 0, WIFI_PHY_BAND_5GHZ, 0});
912  m_phy->SetReceiveOkCallback(
913  MakeCallback(&TestThresholdPreambleDetectionWithFrameCapture::RxSuccess, this));
914  m_phy->SetReceiveErrorCallback(
915  MakeCallback(&TestThresholdPreambleDetectionWithFrameCapture::RxFailure, this));
916 
917  Ptr<ThresholdPreambleDetectionModel> preambleDetectionModel =
918  CreateObject<ThresholdPreambleDetectionModel>();
919  preambleDetectionModel->SetAttribute("Threshold", DoubleValue(4));
920  preambleDetectionModel->SetAttribute("MinimumRssi", DoubleValue(-82));
921  m_phy->SetPreambleDetectionModel(preambleDetectionModel);
922 
923  Ptr<SimpleFrameCaptureModel> frameCaptureModel = CreateObject<SimpleFrameCaptureModel>();
924  frameCaptureModel->SetAttribute("Margin", DoubleValue(5));
925  frameCaptureModel->SetAttribute("CaptureWindow", TimeValue(MicroSeconds(16)));
926  m_phy->SetFrameCaptureModel(frameCaptureModel);
927 }
928 
929 void
930 TestThresholdPreambleDetectionWithFrameCapture::DoTeardown()
931 {
932  m_phy->Dispose();
933  m_phy = nullptr;
934 }
935 
936 void
937 TestThresholdPreambleDetectionWithFrameCapture::DoRun()
938 {
939  RngSeedManager::SetSeed(1);
940  RngSeedManager::SetRun(1);
941  int64_t streamNumber = 1;
942  m_phy->AssignStreams(streamNumber);
943 
944  // RX power > CCA-ED > CCA-PD
945  double rxPowerDbm = -50;
946 
947  // CASE 1: send one packet and check PHY state:
948  // All reception stages should succeed and PHY state should be RX for the duration of the packet
949  // minus the time to detect the preamble, otherwise it should be IDLE.
950 
951  Simulator::Schedule(Seconds(1.0),
952  &TestThresholdPreambleDetectionWithFrameCapture::SendPacket,
953  this,
954  rxPowerDbm);
955  // At 4us, preamble should be successfully detected and STA PHY STATE should move from IDLE to
956  // CCA_BUSY
957  Simulator::Schedule(Seconds(1.0) + NanoSeconds(3999),
958  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
959  this,
960  WifiPhyState::IDLE);
961  Simulator::Schedule(Seconds(1.0) + NanoSeconds(4000),
962  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
963  this,
964  WifiPhyState::CCA_BUSY);
965  // At 44us, PHY header should be successfully received and STA PHY STATE should move from
966  // CCA_BUSY to RX
967  Simulator::Schedule(Seconds(1.0) + NanoSeconds(43999),
968  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
969  this,
970  WifiPhyState::CCA_BUSY);
971  Simulator::Schedule(Seconds(1.0) + NanoSeconds(44000),
972  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
973  this,
974  WifiPhyState::RX);
975  // Since it takes 152.8us to transmit the packet, PHY should be back to IDLE at time 152.8us
976  Simulator::Schedule(Seconds(1.0) + NanoSeconds(152799),
977  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
978  this,
979  WifiPhyState::RX);
980  Simulator::Schedule(Seconds(1.0) + NanoSeconds(152800),
981  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
982  this,
983  WifiPhyState::IDLE);
984  // Packet should have been successfully received
985  Simulator::Schedule(Seconds(1.1),
986  &TestThresholdPreambleDetectionWithFrameCapture::CheckRxPacketCount,
987  this,
988  1,
989  0);
990 
991  // CASE 2: send two packets with same power within the 4us window and check PHY state:
992  // PHY preamble detection should fail because SNR is too low (around 0 dB, which is lower than
993  // the threshold of 4 dB), and PHY state should be CCA_BUSY since the total energy is above
994  // CCA-ED (-62 dBm). CCA_BUSY state should last for the duration of the two packets minus the
995  // time to detect the preamble.
996 
997  Simulator::Schedule(Seconds(2.0),
998  &TestThresholdPreambleDetectionWithFrameCapture::SendPacket,
999  this,
1000  rxPowerDbm);
1001  Simulator::Schedule(Seconds(2.0) + MicroSeconds(2.0),
1002  &TestThresholdPreambleDetectionWithFrameCapture::SendPacket,
1003  this,
1004  rxPowerDbm);
1005  // At 4us, no preamble is successfully detected, hence STA PHY STATE should move from IDLE to
1006  // CCA_BUSY
1007  Simulator::Schedule(Seconds(2.0) + NanoSeconds(3999),
1008  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1009  this,
1010  WifiPhyState::IDLE);
1011  Simulator::Schedule(Seconds(2.0) + NanoSeconds(4000),
1012  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1013  this,
1014  WifiPhyState::CCA_BUSY);
1015  // Since it takes 152.8us to transmit each packet, PHY should be back to IDLE at time 152.8 + 2
1016  // = 154.8us
1017  Simulator::Schedule(Seconds(2.0) + NanoSeconds(154799),
1018  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1019  this,
1020  WifiPhyState::CCA_BUSY);
1021  Simulator::Schedule(Seconds(2.0) + NanoSeconds(154800),
1022  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1023  this,
1024  WifiPhyState::IDLE);
1025  // No more packet should have been successfully received, and since preamble detection did not
1026  // pass the packet should not have been counted as a failure
1027  Simulator::Schedule(Seconds(2.1),
1028  &TestThresholdPreambleDetectionWithFrameCapture::CheckRxPacketCount,
1029  this,
1030  1,
1031  0);
1032 
1033  // CASE 3: send two packets with second one 3 dB weaker within the 4us window and check PHY
1034  // state: PHY preamble detection should fail because SNR is too low (around 3 dB, which is lower
1035  // than the threshold of 4 dB), and PHY state should be CCA_BUSY since the total energy is above
1036  // CCA-ED (-62 dBm). CCA_BUSY state should last for the duration of the two packets minus the
1037  // time to detect the preamble.
1038 
1039  Simulator::Schedule(Seconds(3.0),
1040  &TestThresholdPreambleDetectionWithFrameCapture::SendPacket,
1041  this,
1042  rxPowerDbm);
1043  Simulator::Schedule(Seconds(3.0) + MicroSeconds(2.0),
1044  &TestThresholdPreambleDetectionWithFrameCapture::SendPacket,
1045  this,
1046  rxPowerDbm - 3);
1047  // At 4us, no preamble is successfully detected, hence STA PHY STATE should move from IDLE to
1048  // CCA_BUSY
1049  Simulator::Schedule(Seconds(3.0) + NanoSeconds(3999),
1050  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1051  this,
1052  WifiPhyState::IDLE);
1053  Simulator::Schedule(Seconds(3.0) + NanoSeconds(4000),
1054  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1055  this,
1056  WifiPhyState::CCA_BUSY);
1057  // Since it takes 152.8us to transmit each packet, PHY should be back to IDLE at time 152.8 + 2
1058  // = 154.8us
1059  Simulator::Schedule(Seconds(3.0) + NanoSeconds(154799),
1060  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1061  this,
1062  WifiPhyState::CCA_BUSY);
1063  Simulator::Schedule(Seconds(3.0) + NanoSeconds(154800),
1064  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1065  this,
1066  WifiPhyState::IDLE);
1067  // No more packet should have been successfully received, and since preamble detection did not
1068  // pass the packet should not have been counted as a failure
1069  Simulator::Schedule(Seconds(3.1),
1070  &TestThresholdPreambleDetectionWithFrameCapture::CheckRxPacketCount,
1071  this,
1072  1,
1073  0);
1074 
1075  // CASE 4: send two packets with second one 6 dB weaker within the 4us window and check PHY
1076  // state: PHY preamble detection should succeed because SNR is high enough (around 6 dB, which
1077  // is higher than the threshold of 4 dB), but payload reception should fail (SNR too low to
1078  // decode the modulation).
1079 
1080  Simulator::Schedule(Seconds(4.0),
1081  &TestThresholdPreambleDetectionWithFrameCapture::SendPacket,
1082  this,
1083  rxPowerDbm);
1084  Simulator::Schedule(Seconds(4.0) + MicroSeconds(2.0),
1085  &TestThresholdPreambleDetectionWithFrameCapture::SendPacket,
1086  this,
1087  rxPowerDbm - 6);
1088  // At 4us, preamble should be successfully detected and STA PHY STATE should move from IDLE to
1089  // CCA_BUSY
1090  Simulator::Schedule(Seconds(4.0) + NanoSeconds(3999),
1091  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1092  this,
1093  WifiPhyState::IDLE);
1094  Simulator::Schedule(Seconds(4.0) + NanoSeconds(4000),
1095  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1096  this,
1097  WifiPhyState::CCA_BUSY);
1098  // At 44us, PHY header should be successfully received and STA PHY STATE should move from
1099  // CCA_BUSY to RX
1100  Simulator::Schedule(Seconds(4.0) + NanoSeconds(43999),
1101  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1102  this,
1103  WifiPhyState::CCA_BUSY);
1104  Simulator::Schedule(Seconds(4.0) + NanoSeconds(44000),
1105  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1106  this,
1107  WifiPhyState::RX);
1108  // Since it takes 152.8us to transmit the packet, PHY should be back to IDLE at time 152.8us.
1109  // However, since there is a second packet transmitted with a power above CCA-ED (-62 dBm), PHY
1110  // should first be seen as CCA_BUSY for 2us.
1111  Simulator::Schedule(Seconds(4.0) + NanoSeconds(152799),
1112  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1113  this,
1114  WifiPhyState::RX);
1115  Simulator::Schedule(Seconds(4.0) + NanoSeconds(152800),
1116  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1117  this,
1118  WifiPhyState::CCA_BUSY);
1119  Simulator::Schedule(Seconds(4.0) + NanoSeconds(154799),
1120  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1121  this,
1122  WifiPhyState::CCA_BUSY);
1123  Simulator::Schedule(Seconds(4.0) + NanoSeconds(154800),
1124  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1125  this,
1126  WifiPhyState::IDLE);
1127  // In this case, the first packet should be marked as a failure
1128  Simulator::Schedule(Seconds(4.1),
1129  &TestThresholdPreambleDetectionWithFrameCapture::CheckRxPacketCount,
1130  this,
1131  1,
1132  1);
1133 
1134  // CASE 5: send two packets with second one 3 dB higher within the 4us window and check PHY
1135  // state: PHY preamble detection should switch because a higher packet is received within the
1136  // 4us window, but preamble detection should fail because SNR is too low (around 3 dB, which is
1137  // lower than the threshold of 4 dB), PHY state should be CCA_BUSY since the total energy is
1138  // above CCA-ED (-62 dBm).
1139 
1140  Simulator::Schedule(Seconds(5.0),
1141  &TestThresholdPreambleDetectionWithFrameCapture::SendPacket,
1142  this,
1143  rxPowerDbm);
1144  Simulator::Schedule(Seconds(5.0) + MicroSeconds(2.0),
1145  &TestThresholdPreambleDetectionWithFrameCapture::SendPacket,
1146  this,
1147  rxPowerDbm + 3);
1148  // At 4us, STA PHY STATE should stay IDLE
1149  Simulator::Schedule(Seconds(5.0) + MicroSeconds(4.0),
1150  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1151  this,
1152  WifiPhyState::IDLE);
1153  // At 6us, STA PHY STATE should move from IDLE to CCA_BUSY
1154  Simulator::Schedule(Seconds(5.0) + NanoSeconds(5999),
1155  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1156  this,
1157  WifiPhyState::IDLE);
1158  Simulator::Schedule(Seconds(5.0) + NanoSeconds(6000),
1159  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1160  this,
1161  WifiPhyState::CCA_BUSY);
1162  // Since it takes 152.8us to transmit each packet, PHY should be back to IDLE at time 152.8 + 2
1163  // = 154.8us
1164  Simulator::Schedule(Seconds(5.0) + NanoSeconds(154799),
1165  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1166  this,
1167  WifiPhyState::CCA_BUSY);
1168  Simulator::Schedule(Seconds(5.0) + NanoSeconds(154800),
1169  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1170  this,
1171  WifiPhyState::IDLE);
1172  // No more packet should have been successfully received, and since preamble detection did not
1173  // pass the packet should not have been counted as a failure
1174  Simulator::Schedule(Seconds(5.1),
1175  &TestThresholdPreambleDetectionWithFrameCapture::CheckRxPacketCount,
1176  this,
1177  1,
1178  1);
1179 
1180  // CASE 6: send two packets with second one 6 dB higher within the 4us window and check PHY
1181  // state: PHY preamble detection should switch because a higher packet is received within the
1182  // 4us window, and preamble detection should succeed because SNR is high enough (around 6 dB,
1183  // which is higher than the threshold of 4 dB), Payload reception should fail (SNR too low to
1184  // decode the modulation).
1185 
1186  Simulator::Schedule(Seconds(6.0),
1187  &TestThresholdPreambleDetectionWithFrameCapture::SendPacket,
1188  this,
1189  rxPowerDbm);
1190  Simulator::Schedule(Seconds(6.0) + MicroSeconds(2.0),
1191  &TestThresholdPreambleDetectionWithFrameCapture::SendPacket,
1192  this,
1193  rxPowerDbm + 6);
1194  // At 4us, STA PHY STATE should stay IDLE
1195  Simulator::Schedule(Seconds(6.0) + MicroSeconds(4.0),
1196  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1197  this,
1198  WifiPhyState::IDLE);
1199  // At 6us, preamble should be successfully detected and STA PHY STATE should move from IDLE to
1200  // CCA_BUSY
1201  Simulator::Schedule(Seconds(6.0) + NanoSeconds(5999),
1202  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1203  this,
1204  WifiPhyState::IDLE);
1205  Simulator::Schedule(Seconds(6.0) + NanoSeconds(6000),
1206  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1207  this,
1208  WifiPhyState::CCA_BUSY);
1209  // At 46us, PHY header should be successfully received and STA PHY STATE should move from
1210  // CCA_BUSY to RX
1211  Simulator::Schedule(Seconds(6.0) + NanoSeconds(45999),
1212  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1213  this,
1214  WifiPhyState::CCA_BUSY);
1215  Simulator::Schedule(Seconds(6.0) + NanoSeconds(46000),
1216  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1217  this,
1218  WifiPhyState::RX);
1219  // Since it takes 152.8us to transmit each packet, PHY should be back to IDLE at time 152.8 + 2
1220  // = 154.8us
1221  Simulator::Schedule(Seconds(6.0) + NanoSeconds(154799),
1222  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1223  this,
1224  WifiPhyState::RX);
1225  Simulator::Schedule(Seconds(6.0) + NanoSeconds(154800),
1226  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1227  this,
1228  WifiPhyState::IDLE);
1229  // In this case, the second packet should be marked as a failure
1230  Simulator::Schedule(Seconds(6.1),
1231  &TestThresholdPreambleDetectionWithFrameCapture::CheckRxPacketCount,
1232  this,
1233  1,
1234  2);
1235 
1236  // CASE 7: send two packets with same power at the exact same time and check PHY state:
1237  // PHY preamble detection should fail because SNR is too low (around 0 dB, which is lower than
1238  // the threshold of 4 dB), and PHY state should be CCA_BUSY since the total energy is above
1239  // CCA-ED (-62 dBm). CCA_BUSY state should last for the duration of the two packets minus the
1240  // time to detect the preamble.
1241 
1242  Simulator::Schedule(Seconds(7.0),
1243  &TestThresholdPreambleDetectionWithFrameCapture::SendPacket,
1244  this,
1245  rxPowerDbm);
1246  Simulator::Schedule(Seconds(7.0),
1247  &TestThresholdPreambleDetectionWithFrameCapture::SendPacket,
1248  this,
1249  rxPowerDbm);
1250  // At 4us, no preamble is successfully detected, hence STA PHY STATE should move from IDLE to
1251  // CCA_BUSY
1252  Simulator::Schedule(Seconds(7.0) + NanoSeconds(3999),
1253  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1254  this,
1255  WifiPhyState::IDLE);
1256  Simulator::Schedule(Seconds(7.0) + NanoSeconds(4000),
1257  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1258  this,
1259  WifiPhyState::CCA_BUSY);
1260  // Since it takes 152.8us to transmit each packet, PHY should be back to IDLE at time 152.8 + 2
1261  // = 154.8us
1262  Simulator::Schedule(Seconds(7.0) + NanoSeconds(152799),
1263  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1264  this,
1265  WifiPhyState::CCA_BUSY);
1266  Simulator::Schedule(Seconds(7.0) + NanoSeconds(152800),
1267  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1268  this,
1269  WifiPhyState::IDLE);
1270  // No more packet should have been successfully received, and since preamble detection did not
1271  // pass the packet should not have been counted as a failure
1272  Simulator::Schedule(Seconds(7.1),
1273  &TestThresholdPreambleDetectionWithFrameCapture::CheckRxPacketCount,
1274  this,
1275  1,
1276  2);
1277 
1278  // CASE 8: send two packets with second one 3 dB weaker at the exact same time and check PHY
1279  // state: PHY preamble detection should fail because SNR is too low (around 3 dB, which is lower
1280  // than the threshold of 4 dB), and PHY state should be CCA_BUSY since the total energy is above
1281  // CCA-ED (-62 dBm). CCA_BUSY state should last for the duration of the two packets minus the
1282  // time to detect the preamble.
1283 
1284  Simulator::Schedule(Seconds(8.0),
1285  &TestThresholdPreambleDetectionWithFrameCapture::SendPacket,
1286  this,
1287  rxPowerDbm);
1288  Simulator::Schedule(Seconds(8.0),
1289  &TestThresholdPreambleDetectionWithFrameCapture::SendPacket,
1290  this,
1291  rxPowerDbm - 3);
1292  // At 4us, no preamble is successfully detected, hence STA PHY STATE should move from IDLE to
1293  // CCA_BUSY
1294  Simulator::Schedule(Seconds(8.0) + NanoSeconds(3999),
1295  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1296  this,
1297  WifiPhyState::IDLE);
1298  Simulator::Schedule(Seconds(8.0) + NanoSeconds(4000),
1299  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1300  this,
1301  WifiPhyState::CCA_BUSY);
1302  // Since it takes 152.8us to transmit each packet, PHY should be back to IDLE at time 152.8 us
1303  Simulator::Schedule(Seconds(8.0) + NanoSeconds(152799),
1304  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1305  this,
1306  WifiPhyState::CCA_BUSY);
1307  Simulator::Schedule(Seconds(8.0) + NanoSeconds(152800),
1308  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1309  this,
1310  WifiPhyState::IDLE);
1311  // No more packet should have been successfully received, and since preamble detection did not
1312  // pass the packet should not have been counted as a failure
1313  Simulator::Schedule(Seconds(8.1),
1314  &TestThresholdPreambleDetectionWithFrameCapture::CheckRxPacketCount,
1315  this,
1316  1,
1317  2);
1318 
1319  // CASE 9: send two packets with second one 6 dB weaker at the exact same time and check PHY
1320  // state: PHY preamble detection should succeed because SNR is high enough (around 6 dB, which
1321  // is higher than the threshold of 4 dB), but payload reception should fail (SNR too low to
1322  // decode the modulation).
1323 
1324  Simulator::Schedule(Seconds(9.0),
1325  &TestThresholdPreambleDetectionWithFrameCapture::SendPacket,
1326  this,
1327  rxPowerDbm);
1328  Simulator::Schedule(Seconds(9.0),
1329  &TestThresholdPreambleDetectionWithFrameCapture::SendPacket,
1330  this,
1331  rxPowerDbm - 6);
1332  // At 4us, preamble should be successfully detected and STA PHY STATE should move from IDLE to
1333  // CCA_BUSY
1334  Simulator::Schedule(Seconds(9.0) + NanoSeconds(3999),
1335  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1336  this,
1337  WifiPhyState::IDLE);
1338  Simulator::Schedule(Seconds(9.0) + NanoSeconds(4000),
1339  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1340  this,
1341  WifiPhyState::CCA_BUSY);
1342  // At 44us, PHY header should be successfully received and STA PHY STATE should move from
1343  // CCA_BUSY to RX
1344  Simulator::Schedule(Seconds(9.0) + NanoSeconds(43999),
1345  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1346  this,
1347  WifiPhyState::CCA_BUSY);
1348  Simulator::Schedule(Seconds(9.0) + NanoSeconds(44000),
1349  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1350  this,
1351  WifiPhyState::RX);
1352  // Since it takes 152.8us to transmit the packets, PHY should be back to IDLE at time 152.8us.
1353  Simulator::Schedule(Seconds(9.0) + NanoSeconds(152799),
1354  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1355  this,
1356  WifiPhyState::RX);
1357  Simulator::Schedule(Seconds(9.0) + NanoSeconds(152800),
1358  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1359  this,
1360  WifiPhyState::IDLE);
1361  // In this case, the first packet should be marked as a failure
1362  Simulator::Schedule(Seconds(9.1),
1363  &TestThresholdPreambleDetectionWithFrameCapture::CheckRxPacketCount,
1364  this,
1365  1,
1366  3);
1367 
1368  // CASE 10: send two packets with second one 3 dB higher at the exact same time and check PHY
1369  // state: PHY preamble detection should switch because a higher packet is received within the
1370  // 4us window, but preamble detection should fail because SNR is too low (around 3 dB, which is
1371  // lower than the threshold of 4 dB), PHY state should be CCA_BUSY since the total energy is
1372  // above CCA-ED (-62 dBm).
1373 
1374  Simulator::Schedule(Seconds(10.0),
1375  &TestThresholdPreambleDetectionWithFrameCapture::SendPacket,
1376  this,
1377  rxPowerDbm);
1378  Simulator::Schedule(Seconds(10.0),
1379  &TestThresholdPreambleDetectionWithFrameCapture::SendPacket,
1380  this,
1381  rxPowerDbm + 3);
1382  // At 4us, no preamble is successfully detected, hence STA PHY STATE should move from IDLE to
1383  // CCA_BUSY
1384  Simulator::Schedule(Seconds(10.0) + NanoSeconds(3999),
1385  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1386  this,
1387  WifiPhyState::IDLE);
1388  Simulator::Schedule(Seconds(10.0) + NanoSeconds(4000),
1389  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1390  this,
1391  WifiPhyState::CCA_BUSY);
1392  // Since it takes 152.8us to transmit each packet, PHY should be back to IDLE at time 152.8 us
1393  Simulator::Schedule(Seconds(10.0) + NanoSeconds(152799),
1394  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1395  this,
1396  WifiPhyState::CCA_BUSY);
1397  Simulator::Schedule(Seconds(10.0) + NanoSeconds(152800),
1398  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1399  this,
1400  WifiPhyState::IDLE);
1401  // No more packet should have been successfully received, and since preamble detection did not
1402  // pass the packet should not have been counted as a failure
1403  Simulator::Schedule(Seconds(10.1),
1404  &TestThresholdPreambleDetectionWithFrameCapture::CheckRxPacketCount,
1405  this,
1406  1,
1407  3);
1408 
1409  // CASE 11: send two packets with second one 6 dB higher at the exact same time and check PHY
1410  // state: PHY preamble detection should switch because a higher packet is received within the
1411  // 4us window, and preamble detection should succeed because SNR is high enough (around 6 dB,
1412  // which is higher than the threshold of 4 dB), Payload reception should fail (SNR too low to
1413  // decode the modulation).
1414 
1415  Simulator::Schedule(Seconds(11.0),
1416  &TestThresholdPreambleDetectionWithFrameCapture::SendPacket,
1417  this,
1418  rxPowerDbm);
1419  Simulator::Schedule(Seconds(11.0),
1420  &TestThresholdPreambleDetectionWithFrameCapture::SendPacket,
1421  this,
1422  rxPowerDbm + 6);
1423  // At 4us, preamble should be successfully detected and STA PHY STATE should move from IDLE to
1424  // CCA_BUSY
1425  Simulator::Schedule(Seconds(11.0) + NanoSeconds(3999),
1426  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1427  this,
1428  WifiPhyState::IDLE);
1429  Simulator::Schedule(Seconds(11.0) + NanoSeconds(4000),
1430  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1431  this,
1432  WifiPhyState::CCA_BUSY);
1433  // At 44us, PHY header should be successfully received and STA PHY STATE should move from
1434  // CCA_BUSY to RX
1435  Simulator::Schedule(Seconds(11.0) + NanoSeconds(43999),
1436  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1437  this,
1438  WifiPhyState::CCA_BUSY);
1439  Simulator::Schedule(Seconds(11.0) + NanoSeconds(44000),
1440  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1441  this,
1442  WifiPhyState::RX);
1443  // Since it takes 152.8us to transmit each packet, PHY should be back to IDLE at time 152.8 us
1444  Simulator::Schedule(Seconds(11.0) + NanoSeconds(152799),
1445  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1446  this,
1447  WifiPhyState::RX);
1448  Simulator::Schedule(Seconds(11.0) + NanoSeconds(152800),
1449  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1450  this,
1451  WifiPhyState::IDLE);
1452  // In this case, the second packet should be marked as a failure
1453  Simulator::Schedule(Seconds(11.1),
1454  &TestThresholdPreambleDetectionWithFrameCapture::CheckRxPacketCount,
1455  this,
1456  1,
1457  4);
1458 
1459  // CCA-PD < RX power < CCA-ED
1460  rxPowerDbm = -70;
1461 
1462  // CASE 12: send one packet and check PHY state:
1463  // All reception stages should succeed and PHY state should be RX for the duration of the packet
1464  // minus the time to detect the preamble, otherwise it should be IDLE.
1465 
1466  Simulator::Schedule(Seconds(12.0),
1467  &TestThresholdPreambleDetectionWithFrameCapture::SendPacket,
1468  this,
1469  rxPowerDbm);
1470  // At 4us, preamble should be successfully detected and STA PHY STATE should move from IDLE to
1471  // CCA_BUSY
1472  Simulator::Schedule(Seconds(12.0) + NanoSeconds(3999),
1473  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1474  this,
1475  WifiPhyState::IDLE);
1476  Simulator::Schedule(Seconds(12.0) + NanoSeconds(4000),
1477  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1478  this,
1479  WifiPhyState::CCA_BUSY);
1480  // At 44us, PHY header should be successfully received and STA PHY STATE should move from
1481  // CCA_BUSY to RX
1482  Simulator::Schedule(Seconds(12.0) + NanoSeconds(43999),
1483  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1484  this,
1485  WifiPhyState::CCA_BUSY);
1486  Simulator::Schedule(Seconds(12.0) + NanoSeconds(44000),
1487  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1488  this,
1489  WifiPhyState::RX);
1490  // Since it takes 152.8us to transmit the packet, PHY should be back to IDLE at time 152.8us
1491  Simulator::Schedule(Seconds(12.0) + NanoSeconds(152799),
1492  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1493  this,
1494  WifiPhyState::RX);
1495  Simulator::Schedule(Seconds(12.0) + NanoSeconds(152800),
1496  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1497  this,
1498  WifiPhyState::IDLE);
1499  // Packet should have been successfully received
1500  Simulator::Schedule(Seconds(12.1),
1501  &TestThresholdPreambleDetectionWithFrameCapture::CheckRxPacketCount,
1502  this,
1503  2,
1504  4);
1505 
1506  // CASE 13: send two packets with same power within the 4us window and check PHY state:
1507  // PHY preamble detection should fail because SNR is too low (around 0 dB, which is lower than
1508  // the threshold of 4 dB), and PHY state should be CCA_BUSY since it should detect the start of
1509  // a valid OFDM transmission at a receive level greater than or equal to the minimum modulation
1510  // and coding rate sensitivity (–82 dBm for 20 MHz channel spacing).
1511 
1512  Simulator::Schedule(Seconds(13.0),
1513  &TestThresholdPreambleDetectionWithFrameCapture::SendPacket,
1514  this,
1515  rxPowerDbm);
1516  Simulator::Schedule(Seconds(13.0) + MicroSeconds(2.0),
1517  &TestThresholdPreambleDetectionWithFrameCapture::SendPacket,
1518  this,
1519  rxPowerDbm);
1520  // At 4us, STA PHY STATE should stay IDLE
1521  Simulator::Schedule(Seconds(13.0) + MicroSeconds(4.0),
1522  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1523  this,
1524  WifiPhyState::CCA_BUSY);
1525  // No more packet should have been successfully received, and since preamble detection did not
1526  // pass the packet should not have been counted as a failure
1527  Simulator::Schedule(Seconds(13.1),
1528  &TestThresholdPreambleDetectionWithFrameCapture::CheckRxPacketCount,
1529  this,
1530  2,
1531  4);
1532 
1533  // CASE 14: send two packets with second one 3 dB weaker within the 4us window and check PHY
1534  // state: PHY preamble detection should fail PHY preamble detection should fail because SNR is
1535  // too low (around 3 dB, which is lower than the threshold of 4 dB), and PHY state should be
1536  // CCA_BUSY since it should detect the start of a valid OFDM transmission at a receive level
1537  // greater than or equal to the minimum modulation and coding rate sensitivity (–82 dBm for 20
1538  // MHz channel spacing).
1539 
1540  Simulator::Schedule(Seconds(14.0),
1541  &TestThresholdPreambleDetectionWithFrameCapture::SendPacket,
1542  this,
1543  rxPowerDbm);
1544  Simulator::Schedule(Seconds(14.0) + MicroSeconds(2.0),
1545  &TestThresholdPreambleDetectionWithFrameCapture::SendPacket,
1546  this,
1547  rxPowerDbm - 3);
1548  // At 4us, STA PHY STATE should stay IDLE
1549  Simulator::Schedule(Seconds(14.0) + MicroSeconds(4.0),
1550  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1551  this,
1552  WifiPhyState::CCA_BUSY);
1553  // No more packet should have been successfully received, and since preamble detection did not
1554  // pass the packet should not have been counted as a failure
1555  Simulator::Schedule(Seconds(14.1),
1556  &TestThresholdPreambleDetectionWithFrameCapture::CheckRxPacketCount,
1557  this,
1558  2,
1559  4);
1560 
1561  // CASE 15: send two packets with second one 6 dB weaker within the 4us window and check PHY
1562  // state: PHY preamble detection should succeed because SNR is high enough (around 6 dB, which
1563  // is higher than the threshold of 4 dB), but payload reception should fail (SNR too low to
1564  // decode the modulation).
1565 
1566  Simulator::Schedule(Seconds(15.0),
1567  &TestThresholdPreambleDetectionWithFrameCapture::SendPacket,
1568  this,
1569  rxPowerDbm);
1570  Simulator::Schedule(Seconds(15.0) + MicroSeconds(2.0),
1571  &TestThresholdPreambleDetectionWithFrameCapture::SendPacket,
1572  this,
1573  rxPowerDbm - 6);
1574  // At 4us, preamble should be successfully detected and STA PHY STATE should move from IDLE to
1575  // CCA_BUSY
1576  Simulator::Schedule(Seconds(15.0) + NanoSeconds(3999),
1577  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1578  this,
1579  WifiPhyState::IDLE);
1580  Simulator::Schedule(Seconds(15.0) + NanoSeconds(4000),
1581  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1582  this,
1583  WifiPhyState::CCA_BUSY);
1584  // At 44us, PHY header should be successfully received and STA PHY STATE should move from
1585  // CCA_BUSY to RX
1586  Simulator::Schedule(Seconds(15.0) + NanoSeconds(43999),
1587  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1588  this,
1589  WifiPhyState::CCA_BUSY);
1590  Simulator::Schedule(Seconds(15.0) + NanoSeconds(44000),
1591  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1592  this,
1593  WifiPhyState::RX);
1594  // Since it takes 152.8us to transmit the packet, PHY should be back to CCA_BUSY at time
1595  // 152.8us.
1596  Simulator::Schedule(Seconds(15.0) + NanoSeconds(152799),
1597  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1598  this,
1599  WifiPhyState::RX);
1600  Simulator::Schedule(Seconds(15.0) + NanoSeconds(152800),
1601  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1602  this,
1603  WifiPhyState::CCA_BUSY);
1604  // In this case, the first packet should be marked as a failure
1605  Simulator::Schedule(Seconds(15.1),
1606  &TestThresholdPreambleDetectionWithFrameCapture::CheckRxPacketCount,
1607  this,
1608  2,
1609  5);
1610 
1611  // CASE 16: send two packets with second one 3 dB higher within the 4us window and check PHY
1612  // state: PHY preamble detection should switch because a higher packet is received within the
1613  // 4us window, but preamble detection should fail because SNR is too low (around 3 dB, which is
1614  // lower than the threshold of 4 dB). and PHY state should be CCA_BUSY since it should detect
1615  // the start of a valid OFDM transmission at a receive level greater than or equal to the
1616  // minimum modulation and coding rate sensitivity (–82 dBm for 20 MHz channel spacing).
1617 
1618  Simulator::Schedule(Seconds(16.0),
1619  &TestThresholdPreambleDetectionWithFrameCapture::SendPacket,
1620  this,
1621  rxPowerDbm);
1622  Simulator::Schedule(Seconds(16.0) + MicroSeconds(2.0),
1623  &TestThresholdPreambleDetectionWithFrameCapture::SendPacket,
1624  this,
1625  rxPowerDbm + 3);
1626  // At 4us, STA PHY STATE should stay IDLE
1627  Simulator::Schedule(Seconds(16.0) + MicroSeconds(4.0),
1628  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1629  this,
1630  WifiPhyState::IDLE);
1631  // At 6us, STA PHY STATE should be CCA_BUSY
1632  Simulator::Schedule(Seconds(16.0) + MicroSeconds(6.0),
1633  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1634  this,
1635  WifiPhyState::CCA_BUSY);
1636  // No more packet should have been successfully received, and since preamble detection did not
1637  // pass the packet should not have been counted as a failure
1638  Simulator::Schedule(Seconds(16.1),
1639  &TestThresholdPreambleDetectionWithFrameCapture::CheckRxPacketCount,
1640  this,
1641  2,
1642  5);
1643 
1644  // CASE 17: send two packets with second one 6 dB higher within the 4us window and check PHY
1645  // state: PHY preamble detection should switch because a higher packet is received within the
1646  // 4us window, and preamble detection should succeed because SNR is high enough (around 6 dB,
1647  // which is higher than the threshold of 4 dB), Payload reception should fail (SNR too low to
1648  // decode the modulation).
1649 
1650  Simulator::Schedule(Seconds(17.0),
1651  &TestThresholdPreambleDetectionWithFrameCapture::SendPacket,
1652  this,
1653  rxPowerDbm);
1654  Simulator::Schedule(Seconds(17.0) + MicroSeconds(2.0),
1655  &TestThresholdPreambleDetectionWithFrameCapture::SendPacket,
1656  this,
1657  rxPowerDbm + 6);
1658  // At 4us, STA PHY STATE should stay IDLE
1659  Simulator::Schedule(Seconds(17.0) + MicroSeconds(4.0),
1660  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1661  this,
1662  WifiPhyState::IDLE);
1663  // At 6us, preamble should be successfully detected and STA PHY STATE should move from IDLE to
1664  // CCA_BUSY
1665  Simulator::Schedule(Seconds(17.0) + NanoSeconds(5999),
1666  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1667  this,
1668  WifiPhyState::IDLE);
1669  Simulator::Schedule(Seconds(17.0) + NanoSeconds(6000),
1670  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1671  this,
1672  WifiPhyState::CCA_BUSY);
1673  // At 46us, PHY header should be successfully received and STA PHY STATE should move from
1674  // CCA_BUSY to RX
1675  Simulator::Schedule(Seconds(17.0) + NanoSeconds(45999),
1676  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1677  this,
1678  WifiPhyState::CCA_BUSY);
1679  Simulator::Schedule(Seconds(17.0) + NanoSeconds(46000),
1680  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1681  this,
1682  WifiPhyState::RX);
1683  // Since it takes 152.8us to transmit each packet, PHY should be back to IDLE at time 152.8 + 2
1684  // = 154.8us
1685  Simulator::Schedule(Seconds(17.0) + NanoSeconds(154799),
1686  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1687  this,
1688  WifiPhyState::RX);
1689  Simulator::Schedule(Seconds(17.0) + NanoSeconds(154800),
1690  &TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState,
1691  this,
1692  WifiPhyState::IDLE);
1693  // In this case, the second packet should be marked as a failure
1694  Simulator::Schedule(Seconds(17.1),
1695  &TestThresholdPreambleDetectionWithFrameCapture::CheckRxPacketCount,
1696  this,
1697  2,
1698  6);
1699 
1700  rxPowerDbm = -50;
1701  // CASE 18: send two packets with second one 50 dB higher within the 4us window
1702 
1703  Simulator::Schedule(Seconds(18.0),
1704  &TestThresholdPreambleDetectionWithFrameCapture::SendPacket,
1705  this,
1706  rxPowerDbm);
1707  Simulator::Schedule(Seconds(18.0) + MicroSeconds(2.0),
1708  &TestThresholdPreambleDetectionWithFrameCapture::SendPacket,
1709  this,
1710  rxPowerDbm + 50);
1711  // The second packet should be received successfully
1712  Simulator::Schedule(Seconds(18.1),
1713  &TestThresholdPreambleDetectionWithFrameCapture::CheckRxPacketCount,
1714  this,
1715  3,
1716  6);
1717 
1718  // CASE 19: send two packets with second one 10 dB higher within the 4us window
1719 
1720  Simulator::Schedule(Seconds(19.0),
1721  &TestThresholdPreambleDetectionWithFrameCapture::SendPacket,
1722  this,
1723  rxPowerDbm);
1724  Simulator::Schedule(Seconds(19.0) + MicroSeconds(2.0),
1725  &TestThresholdPreambleDetectionWithFrameCapture::SendPacket,
1726  this,
1727  rxPowerDbm + 10);
1728  // The second packet should be captured, but not decoded since SNR to low for used MCS
1729  Simulator::Schedule(Seconds(19.1),
1730  &TestThresholdPreambleDetectionWithFrameCapture::CheckRxPacketCount,
1731  this,
1732  3,
1733  7);
1734 
1735  // CASE 20: send two packets with second one 50 dB higher in the same time
1736 
1737  Simulator::Schedule(Seconds(20.0),
1738  &TestThresholdPreambleDetectionWithFrameCapture::SendPacket,
1739  this,
1740  rxPowerDbm);
1741  Simulator::Schedule(Seconds(20.0),
1742  &TestThresholdPreambleDetectionWithFrameCapture::SendPacket,
1743  this,
1744  rxPowerDbm + 50);
1745  // The second packet should be received successfully, same as in CASE 13
1746  Simulator::Schedule(Seconds(20.1),
1747  &TestThresholdPreambleDetectionWithFrameCapture::CheckRxPacketCount,
1748  this,
1749  4,
1750  7);
1751 
1752  // CASE 21: send two packets with second one 10 dB higher in the same time
1753 
1754  Simulator::Schedule(Seconds(21.0),
1755  &TestThresholdPreambleDetectionWithFrameCapture::SendPacket,
1756  this,
1757  rxPowerDbm);
1758  Simulator::Schedule(Seconds(21.0),
1759  &TestThresholdPreambleDetectionWithFrameCapture::SendPacket,
1760  this,
1761  rxPowerDbm + 10);
1762  // The second packet should be captured, but not decoded since SNR to low for used MCS, same as
1763  // in CASE 19
1764  Simulator::Schedule(Seconds(21.1),
1765  &TestThresholdPreambleDetectionWithFrameCapture::CheckRxPacketCount,
1766  this,
1767  4,
1768  8);
1769 
1770  Simulator::Run();
1771  Simulator::Destroy();
1772 }
1773 
1780 class TestSimpleFrameCaptureModel : public TestCase
1781 {
1782  public:
1783  TestSimpleFrameCaptureModel();
1784  ~TestSimpleFrameCaptureModel() override;
1785 
1786  protected:
1787  void DoSetup() override;
1788  void DoTeardown() override;
1789 
1790  private:
1791  void DoRun() override;
1792 
1796  void Reset();
1802  void SendPacket(double rxPowerDbm, uint32_t packetSize);
1810  void RxSuccess(Ptr<const WifiPsdu> psdu,
1811  RxSignalInfo rxSignalInfo,
1812  WifiTxVector txVector,
1813  std::vector<bool> statusPerMpdu);
1819  void RxDropped(Ptr<const Packet> p, WifiPhyRxfailureReason reason);
1820 
1824  void Expect1000BPacketReceived();
1828  void Expect1500BPacketReceived();
1832  void Expect1000BPacketDropped();
1836  void Expect1500BPacketDropped();
1837 
1838  Ptr<SpectrumWifiPhy> m_phy;
1839 
1840  bool m_rxSuccess1000B;
1841  bool m_rxSuccess1500B;
1842  bool m_rxDropped1000B;
1843  bool m_rxDropped1500B;
1844 
1845  uint64_t m_uid;
1846 };
1847 
1848 TestSimpleFrameCaptureModel::TestSimpleFrameCaptureModel()
1849  : TestCase("Simple frame capture model test"),
1850  m_rxSuccess1000B(false),
1851  m_rxSuccess1500B(false),
1852  m_rxDropped1000B(false),
1853  m_rxDropped1500B(false),
1854  m_uid(0)
1855 {
1856 }
1857 
1858 void
1859 TestSimpleFrameCaptureModel::SendPacket(double rxPowerDbm, uint32_t packetSize)
1860 {
1861  WifiTxVector txVector =
1862  WifiTxVector(HePhy::GetHeMcs0(), 0, WIFI_PREAMBLE_HE_SU, 800, 1, 1, 0, 20, false);
1863 
1864  Ptr<Packet> pkt = Create<Packet>(packetSize);
1865  WifiMacHeader hdr;
1866 
1867  hdr.SetType(WIFI_MAC_QOSDATA);
1868  hdr.SetQosTid(0);
1869 
1870  Ptr<WifiPsdu> psdu = Create<WifiPsdu>(pkt, hdr);
1871  Time txDuration = m_phy->CalculateTxDuration(psdu->GetSize(), txVector, m_phy->GetPhyBand());
1872 
1873  Ptr<WifiPpdu> ppdu =
1874  Create<HePpdu>(psdu, txVector, FREQUENCY, txDuration, WIFI_PHY_BAND_5GHZ, m_uid++);
1875 
1876  Ptr<SpectrumValue> txPowerSpectrum =
1877  WifiSpectrumValueHelper::CreateHeOfdmTxPowerSpectralDensity(FREQUENCY,
1878  CHANNEL_WIDTH,
1879  DbmToW(rxPowerDbm),
1880  GUARD_WIDTH);
1881 
1882  Ptr<WifiSpectrumSignalParameters> txParams = Create<WifiSpectrumSignalParameters>();
1883  txParams->psd = txPowerSpectrum;
1884  txParams->txPhy = nullptr;
1885  txParams->duration = txDuration;
1886  txParams->ppdu = ppdu;
1887 
1888  m_phy->StartRx(txParams);
1889 }
1890 
1891 void
1892 TestSimpleFrameCaptureModel::RxSuccess(Ptr<const WifiPsdu> psdu,
1893  RxSignalInfo rxSignalInfo,
1894  WifiTxVector txVector,
1895  std::vector<bool> statusPerMpdu)
1896 {
1897  NS_LOG_FUNCTION(this << *psdu << rxSignalInfo << txVector);
1898  NS_ASSERT(!psdu->IsAggregate() || psdu->IsSingle());
1899  if (psdu->GetSize() == 1030)
1900  {
1901  m_rxSuccess1000B = true;
1902  }
1903  else if (psdu->GetSize() == 1530)
1904  {
1905  m_rxSuccess1500B = true;
1906  }
1907 }
1908 
1909 void
1910 TestSimpleFrameCaptureModel::RxDropped(Ptr<const Packet> p, WifiPhyRxfailureReason reason)
1911 {
1912  NS_LOG_FUNCTION(this << p << reason);
1913  if (p->GetSize() == 1030)
1914  {
1915  m_rxDropped1000B = true;
1916  }
1917  else if (p->GetSize() == 1530)
1918  {
1919  m_rxDropped1500B = true;
1920  }
1921 }
1922 
1923 void
1924 TestSimpleFrameCaptureModel::Reset()
1925 {
1926  m_rxSuccess1000B = false;
1927  m_rxSuccess1500B = false;
1928  m_rxDropped1000B = false;
1929  m_rxDropped1500B = false;
1930 }
1931 
1932 void
1933 TestSimpleFrameCaptureModel::Expect1000BPacketReceived()
1934 {
1935  NS_TEST_ASSERT_MSG_EQ(m_rxSuccess1000B, true, "Didn't receive 1000B packet");
1936 }
1937 
1938 void
1939 TestSimpleFrameCaptureModel::Expect1500BPacketReceived()
1940 {
1941  NS_TEST_ASSERT_MSG_EQ(m_rxSuccess1500B, true, "Didn't receive 1500B packet");
1942 }
1943 
1944 void
1945 TestSimpleFrameCaptureModel::Expect1000BPacketDropped()
1946 {
1947  NS_TEST_ASSERT_MSG_EQ(m_rxDropped1000B, true, "Didn't drop 1000B packet");
1948 }
1949 
1950 void
1951 TestSimpleFrameCaptureModel::Expect1500BPacketDropped()
1952 {
1953  NS_TEST_ASSERT_MSG_EQ(m_rxDropped1500B, true, "Didn't drop 1500B packet");
1954 }
1955 
1956 TestSimpleFrameCaptureModel::~TestSimpleFrameCaptureModel()
1957 {
1958  m_phy = nullptr;
1959 }
1960 
1961 void
1962 TestSimpleFrameCaptureModel::DoSetup()
1963 {
1964  m_phy = CreateObject<SpectrumWifiPhy>();
1965  m_phy->ConfigureStandard(WIFI_STANDARD_80211ax);
1966  Ptr<InterferenceHelper> interferenceHelper = CreateObject<InterferenceHelper>();
1967  m_phy->SetInterferenceHelper(interferenceHelper);
1968  Ptr<ErrorRateModel> error = CreateObject<NistErrorRateModel>();
1969  m_phy->SetErrorRateModel(error);
1970  m_phy->SetOperatingChannel(WifiPhy::ChannelTuple{CHANNEL_NUMBER, 0, WIFI_PHY_BAND_5GHZ, 0});
1971 
1972  m_phy->SetReceiveOkCallback(MakeCallback(&TestSimpleFrameCaptureModel::RxSuccess, this));
1973  m_phy->TraceConnectWithoutContext("PhyRxDrop",
1974  MakeCallback(&TestSimpleFrameCaptureModel::RxDropped, this));
1975 
1976  Ptr<ThresholdPreambleDetectionModel> preambleDetectionModel =
1977  CreateObject<ThresholdPreambleDetectionModel>();
1978  preambleDetectionModel->SetAttribute("Threshold", DoubleValue(2));
1979  m_phy->SetPreambleDetectionModel(preambleDetectionModel);
1980 
1981  Ptr<SimpleFrameCaptureModel> frameCaptureModel = CreateObject<SimpleFrameCaptureModel>();
1982  frameCaptureModel->SetAttribute("Margin", DoubleValue(5));
1983  frameCaptureModel->SetAttribute("CaptureWindow", TimeValue(MicroSeconds(16)));
1984  m_phy->SetFrameCaptureModel(frameCaptureModel);
1985 }
1986 
1987 void
1988 TestSimpleFrameCaptureModel::DoTeardown()
1989 {
1990  m_phy->Dispose();
1991  m_phy = nullptr;
1992 }
1993 
1994 void
1995 TestSimpleFrameCaptureModel::DoRun()
1996 {
1997  RngSeedManager::SetSeed(1);
1998  RngSeedManager::SetRun(1);
1999  int64_t streamNumber = 2;
2000  double rxPowerDbm = -30;
2001  m_phy->AssignStreams(streamNumber);
2002 
2003  // CASE 1: send two packets with same power within the capture window:
2004  // PHY should not switch reception because they have same power.
2005 
2006  Simulator::Schedule(Seconds(1.0),
2007  &TestSimpleFrameCaptureModel::SendPacket,
2008  this,
2009  rxPowerDbm,
2010  1000);
2011  Simulator::Schedule(Seconds(1.0) + MicroSeconds(10.0),
2012  &TestSimpleFrameCaptureModel::SendPacket,
2013  this,
2014  rxPowerDbm,
2015  1500);
2016  Simulator::Schedule(Seconds(1.1), &TestSimpleFrameCaptureModel::Expect1500BPacketDropped, this);
2017  Simulator::Schedule(Seconds(1.2), &TestSimpleFrameCaptureModel::Reset, this);
2018 
2019  // CASE 2: send two packets with second one 6 dB weaker within the capture window:
2020  // PHY should not switch reception because first one has higher power.
2021 
2022  Simulator::Schedule(Seconds(2.0),
2023  &TestSimpleFrameCaptureModel::SendPacket,
2024  this,
2025  rxPowerDbm,
2026  1000);
2027  Simulator::Schedule(Seconds(2.0) + MicroSeconds(10.0),
2028  &TestSimpleFrameCaptureModel::SendPacket,
2029  this,
2030  rxPowerDbm - 6,
2031  1500);
2032  Simulator::Schedule(Seconds(2.1),
2033  &TestSimpleFrameCaptureModel::Expect1000BPacketReceived,
2034  this);
2035  Simulator::Schedule(Seconds(2.1), &TestSimpleFrameCaptureModel::Expect1500BPacketDropped, this);
2036  Simulator::Schedule(Seconds(2.2), &TestSimpleFrameCaptureModel::Reset, this);
2037 
2038  // CASE 3: send two packets with second one 6 dB higher within the capture window:
2039  // PHY should switch reception because the second one has a higher power.
2040 
2041  Simulator::Schedule(Seconds(3.0),
2042  &TestSimpleFrameCaptureModel::SendPacket,
2043  this,
2044  rxPowerDbm,
2045  1000);
2046  Simulator::Schedule(Seconds(3.0) + MicroSeconds(10.0),
2047  &TestSimpleFrameCaptureModel::SendPacket,
2048  this,
2049  rxPowerDbm + 6,
2050  1500);
2051  Simulator::Schedule(Seconds(3.1), &TestSimpleFrameCaptureModel::Expect1000BPacketDropped, this);
2052  Simulator::Schedule(Seconds(3.1),
2053  &TestSimpleFrameCaptureModel::Expect1500BPacketReceived,
2054  this);
2055  Simulator::Schedule(Seconds(3.2), &TestSimpleFrameCaptureModel::Reset, this);
2056 
2057  // CASE 4: send two packets with second one 6 dB higher after the capture window:
2058  // PHY should not switch reception because capture window duration has elapsed when the second
2059  // packet arrives.
2060 
2061  Simulator::Schedule(Seconds(4.0),
2062  &TestSimpleFrameCaptureModel::SendPacket,
2063  this,
2064  rxPowerDbm,
2065  1000);
2066  Simulator::Schedule(Seconds(4.0) + MicroSeconds(25.0),
2067  &TestSimpleFrameCaptureModel::SendPacket,
2068  this,
2069  rxPowerDbm + 6,
2070  1500);
2071  Simulator::Schedule(Seconds(4.1), &TestSimpleFrameCaptureModel::Expect1500BPacketDropped, this);
2072  Simulator::Schedule(Seconds(4.2), &TestSimpleFrameCaptureModel::Reset, this);
2073 
2074  Simulator::Run();
2075  Simulator::Destroy();
2076 }
2077 
2084 class TestPhyHeadersReception : public TestCase
2085 {
2086  public:
2087  TestPhyHeadersReception();
2088  ~TestPhyHeadersReception() override;
2089 
2090  protected:
2091  void DoSetup() override;
2092  void DoTeardown() override;
2093  Ptr<SpectrumWifiPhy> m_phy;
2098  void SendPacket(double rxPowerDbm);
2099 
2100  private:
2101  void DoRun() override;
2102 
2107  void CheckPhyState(WifiPhyState expectedState);
2112  void DoCheckPhyState(WifiPhyState expectedState);
2113 
2114  uint64_t m_uid;
2115 };
2116 
2117 TestPhyHeadersReception::TestPhyHeadersReception()
2118  : TestCase("PHY headers reception test"),
2119  m_uid(0)
2120 {
2121 }
2122 
2123 void
2124 TestPhyHeadersReception::SendPacket(double rxPowerDbm)
2125 {
2126  WifiTxVector txVector =
2127  WifiTxVector(HePhy::GetHeMcs7(), 0, WIFI_PREAMBLE_HE_SU, 800, 1, 1, 0, 20, false);
2128 
2129  Ptr<Packet> pkt = Create<Packet>(1000);
2130  WifiMacHeader hdr;
2131 
2132  hdr.SetType(WIFI_MAC_QOSDATA);
2133  hdr.SetQosTid(0);
2134 
2135  Ptr<WifiPsdu> psdu = Create<WifiPsdu>(pkt, hdr);
2136  Time txDuration = m_phy->CalculateTxDuration(psdu->GetSize(), txVector, m_phy->GetPhyBand());
2137 
2138  Ptr<WifiPpdu> ppdu =
2139  Create<HePpdu>(psdu, txVector, FREQUENCY, txDuration, WIFI_PHY_BAND_5GHZ, m_uid++);
2140 
2141  Ptr<SpectrumValue> txPowerSpectrum =
2142  WifiSpectrumValueHelper::CreateHeOfdmTxPowerSpectralDensity(FREQUENCY,
2143  CHANNEL_WIDTH,
2144  DbmToW(rxPowerDbm),
2145  GUARD_WIDTH);
2146 
2147  Ptr<WifiSpectrumSignalParameters> txParams = Create<WifiSpectrumSignalParameters>();
2148  txParams->psd = txPowerSpectrum;
2149  txParams->txPhy = nullptr;
2150  txParams->duration = txDuration;
2151  txParams->ppdu = ppdu;
2152 
2153  m_phy->StartRx(txParams);
2154 }
2155 
2156 void
2157 TestPhyHeadersReception::CheckPhyState(WifiPhyState expectedState)
2158 {
2159  // This is needed to make sure PHY state will be checked as the last event if a state change
2160  // occurred at the exact same time as the check
2161  Simulator::ScheduleNow(&TestPhyHeadersReception::DoCheckPhyState, this, expectedState);
2162 }
2163 
2164 void
2165 TestPhyHeadersReception::DoCheckPhyState(WifiPhyState expectedState)
2166 {
2167  WifiPhyState currentState;
2168  PointerValue ptr;
2169  m_phy->GetAttribute("State", ptr);
2170  Ptr<WifiPhyStateHelper> state = DynamicCast<WifiPhyStateHelper>(ptr.Get<WifiPhyStateHelper>());
2171  currentState = state->GetState();
2172  NS_LOG_FUNCTION(this << currentState);
2173  NS_TEST_ASSERT_MSG_EQ(currentState,
2174  expectedState,
2175  "PHY State " << currentState << " does not match expected state "
2176  << expectedState << " at " << Simulator::Now());
2177 }
2178 
2179 TestPhyHeadersReception::~TestPhyHeadersReception()
2180 {
2181  m_phy = nullptr;
2182 }
2183 
2184 void
2185 TestPhyHeadersReception::DoSetup()
2186 {
2187  m_phy = CreateObject<SpectrumWifiPhy>();
2188  m_phy->ConfigureStandard(WIFI_STANDARD_80211ax);
2189  Ptr<InterferenceHelper> interferenceHelper = CreateObject<InterferenceHelper>();
2190  m_phy->SetInterferenceHelper(interferenceHelper);
2191  Ptr<ErrorRateModel> error = CreateObject<NistErrorRateModel>();
2192  m_phy->SetErrorRateModel(error);
2193  m_phy->SetOperatingChannel(WifiPhy::ChannelTuple{CHANNEL_NUMBER, 0, WIFI_PHY_BAND_5GHZ, 0});
2194 }
2195 
2196 void
2197 TestPhyHeadersReception::DoTeardown()
2198 {
2199  m_phy->Dispose();
2200  m_phy = nullptr;
2201 }
2202 
2203 void
2204 TestPhyHeadersReception::DoRun()
2205 {
2206  RngSeedManager::SetSeed(1);
2207  RngSeedManager::SetRun(1);
2208  int64_t streamNumber = 0;
2209  m_phy->AssignStreams(streamNumber);
2210 
2211  // RX power > CCA-ED
2212  double rxPowerDbm = -50;
2213 
2214  // CASE 1: send one packet followed by a second one with same power between the end of the 4us
2215  // preamble detection window and the start of L-SIG of the first packet: reception should be
2216  // aborted since L-SIG cannot be decoded (SNR too low).
2217 
2218  Simulator::Schedule(Seconds(1.0), &TestPhyHeadersReception::SendPacket, this, rxPowerDbm);
2219  Simulator::Schedule(Seconds(1.0) + MicroSeconds(10),
2220  &TestPhyHeadersReception::SendPacket,
2221  this,
2222  rxPowerDbm);
2223  // At 10 us, STA PHY STATE should be CCA_BUSY.
2224  Simulator::Schedule(Seconds(1.0) + MicroSeconds(10.0),
2225  &TestPhyHeadersReception::CheckPhyState,
2226  this,
2227  WifiPhyState::CCA_BUSY);
2228  // At 44us (end of PHY header), STA PHY STATE should not have moved to RX and be kept to
2229  // CCA_BUSY.
2230  Simulator::Schedule(Seconds(1.0) + NanoSeconds(44000),
2231  &TestPhyHeadersReception::CheckPhyState,
2232  this,
2233  WifiPhyState::CCA_BUSY);
2234  // Since it takes 152.8us to transmit the packet, PHY should be back to IDLE at time 152.8 + 10
2235  // = 162.8us.
2236  Simulator::Schedule(Seconds(1.0) + NanoSeconds(162799),
2237  &TestPhyHeadersReception::CheckPhyState,
2238  this,
2239  WifiPhyState::CCA_BUSY);
2240  Simulator::Schedule(Seconds(1.0) + NanoSeconds(162800),
2241  &TestPhyHeadersReception::CheckPhyState,
2242  this,
2243  WifiPhyState::IDLE);
2244 
2245  // CASE 2: send one packet followed by a second one 3 dB weaker between the end of the 4us
2246  // preamble detection window and the start of L-SIG of the first packet: reception should not be
2247  // aborted since L-SIG can be decoded (SNR high enough).
2248 
2249  Simulator::Schedule(Seconds(2.0), &TestPhyHeadersReception::SendPacket, this, rxPowerDbm);
2250  Simulator::Schedule(Seconds(2.0) + MicroSeconds(10),
2251  &TestPhyHeadersReception::SendPacket,
2252  this,
2253  rxPowerDbm - 3);
2254  // At 10 us, STA PHY STATE should be CCA_BUSY.
2255  Simulator::Schedule(Seconds(2.0) + MicroSeconds(10.0),
2256  &TestPhyHeadersReception::CheckPhyState,
2257  this,
2258  WifiPhyState::CCA_BUSY);
2259  // At 44us (end of PHY header), STA PHY STATE should have moved to RX since PHY header reception
2260  // should have succeeded.
2261  Simulator::Schedule(Seconds(2.0) + NanoSeconds(43999),
2262  &TestPhyHeadersReception::CheckPhyState,
2263  this,
2264  WifiPhyState::CCA_BUSY);
2265  Simulator::Schedule(Seconds(2.0) + NanoSeconds(44000),
2266  &TestPhyHeadersReception::CheckPhyState,
2267  this,
2268  WifiPhyState::RX);
2269  // Since it takes 152.8us to transmit the packet, PHY should be back to IDLE at time 152.8us.
2270  // However, since there is a second packet transmitted with a power above CCA-ED (-62 dBm), PHY
2271  // should first be seen as CCA_BUSY for 10us.
2272  Simulator::Schedule(Seconds(2.0) + NanoSeconds(152799),
2273  &TestPhyHeadersReception::CheckPhyState,
2274  this,
2275  WifiPhyState::RX);
2276  Simulator::Schedule(Seconds(2.0) + NanoSeconds(152800),
2277  &TestPhyHeadersReception::CheckPhyState,
2278  this,
2279  WifiPhyState::CCA_BUSY);
2280  Simulator::Schedule(Seconds(2.0) + NanoSeconds(162799),
2281  &TestPhyHeadersReception::CheckPhyState,
2282  this,
2283  WifiPhyState::CCA_BUSY);
2284  Simulator::Schedule(Seconds(2.0) + NanoSeconds(162800),
2285  &TestPhyHeadersReception::CheckPhyState,
2286  this,
2287  WifiPhyState::IDLE);
2288 
2289  // CASE 3: send one packet followed by a second one with same power between the end of L-SIG and
2290  // the start of HE-SIG of the first packet: PHY header reception should not succeed but PHY
2291  // should stay in RX state for the duration estimated from L-SIG.
2292 
2293  Simulator::Schedule(Seconds(3.0), &TestPhyHeadersReception::SendPacket, this, rxPowerDbm);
2294  Simulator::Schedule(Seconds(3.0) + MicroSeconds(25),
2295  &TestPhyHeadersReception::SendPacket,
2296  this,
2297  rxPowerDbm);
2298  // At 44us (end of PHY header), STA PHY STATE should not have moved to RX (HE-SIG failed) and be
2299  // kept to CCA_BUSY.
2300  Simulator::Schedule(Seconds(3.0) + MicroSeconds(44.0),
2301  &TestPhyHeadersReception::CheckPhyState,
2302  this,
2303  WifiPhyState::CCA_BUSY);
2304  // STA PHY STATE should move back to IDLE once the duration estimated from L-SIG has elapsed,
2305  // i.e. at 152.8us. However, since there is a second packet transmitted with a power above
2306  // CCA-ED (-62 dBm), PHY should first be seen as CCA_BUSY for 25us.
2307  Simulator::Schedule(Seconds(3.0) + NanoSeconds(152799),
2308  &TestPhyHeadersReception::CheckPhyState,
2309  this,
2310  WifiPhyState::CCA_BUSY);
2311  Simulator::Schedule(Seconds(3.0) + NanoSeconds(152800),
2312  &TestPhyHeadersReception::CheckPhyState,
2313  this,
2314  WifiPhyState::CCA_BUSY);
2315  Simulator::Schedule(Seconds(3.0) + NanoSeconds(177799),
2316  &TestPhyHeadersReception::CheckPhyState,
2317  this,
2318  WifiPhyState::CCA_BUSY);
2319  Simulator::Schedule(Seconds(3.0) + NanoSeconds(177800),
2320  &TestPhyHeadersReception::CheckPhyState,
2321  this,
2322  WifiPhyState::IDLE);
2323 
2324  // CASE 4: send one packet followed by a second one 3 dB weaker between the end of L-SIG and the
2325  // start of HE-SIG of the first packet: PHY header reception should succeed.
2326 
2327  Simulator::Schedule(Seconds(4.0), &TestPhyHeadersReception::SendPacket, this, rxPowerDbm);
2328  Simulator::Schedule(Seconds(4.0) + MicroSeconds(25),
2329  &TestPhyHeadersReception::SendPacket,
2330  this,
2331  rxPowerDbm - 3);
2332  // At 10 us, STA PHY STATE should be CCA_BUSY.
2333  Simulator::Schedule(Seconds(4.0) + MicroSeconds(10.0),
2334  &TestPhyHeadersReception::CheckPhyState,
2335  this,
2336  WifiPhyState::CCA_BUSY);
2337  // At 44 us (end of HE-SIG), STA PHY STATE should move to RX since the PHY header reception
2338  // should have succeeded.
2339  Simulator::Schedule(Seconds(4.0) + NanoSeconds(43999),
2340  &TestPhyHeadersReception::CheckPhyState,
2341  this,
2342  WifiPhyState::CCA_BUSY);
2343  Simulator::Schedule(Seconds(4.0) + NanoSeconds(44000),
2344  &TestPhyHeadersReception::CheckPhyState,
2345  this,
2346  WifiPhyState::RX);
2347  // STA PHY STATE should move back to IDLE once the duration estimated from L-SIG has elapsed,
2348  // i.e. at 152.8us. However, since there is a second packet transmitted with a power above
2349  // CCA-ED (-62 dBm), PHY should first be seen as CCA_BUSY for 25us.
2350  Simulator::Schedule(Seconds(4.0) + NanoSeconds(152799),
2351  &TestPhyHeadersReception::CheckPhyState,
2352  this,
2353  WifiPhyState::RX);
2354  Simulator::Schedule(Seconds(4.0) + NanoSeconds(152800),
2355  &TestPhyHeadersReception::CheckPhyState,
2356  this,
2357  WifiPhyState::CCA_BUSY);
2358  Simulator::Schedule(Seconds(4.0) + NanoSeconds(177799),
2359  &TestPhyHeadersReception::CheckPhyState,
2360  this,
2361  WifiPhyState::CCA_BUSY);
2362  Simulator::Schedule(Seconds(4.0) + NanoSeconds(177800),
2363  &TestPhyHeadersReception::CheckPhyState,
2364  this,
2365  WifiPhyState::IDLE);
2366 
2367  // RX power < CCA-ED
2368  rxPowerDbm = -70;
2369 
2370  // CASE 5: send one packet followed by a second one with same power between the end of the 4us
2371  // preamble detection window and the start of L-SIG of the first packet: reception should be
2372  // aborted since L-SIG cannot be decoded (SNR too low).
2373 
2374  Simulator::Schedule(Seconds(5.0), &TestPhyHeadersReception::SendPacket, this, rxPowerDbm);
2375  Simulator::Schedule(Seconds(5.0) + MicroSeconds(10),
2376  &TestPhyHeadersReception::SendPacket,
2377  this,
2378  rxPowerDbm);
2379  // At 10 us, STA PHY STATE should be CCA_BUSY.
2380  Simulator::Schedule(Seconds(5.0) + MicroSeconds(10.0),
2381  &TestPhyHeadersReception::CheckPhyState,
2382  this,
2383  WifiPhyState::CCA_BUSY);
2384  // At 24us (end of L-SIG), STA PHY STATE stay CCA_BUSY because L-SIG reception failed and the
2385  // start of a valid OFDM transmission has been detected
2386  Simulator::Schedule(Seconds(5.0) + NanoSeconds(24000),
2387  &TestPhyHeadersReception::CheckPhyState,
2388  this,
2389  WifiPhyState::CCA_BUSY);
2390 
2391  // CASE 6: send one packet followed by a second one 3 dB weaker between the end of the 4us
2392  // preamble detection window and the start of L-SIG of the first packet: reception should not be
2393  // aborted since L-SIG can be decoded (SNR high enough).
2394 
2395  Simulator::Schedule(Seconds(6.0), &TestPhyHeadersReception::SendPacket, this, rxPowerDbm);
2396  Simulator::Schedule(Seconds(6.0) + MicroSeconds(10),
2397  &TestPhyHeadersReception::SendPacket,
2398  this,
2399  rxPowerDbm - 3);
2400  // At 10 us, STA PHY STATE should be CCA_BUSY.
2401  Simulator::Schedule(Seconds(6.0) + MicroSeconds(10.0),
2402  &TestPhyHeadersReception::CheckPhyState,
2403  this,
2404  WifiPhyState::CCA_BUSY);
2405  // At 24us (end of L-SIG), STA PHY STATE should be unchanged because L-SIG reception should have
2406  // succeeded.
2407  Simulator::Schedule(Seconds(6.0) + MicroSeconds(24.0),
2408  &TestPhyHeadersReception::CheckPhyState,
2409  this,
2410  WifiPhyState::CCA_BUSY);
2411  // At 44 us (end of HE-SIG), STA PHY STATE should move to RX since the PHY header reception
2412  // should have succeeded.
2413  Simulator::Schedule(Seconds(6.0) + NanoSeconds(43999),
2414  &TestPhyHeadersReception::CheckPhyState,
2415  this,
2416  WifiPhyState::CCA_BUSY);
2417  Simulator::Schedule(Seconds(6.0) + NanoSeconds(44000),
2418  &TestPhyHeadersReception::CheckPhyState,
2419  this,
2420  WifiPhyState::RX);
2421  // Since it takes 152.8us to transmit the packet, PHY should be back to CCA_BUSY at time
2422  // 152.8us.
2423  Simulator::Schedule(Seconds(6.0) + NanoSeconds(152799),
2424  &TestPhyHeadersReception::CheckPhyState,
2425  this,
2426  WifiPhyState::RX);
2427  Simulator::Schedule(Seconds(6.0) + NanoSeconds(152800),
2428  &TestPhyHeadersReception::CheckPhyState,
2429  this,
2430  WifiPhyState::CCA_BUSY);
2431 
2432  // CASE 7: send one packet followed by a second one with same power between the end of L-SIG and
2433  // the start of HE-SIG of the first packet: PHY header reception should not succeed but PHY
2434  // should stay in RX state for the duration estimated from L-SIG.
2435 
2436  Simulator::Schedule(Seconds(7.0), &TestPhyHeadersReception::SendPacket, this, rxPowerDbm);
2437  Simulator::Schedule(Seconds(7.0) + MicroSeconds(25),
2438  &TestPhyHeadersReception::SendPacket,
2439  this,
2440  rxPowerDbm);
2441  // At 10 us, STA PHY STATE should be CCA_BUSY.
2442  Simulator::Schedule(Seconds(7.0) + MicroSeconds(10.0),
2443  &TestPhyHeadersReception::CheckPhyState,
2444  this,
2445  WifiPhyState::CCA_BUSY);
2446  // At 24us (end of L-SIG), STA PHY STATE should be unchanged because L-SIG reception should have
2447  // succeeded.
2448  Simulator::Schedule(Seconds(7.0) + MicroSeconds(24.0),
2449  &TestPhyHeadersReception::CheckPhyState,
2450  this,
2451  WifiPhyState::CCA_BUSY);
2452  // At 44 us (end of HE-SIG), STA PHY STATE should be not have moved to RX since reception of
2453  // HE-SIG should have failed.
2454  Simulator::Schedule(Seconds(7.0) + MicroSeconds(44.0),
2455  &TestPhyHeadersReception::CheckPhyState,
2456  this,
2457  WifiPhyState::CCA_BUSY);
2458  // STA PHY STATE should keep CCA_BUSY once the duration estimated from L-SIG has elapsed, i.e.
2459  // at 152.8us.
2460  Simulator::Schedule(Seconds(7.0) + NanoSeconds(152800),
2461  &TestPhyHeadersReception::CheckPhyState,
2462  this,
2463  WifiPhyState::CCA_BUSY);
2464 
2465  // CASE 8: send one packet followed by a second one 3 dB weaker between the end of L-SIG and the
2466  // start of HE-SIG of the first packet: PHY header reception should succeed.
2467 
2468  Simulator::Schedule(Seconds(8.0), &TestPhyHeadersReception::SendPacket, this, rxPowerDbm);
2469  Simulator::Schedule(Seconds(8.0) + MicroSeconds(25),
2470  &TestPhyHeadersReception::SendPacket,
2471  this,
2472  rxPowerDbm - 3);
2473  // At 10 us, STA PHY STATE should be CCA_BUSY.
2474  Simulator::Schedule(Seconds(8.0) + MicroSeconds(10.0),
2475  &TestPhyHeadersReception::CheckPhyState,
2476  this,
2477  WifiPhyState::CCA_BUSY);
2478  // At 24us (end of L-SIG), STA PHY STATE should be unchanged because L-SIG reception should have
2479  // succeeded.
2480  Simulator::Schedule(Seconds(8.0) + MicroSeconds(24.0),
2481  &TestPhyHeadersReception::CheckPhyState,
2482  this,
2483  WifiPhyState::CCA_BUSY);
2484  // At 44 us (end of HE-SIG), STA PHY STATE should move to RX since the PHY header reception
2485  // should have succeeded.
2486  Simulator::Schedule(Seconds(8.0) + NanoSeconds(43999),
2487  &TestPhyHeadersReception::CheckPhyState,
2488  this,
2489  WifiPhyState::CCA_BUSY);
2490  Simulator::Schedule(Seconds(8.0) + NanoSeconds(44000),
2491  &TestPhyHeadersReception::CheckPhyState,
2492  this,
2493  WifiPhyState::RX);
2494  // STA PHY STATE should move back to CCA_BUSY once the duration estimated from L-SIG has
2495  // elapsed, i.e. at 152.8us.
2496  Simulator::Schedule(Seconds(8.0) + NanoSeconds(152799),
2497  &TestPhyHeadersReception::CheckPhyState,
2498  this,
2499  WifiPhyState::RX);
2500  Simulator::Schedule(Seconds(8.0) + NanoSeconds(152800),
2501  &TestPhyHeadersReception::CheckPhyState,
2502  this,
2503  WifiPhyState::CCA_BUSY);
2504 
2505  Simulator::Run();
2506  Simulator::Destroy();
2507 }
2508 
2515 class TestAmpduReception : public TestCase
2516 {
2517  public:
2518  TestAmpduReception();
2519  ~TestAmpduReception() override;
2520 
2521  protected:
2522  void DoSetup() override;
2523  void DoTeardown() override;
2524 
2525  private:
2526  void DoRun() override;
2527 
2535  void RxSuccess(Ptr<const WifiPsdu> psdu,
2536  RxSignalInfo rxSignalInfo,
2537  WifiTxVector txVector,
2538  std::vector<bool> statusPerMpdu);
2543  void RxFailure(Ptr<const WifiPsdu> psdu);
2549  void RxDropped(Ptr<const Packet> p, WifiPhyRxfailureReason reason);
2554  void IncrementSuccessBitmap(uint32_t size);
2559  void IncrementFailureBitmap(uint32_t size);
2560 
2564  void ResetBitmaps();
2565 
2573  void SendAmpduWithThreeMpdus(double rxPowerDbm, uint32_t referencePacketSize);
2574 
2579  void CheckRxSuccessBitmapAmpdu1(uint8_t expected);
2584  void CheckRxSuccessBitmapAmpdu2(uint8_t expected);
2589  void CheckRxFailureBitmapAmpdu1(uint8_t expected);
2594  void CheckRxFailureBitmapAmpdu2(uint8_t expected);
2599  void CheckRxDroppedBitmapAmpdu1(uint8_t expected);
2604  void CheckRxDroppedBitmapAmpdu2(uint8_t expected);
2605 
2610  void CheckPhyState(WifiPhyState expectedState);
2611 
2612  Ptr<SpectrumWifiPhy> m_phy;
2613 
2614  uint8_t m_rxSuccessBitmapAmpdu1;
2615  uint8_t m_rxSuccessBitmapAmpdu2;
2616 
2617  uint8_t m_rxFailureBitmapAmpdu1;
2618  uint8_t m_rxFailureBitmapAmpdu2;
2619 
2620  uint8_t m_rxDroppedBitmapAmpdu1;
2621  uint8_t m_rxDroppedBitmapAmpdu2;
2622 
2623  uint64_t m_uid;
2624 };
2625 
2626 TestAmpduReception::TestAmpduReception()
2627  : TestCase("A-MPDU reception test"),
2628  m_rxSuccessBitmapAmpdu1(0),
2629  m_rxSuccessBitmapAmpdu2(0),
2630  m_rxFailureBitmapAmpdu1(0),
2631  m_rxFailureBitmapAmpdu2(0),
2632  m_rxDroppedBitmapAmpdu1(0),
2633  m_rxDroppedBitmapAmpdu2(0),
2634  m_uid(0)
2635 {
2636 }
2637 
2638 TestAmpduReception::~TestAmpduReception()
2639 {
2640  m_phy = nullptr;
2641 }
2642 
2643 void
2644 TestAmpduReception::ResetBitmaps()
2645 {
2646  m_rxSuccessBitmapAmpdu1 = 0;
2647  m_rxSuccessBitmapAmpdu2 = 0;
2648  m_rxFailureBitmapAmpdu1 = 0;
2649  m_rxFailureBitmapAmpdu2 = 0;
2650  m_rxDroppedBitmapAmpdu1 = 0;
2651  m_rxDroppedBitmapAmpdu2 = 0;
2652 }
2653 
2654 void
2655 TestAmpduReception::RxSuccess(Ptr<const WifiPsdu> psdu,
2656  RxSignalInfo rxSignalInfo,
2657  WifiTxVector txVector,
2658  std::vector<bool> statusPerMpdu)
2659 {
2660  NS_LOG_FUNCTION(this << *psdu << rxSignalInfo << txVector);
2661  if (statusPerMpdu.empty()) // wait for the whole A-MPDU
2662  {
2663  return;
2664  }
2665  NS_ABORT_MSG_IF(psdu->GetNMpdus() != statusPerMpdu.size(),
2666  "Should have one receive status per MPDU");
2667  auto rxOkForMpdu = statusPerMpdu.begin();
2668  for (auto mpdu = psdu->begin(); mpdu != psdu->end(); ++mpdu)
2669  {
2670  if (*rxOkForMpdu)
2671  {
2672  IncrementSuccessBitmap((*mpdu)->GetSize());
2673  }
2674  else
2675  {
2676  IncrementFailureBitmap((*mpdu)->GetSize());
2677  }
2678  ++rxOkForMpdu;
2679  }
2680 }
2681 
2682 void
2683 TestAmpduReception::IncrementSuccessBitmap(uint32_t size)
2684 {
2685  if (size == 1030) // A-MPDU 1 - MPDU #1
2686  {
2687  m_rxSuccessBitmapAmpdu1 |= 1;
2688  }
2689  else if (size == 1130) // A-MPDU 1 - MPDU #2
2690  {
2691  m_rxSuccessBitmapAmpdu1 |= (1 << 1);
2692  }
2693  else if (size == 1230) // A-MPDU 1 - MPDU #3
2694  {
2695  m_rxSuccessBitmapAmpdu1 |= (1 << 2);
2696  }
2697  else if (size == 1330) // A-MPDU 2 - MPDU #1
2698  {
2699  m_rxSuccessBitmapAmpdu2 |= 1;
2700  }
2701  else if (size == 1430) // A-MPDU 2 - MPDU #2
2702  {
2703  m_rxSuccessBitmapAmpdu2 |= (1 << 1);
2704  }
2705  else if (size == 1530) // A-MPDU 2 - MPDU #3
2706  {
2707  m_rxSuccessBitmapAmpdu2 |= (1 << 2);
2708  }
2709 }
2710 
2711 void
2712 TestAmpduReception::RxFailure(Ptr<const WifiPsdu> psdu)
2713 {
2714  NS_LOG_FUNCTION(this << *psdu);
2715  for (auto mpdu = psdu->begin(); mpdu != psdu->end(); ++mpdu)
2716  {
2717  IncrementFailureBitmap((*mpdu)->GetSize());
2718  }
2719 }
2720 
2721 void
2722 TestAmpduReception::IncrementFailureBitmap(uint32_t size)
2723 {
2724  if (size == 1030) // A-MPDU 1 - MPDU #1
2725  {
2726  m_rxFailureBitmapAmpdu1 |= 1;
2727  }
2728  else if (size == 1130) // A-MPDU 1 - MPDU #2
2729  {
2730  m_rxFailureBitmapAmpdu1 |= (1 << 1);
2731  }
2732  else if (size == 1230) // A-MPDU 1 - MPDU #3
2733  {
2734  m_rxFailureBitmapAmpdu1 |= (1 << 2);
2735  }
2736  else if (size == 1330) // A-MPDU 2 - MPDU #1
2737  {
2738  m_rxFailureBitmapAmpdu2 |= 1;
2739  }
2740  else if (size == 1430) // A-MPDU 2 - MPDU #2
2741  {
2742  m_rxFailureBitmapAmpdu2 |= (1 << 1);
2743  }
2744  else if (size == 1530) // A-MPDU 2 - MPDU #3
2745  {
2746  m_rxFailureBitmapAmpdu2 |= (1 << 2);
2747  }
2748 }
2749 
2750 void
2751 TestAmpduReception::RxDropped(Ptr<const Packet> p, WifiPhyRxfailureReason reason)
2752 {
2753  NS_LOG_FUNCTION(this << p << reason);
2754  if (p->GetSize() == 1030) // A-MPDU 1 - MPDU #1
2755  {
2756  m_rxDroppedBitmapAmpdu1 |= 1;
2757  }
2758  else if (p->GetSize() == 1130) // A-MPDU 1 - MPDU #2
2759  {
2760  m_rxDroppedBitmapAmpdu1 |= (1 << 1);
2761  }
2762  else if (p->GetSize() == 1230) // A-MPDU 1 - MPDU #3
2763  {
2764  m_rxDroppedBitmapAmpdu1 |= (1 << 2);
2765  }
2766  else if (p->GetSize() == 1330) // A-MPDU 2 - MPDU #1
2767  {
2768  m_rxDroppedBitmapAmpdu2 |= 1;
2769  }
2770  else if (p->GetSize() == 1430) // A-MPDU 2 - MPDU #2
2771  {
2772  m_rxDroppedBitmapAmpdu2 |= (1 << 1);
2773  }
2774  else if (p->GetSize() == 1530) // A-MPDU 2 - MPDU #3
2775  {
2776  m_rxDroppedBitmapAmpdu2 |= (1 << 2);
2777  }
2778 }
2779 
2780 void
2781 TestAmpduReception::CheckRxSuccessBitmapAmpdu1(uint8_t expected)
2782 {
2783  NS_TEST_ASSERT_MSG_EQ(m_rxSuccessBitmapAmpdu1,
2784  expected,
2785  "RX success bitmap for A-MPDU 1 is not as expected");
2786 }
2787 
2788 void
2789 TestAmpduReception::CheckRxSuccessBitmapAmpdu2(uint8_t expected)
2790 {
2791  NS_TEST_ASSERT_MSG_EQ(m_rxSuccessBitmapAmpdu2,
2792  expected,
2793  "RX success bitmap for A-MPDU 2 is not as expected");
2794 }
2795 
2796 void
2797 TestAmpduReception::CheckRxFailureBitmapAmpdu1(uint8_t expected)
2798 {
2799  NS_TEST_ASSERT_MSG_EQ(m_rxFailureBitmapAmpdu1,
2800  expected,
2801  "RX failure bitmap for A-MPDU 1 is not as expected");
2802 }
2803 
2804 void
2805 TestAmpduReception::CheckRxFailureBitmapAmpdu2(uint8_t expected)
2806 {
2807  NS_TEST_ASSERT_MSG_EQ(m_rxFailureBitmapAmpdu2,
2808  expected,
2809  "RX failure bitmap for A-MPDU 2 is not as expected");
2810 }
2811 
2812 void
2813 TestAmpduReception::CheckRxDroppedBitmapAmpdu1(uint8_t expected)
2814 {
2815  NS_TEST_ASSERT_MSG_EQ(m_rxDroppedBitmapAmpdu1,
2816  expected,
2817  "RX dropped bitmap for A-MPDU 1 is not as expected");
2818 }
2819 
2820 void
2821 TestAmpduReception::CheckRxDroppedBitmapAmpdu2(uint8_t expected)
2822 {
2823  NS_TEST_ASSERT_MSG_EQ(m_rxDroppedBitmapAmpdu2,
2824  expected,
2825  "RX dropped bitmap for A-MPDU 2 is not as expected");
2826 }
2827 
2828 void
2829 TestAmpduReception::CheckPhyState(WifiPhyState expectedState)
2830 {
2831  WifiPhyState currentState;
2832  PointerValue ptr;
2833  m_phy->GetAttribute("State", ptr);
2834  Ptr<WifiPhyStateHelper> state = DynamicCast<WifiPhyStateHelper>(ptr.Get<WifiPhyStateHelper>());
2835  currentState = state->GetState();
2836  NS_TEST_ASSERT_MSG_EQ(currentState,
2837  expectedState,
2838  "PHY State " << currentState << " does not match expected state "
2839  << expectedState << " at " << Simulator::Now());
2840 }
2841 
2842 void
2843 TestAmpduReception::SendAmpduWithThreeMpdus(double rxPowerDbm, uint32_t referencePacketSize)
2844 {
2845  WifiTxVector txVector =
2846  WifiTxVector(HePhy::GetHeMcs0(), 0, WIFI_PREAMBLE_HE_SU, 800, 1, 1, 0, 20, true);
2847 
2848  WifiMacHeader hdr;
2849  hdr.SetType(WIFI_MAC_QOSDATA);
2850  hdr.SetQosTid(0);
2851 
2852  std::vector<Ptr<WifiMpdu>> mpduList;
2853  for (size_t i = 0; i < 3; ++i)
2854  {
2855  Ptr<Packet> p = Create<Packet>(referencePacketSize + i * 100);
2856  mpduList.push_back(Create<WifiMpdu>(p, hdr));
2857  }
2858  Ptr<WifiPsdu> psdu = Create<WifiPsdu>(mpduList);
2859 
2860  Time txDuration = m_phy->CalculateTxDuration(psdu->GetSize(), txVector, m_phy->GetPhyBand());
2861 
2862  Ptr<WifiPpdu> ppdu =
2863  Create<HePpdu>(psdu, txVector, FREQUENCY, txDuration, WIFI_PHY_BAND_5GHZ, m_uid++);
2864 
2865  Ptr<SpectrumValue> txPowerSpectrum =
2866  WifiSpectrumValueHelper::CreateHeOfdmTxPowerSpectralDensity(FREQUENCY,
2867  CHANNEL_WIDTH,
2868  DbmToW(rxPowerDbm),
2869  GUARD_WIDTH);
2870 
2871  Ptr<WifiSpectrumSignalParameters> txParams = Create<WifiSpectrumSignalParameters>();
2872  txParams->psd = txPowerSpectrum;
2873  txParams->txPhy = nullptr;
2874  txParams->duration = txDuration;
2875  txParams->ppdu = ppdu;
2876  txParams->txWidth = CHANNEL_WIDTH;
2877 
2878  m_phy->StartRx(txParams);
2879 }
2880 
2881 void
2882 TestAmpduReception::DoSetup()
2883 {
2884  m_phy = CreateObject<SpectrumWifiPhy>();
2885  m_phy->ConfigureStandard(WIFI_STANDARD_80211ax);
2886  Ptr<InterferenceHelper> interferenceHelper = CreateObject<InterferenceHelper>();
2887  m_phy->SetInterferenceHelper(interferenceHelper);
2888  Ptr<ErrorRateModel> error = CreateObject<NistErrorRateModel>();
2889  m_phy->SetErrorRateModel(error);
2890  m_phy->SetOperatingChannel(WifiPhy::ChannelTuple{CHANNEL_NUMBER, 0, WIFI_PHY_BAND_5GHZ, 0});
2891 
2892  m_phy->SetReceiveOkCallback(MakeCallback(&TestAmpduReception::RxSuccess, this));
2893  m_phy->SetReceiveErrorCallback(MakeCallback(&TestAmpduReception::RxFailure, this));
2894  m_phy->TraceConnectWithoutContext("PhyRxDrop",
2895  MakeCallback(&TestAmpduReception::RxDropped, this));
2896 
2897  Ptr<ThresholdPreambleDetectionModel> preambleDetectionModel =
2898  CreateObject<ThresholdPreambleDetectionModel>();
2899  preambleDetectionModel->SetAttribute("Threshold", DoubleValue(2));
2900  m_phy->SetPreambleDetectionModel(preambleDetectionModel);
2901 
2902  Ptr<SimpleFrameCaptureModel> frameCaptureModel = CreateObject<SimpleFrameCaptureModel>();
2903  frameCaptureModel->SetAttribute("Margin", DoubleValue(5));
2904  frameCaptureModel->SetAttribute("CaptureWindow", TimeValue(MicroSeconds(16)));
2905  m_phy->SetFrameCaptureModel(frameCaptureModel);
2906 }
2907 
2908 void
2909 TestAmpduReception::DoTeardown()
2910 {
2911  m_phy->Dispose();
2912  m_phy = nullptr;
2913 }
2914 
2915 void
2916 TestAmpduReception::DoRun()
2917 {
2918  RngSeedManager::SetSeed(1);
2919  RngSeedManager::SetRun(2);
2920  int64_t streamNumber = 1;
2921  double rxPowerDbm = -30;
2922  m_phy->AssignStreams(streamNumber);
2923 
2925  // CASE 1: receive two A-MPDUs (containing each 3 MPDUs) where the first A-MPDU is received with
2926  // power under RX sensitivity. The second A-MPDU is received 2 microseconds after the first
2927  // A-MPDU (i.e. during preamble detection).
2929 
2930  // A-MPDU 1
2931  Simulator::Schedule(Seconds(1.0),
2932  &TestAmpduReception::SendAmpduWithThreeMpdus,
2933  this,
2934  rxPowerDbm - 100,
2935  1000);
2936 
2937  // A-MPDU 2
2938  Simulator::Schedule(Seconds(1.0) + MicroSeconds(2),
2939  &TestAmpduReception::SendAmpduWithThreeMpdus,
2940  this,
2941  rxPowerDbm,
2942  1300);
2943 
2944  // All MPDUs of A-MPDU 1 should have been ignored.
2945  Simulator::Schedule(Seconds(1.1),
2946  &TestAmpduReception::CheckRxSuccessBitmapAmpdu1,
2947  this,
2948  0b00000000);
2949  Simulator::Schedule(Seconds(1.1),
2950  &TestAmpduReception::CheckRxFailureBitmapAmpdu1,
2951  this,
2952  0b00000000);
2953  Simulator::Schedule(Seconds(1.1),
2954  &TestAmpduReception::CheckRxDroppedBitmapAmpdu1,
2955  this,
2956  0b00000000);
2957 
2958  // All MPDUs of A-MPDU 2 should have been successfully received.
2959  Simulator::Schedule(Seconds(1.1),
2960  &TestAmpduReception::CheckRxSuccessBitmapAmpdu2,
2961  this,
2962  0b00000111);
2963  Simulator::Schedule(Seconds(1.1),
2964  &TestAmpduReception::CheckRxFailureBitmapAmpdu2,
2965  this,
2966  0b00000000);
2967  Simulator::Schedule(Seconds(1.1),
2968  &TestAmpduReception::CheckRxDroppedBitmapAmpdu2,
2969  this,
2970  0b00000000);
2971 
2972  Simulator::Schedule(Seconds(1.2), &TestAmpduReception::ResetBitmaps, this);
2973 
2975  // CASE 2: receive two A-MPDUs (containing each 3 MPDUs) where the second A-MPDU is received
2976  // with power under RX sensitivity. The second A-MPDU is received 2 microseconds after the first
2977  // A-MPDU (i.e. during preamble detection).
2979 
2980  // A-MPDU 1
2981  Simulator::Schedule(Seconds(2.0),
2982  &TestAmpduReception::SendAmpduWithThreeMpdus,
2983  this,
2984  rxPowerDbm,
2985  1000);
2986 
2987  // A-MPDU 2
2988  Simulator::Schedule(Seconds(2.0) + MicroSeconds(2),
2989  &TestAmpduReception::SendAmpduWithThreeMpdus,
2990  this,
2991  rxPowerDbm - 100,
2992  1300);
2993 
2994  // All MPDUs of A-MPDU 1 should have been received.
2995  Simulator::Schedule(Seconds(2.1),
2996  &TestAmpduReception::CheckRxSuccessBitmapAmpdu1,
2997  this,
2998  0b00000111);
2999  Simulator::Schedule(Seconds(2.1),
3000  &TestAmpduReception::CheckRxFailureBitmapAmpdu1,
3001  this,
3002  0b00000000);
3003  Simulator::Schedule(Seconds(2.1),
3004  &TestAmpduReception::CheckRxDroppedBitmapAmpdu1,
3005  this,
3006  0b00000000);
3007 
3008  // All MPDUs of A-MPDU 2 should have been ignored.
3009  Simulator::Schedule(Seconds(2.1),
3010  &TestAmpduReception::CheckRxSuccessBitmapAmpdu2,
3011  this,
3012  0b00000000);
3013  Simulator::Schedule(Seconds(2.1),
3014  &TestAmpduReception::CheckRxFailureBitmapAmpdu2,
3015  this,
3016  0b00000000);
3017  Simulator::Schedule(Seconds(2.1),
3018  &TestAmpduReception::CheckRxDroppedBitmapAmpdu2,
3019  this,
3020  0b00000000);
3021 
3022  Simulator::Schedule(Seconds(2.2), &TestAmpduReception::ResetBitmaps, this);
3023 
3025  // CASE 3: receive two A-MPDUs (containing each 3 MPDUs) where the first A-MPDU is received with
3026  // power under RX sensitivity. The second A-MPDU is received 10 microseconds after the first
3027  // A-MPDU (i.e. during the frame capture window).
3029 
3030  // A-MPDU 1
3031  Simulator::Schedule(Seconds(3.0),
3032  &TestAmpduReception::SendAmpduWithThreeMpdus,
3033  this,
3034  rxPowerDbm - 100,
3035  1000);
3036 
3037  // A-MPDU 2
3038  Simulator::Schedule(Seconds(3.0) + MicroSeconds(10),
3039  &TestAmpduReception::SendAmpduWithThreeMpdus,
3040  this,
3041  rxPowerDbm,
3042  1300);
3043 
3044  // All MPDUs of A-MPDU 1 should have been ignored.
3045  Simulator::Schedule(Seconds(3.1),
3046  &TestAmpduReception::CheckRxSuccessBitmapAmpdu1,
3047  this,
3048  0b00000000);
3049  Simulator::Schedule(Seconds(3.1),
3050  &TestAmpduReception::CheckRxFailureBitmapAmpdu1,
3051  this,
3052  0b00000000);
3053  Simulator::Schedule(Seconds(3.1),
3054  &TestAmpduReception::CheckRxDroppedBitmapAmpdu1,
3055  this,
3056  0b00000000);
3057 
3058  // All MPDUs of A-MPDU 2 should have been successfully received.
3059  Simulator::Schedule(Seconds(3.1),
3060  &TestAmpduReception::CheckRxSuccessBitmapAmpdu2,
3061  this,
3062  0b00000111);
3063  Simulator::Schedule(Seconds(3.1),
3064  &TestAmpduReception::CheckRxFailureBitmapAmpdu2,
3065  this,
3066  0b00000000);
3067  Simulator::Schedule(Seconds(3.1),
3068  &TestAmpduReception::CheckRxDroppedBitmapAmpdu2,
3069  this,
3070  0b00000000);
3071 
3072  Simulator::Schedule(Seconds(3.2), &TestAmpduReception::ResetBitmaps, this);
3073 
3075  // CASE 4: receive two A-MPDUs (containing each 3 MPDUs) where the second A-MPDU is received
3076  // with power under RX sensitivity. The second A-MPDU is received 10 microseconds after the
3077  // first A-MPDU (i.e. during the frame capture window).
3079 
3080  // A-MPDU 1
3081  Simulator::Schedule(Seconds(4.0),
3082  &TestAmpduReception::SendAmpduWithThreeMpdus,
3083  this,
3084  rxPowerDbm,
3085  1000);
3086 
3087  // A-MPDU 2
3088  Simulator::Schedule(Seconds(4.0) + MicroSeconds(10),
3089  &TestAmpduReception::SendAmpduWithThreeMpdus,
3090  this,
3091  rxPowerDbm - 100,
3092  1300);
3093 
3094  // All MPDUs of A-MPDU 1 should have been received.
3095  Simulator::Schedule(Seconds(4.1),
3096  &TestAmpduReception::CheckRxSuccessBitmapAmpdu1,
3097  this,
3098  0b00000111);
3099  Simulator::Schedule(Seconds(4.1),
3100  &TestAmpduReception::CheckRxFailureBitmapAmpdu1,
3101  this,
3102  0b00000000);
3103  Simulator::Schedule(Seconds(4.1),
3104  &TestAmpduReception::CheckRxDroppedBitmapAmpdu1,
3105  this,
3106  0b00000000);
3107 
3108  // All MPDUs of A-MPDU 2 should have been ignored.
3109  Simulator::Schedule(Seconds(4.1),
3110  &TestAmpduReception::CheckRxSuccessBitmapAmpdu2,
3111  this,
3112  0b00000000);
3113  Simulator::Schedule(Seconds(4.1),
3114  &TestAmpduReception::CheckRxFailureBitmapAmpdu2,
3115  this,
3116  0b00000000);
3117  Simulator::Schedule(Seconds(4.1),
3118  &TestAmpduReception::CheckRxDroppedBitmapAmpdu2,
3119  this,
3120  0b00000000);
3121 
3122  Simulator::Schedule(Seconds(4.2), &TestAmpduReception::ResetBitmaps, this);
3123 
3125  // CASE 5: receive two A-MPDUs (containing each 3 MPDUs) where the first A-MPDU is received with
3126  // power under RX sensitivity. The second A-MPDU is received 100 microseconds after the first
3127  // A-MPDU (i.e. after the frame capture window, during the payload of MPDU #1).
3129 
3130  // A-MPDU 1
3131  Simulator::Schedule(Seconds(5.0),
3132  &TestAmpduReception::SendAmpduWithThreeMpdus,
3133  this,
3134  rxPowerDbm - 100,
3135  1000);
3136 
3137  // A-MPDU 2
3138  Simulator::Schedule(Seconds(5.0) + MicroSeconds(100),
3139  &TestAmpduReception::SendAmpduWithThreeMpdus,
3140  this,
3141  rxPowerDbm,
3142  1300);
3143 
3144  // All MPDUs of A-MPDU 1 should have been ignored.
3145  Simulator::Schedule(Seconds(5.1),
3146  &TestAmpduReception::CheckRxSuccessBitmapAmpdu1,
3147  this,
3148  0b00000000);
3149  Simulator::Schedule(Seconds(5.1),
3150  &TestAmpduReception::CheckRxFailureBitmapAmpdu1,
3151  this,
3152  0b00000000);
3153  Simulator::Schedule(Seconds(5.1),
3154  &TestAmpduReception::CheckRxDroppedBitmapAmpdu1,
3155  this,
3156  0b00000000);
3157 
3158  // All MPDUs of A-MPDU 2 should have been successfully received.
3159  Simulator::Schedule(Seconds(5.1),
3160  &TestAmpduReception::CheckRxSuccessBitmapAmpdu2,
3161  this,
3162  0b00000111);
3163  Simulator::Schedule(Seconds(5.1),
3164  &TestAmpduReception::CheckRxFailureBitmapAmpdu2,
3165  this,
3166  0b00000000);
3167  Simulator::Schedule(Seconds(5.1),
3168  &TestAmpduReception::CheckRxDroppedBitmapAmpdu2,
3169  this,
3170  0b00000000);
3171 
3172  Simulator::Schedule(Seconds(5.2), &TestAmpduReception::ResetBitmaps, this);
3173 
3175  // CASE 6: receive two A-MPDUs (containing each 3 MPDUs) where the second A-MPDU is received
3176  // with power under RX sensitivity. The second A-MPDU is received 100 microseconds after the
3177  // first A-MPDU (i.e. after the frame capture window, during the payload of MPDU #1).
3179 
3180  // A-MPDU 1
3181  Simulator::Schedule(Seconds(6.0),
3182  &TestAmpduReception::SendAmpduWithThreeMpdus,
3183  this,
3184  rxPowerDbm,
3185  1000);
3186 
3187  // A-MPDU 2
3188  Simulator::Schedule(Seconds(6.0) + MicroSeconds(100),
3189  &TestAmpduReception::SendAmpduWithThreeMpdus,
3190  this,
3191  rxPowerDbm - 100,
3192  1300);
3193 
3194  // All MPDUs of A-MPDU 1 should have been received.
3195  Simulator::Schedule(Seconds(6.1),
3196  &TestAmpduReception::CheckRxSuccessBitmapAmpdu1,
3197  this,
3198  0b00000111);
3199  Simulator::Schedule(Seconds(6.1),
3200  &TestAmpduReception::CheckRxFailureBitmapAmpdu1,
3201  this,
3202  0b00000000);
3203  Simulator::Schedule(Seconds(6.1),
3204  &TestAmpduReception::CheckRxDroppedBitmapAmpdu1,
3205  this,
3206  0b00000000);
3207 
3208  // All MPDUs of A-MPDU 2 should have been ignored.
3209  Simulator::Schedule(Seconds(6.1),
3210  &TestAmpduReception::CheckRxSuccessBitmapAmpdu2,
3211  this,
3212  0b00000000);
3213  Simulator::Schedule(Seconds(6.1),
3214  &TestAmpduReception::CheckRxFailureBitmapAmpdu2,
3215  this,
3216  0b00000000);
3217  Simulator::Schedule(Seconds(6.1),
3218  &TestAmpduReception::CheckRxDroppedBitmapAmpdu2,
3219  this,
3220  0b00000000);
3221 
3222  Simulator::Schedule(Seconds(6.2), &TestAmpduReception::ResetBitmaps, this);
3223 
3225  // CASE 7: receive two A-MPDUs (containing each 3 MPDUs) where the first A-MPDU is received with
3226  // power under RX sensitivity. The second A-MPDU is received during the payload of MPDU #2.
3228 
3229  // A-MPDU 1
3230  Simulator::Schedule(Seconds(7.0),
3231  &TestAmpduReception::SendAmpduWithThreeMpdus,
3232  this,
3233  rxPowerDbm - 100,
3234  1000);
3235 
3236  // A-MPDU 2
3237  Simulator::Schedule(Seconds(7.0) + NanoSeconds(1100000),
3238  &TestAmpduReception::SendAmpduWithThreeMpdus,
3239  this,
3240  rxPowerDbm,
3241  1300);
3242 
3243  // All MPDUs of A-MPDU 1 should have been ignored.
3244  Simulator::Schedule(Seconds(7.1),
3245  &TestAmpduReception::CheckRxSuccessBitmapAmpdu1,
3246  this,
3247  0b00000000);
3248  Simulator::Schedule(Seconds(7.1),
3249  &TestAmpduReception::CheckRxFailureBitmapAmpdu1,
3250  this,
3251  0b00000000);
3252  Simulator::Schedule(Seconds(7.1),
3253  &TestAmpduReception::CheckRxDroppedBitmapAmpdu1,
3254  this,
3255  0b00000000);
3256 
3257  // All MPDUs of A-MPDU 2 should have been successfully received.
3258  Simulator::Schedule(Seconds(7.1),
3259  &TestAmpduReception::CheckRxSuccessBitmapAmpdu2,
3260  this,
3261  0b00000111);
3262  Simulator::Schedule(Seconds(7.1),
3263  &TestAmpduReception::CheckRxFailureBitmapAmpdu2,
3264  this,
3265  0b00000000);
3266  Simulator::Schedule(Seconds(7.1),
3267  &TestAmpduReception::CheckRxDroppedBitmapAmpdu2,
3268  this,
3269  0b00000000);
3270 
3271  Simulator::Schedule(Seconds(7.2), &TestAmpduReception::ResetBitmaps, this);
3272 
3274  // CASE 8: receive two A-MPDUs (containing each 3 MPDUs) where the second A-MPDU is received
3275  // with power under RX sensitivity. The second A-MPDU is received during the payload of MPDU #2.
3277 
3278  // A-MPDU 1
3279  Simulator::Schedule(Seconds(8.0),
3280  &TestAmpduReception::SendAmpduWithThreeMpdus,
3281  this,
3282  rxPowerDbm,
3283  1000);
3284 
3285  // A-MPDU 2
3286  Simulator::Schedule(Seconds(8.0) + NanoSeconds(1100000),
3287  &TestAmpduReception::SendAmpduWithThreeMpdus,
3288  this,
3289  rxPowerDbm - 100,
3290  1300);
3291 
3292  // All MPDUs of A-MPDU 1 should have been received.
3293  Simulator::Schedule(Seconds(8.1),
3294  &TestAmpduReception::CheckRxSuccessBitmapAmpdu1,
3295  this,
3296  0b00000111);
3297  Simulator::Schedule(Seconds(8.1),
3298  &TestAmpduReception::CheckRxFailureBitmapAmpdu1,
3299  this,
3300  0b00000000);
3301  Simulator::Schedule(Seconds(8.1),
3302  &TestAmpduReception::CheckRxDroppedBitmapAmpdu1,
3303  this,
3304  0b00000000);
3305 
3306  // All MPDUs of A-MPDU 2 should have been ignored.
3307  Simulator::Schedule(Seconds(8.1),
3308  &TestAmpduReception::CheckRxSuccessBitmapAmpdu2,
3309  this,
3310  0b00000000);
3311  Simulator::Schedule(Seconds(8.1),
3312  &TestAmpduReception::CheckRxFailureBitmapAmpdu2,
3313  this,
3314  0b00000000);
3315  Simulator::Schedule(Seconds(8.1),
3316  &TestAmpduReception::CheckRxDroppedBitmapAmpdu2,
3317  this,
3318  0b00000000);
3319 
3320  Simulator::Schedule(Seconds(8.2), &TestAmpduReception::ResetBitmaps, this);
3321 
3323  // CASE 9: receive two A-MPDUs (containing each 3 MPDUs) with the second A-MPDU having a power 3
3324  // dB higher. The second A-MPDU is received 2 microseconds after the first A-MPDU (i.e. during
3325  // preamble detection).
3327 
3328  // A-MPDU 1
3329  Simulator::Schedule(Seconds(9.0),
3330  &TestAmpduReception::SendAmpduWithThreeMpdus,
3331  this,
3332  rxPowerDbm,
3333  1000);
3334 
3335  // A-MPDU 2
3336  Simulator::Schedule(Seconds(9.0) + MicroSeconds(2),
3337  &TestAmpduReception::SendAmpduWithThreeMpdus,
3338  this,
3339  rxPowerDbm + 3,
3340  1300);
3341 
3342  // All MPDUs of A-MPDU 1 should have been dropped.
3343  Simulator::Schedule(Seconds(9.1),
3344  &TestAmpduReception::CheckRxSuccessBitmapAmpdu1,
3345  this,
3346  0b00000000);
3347  Simulator::Schedule(Seconds(9.1),
3348  &TestAmpduReception::CheckRxFailureBitmapAmpdu1,
3349  this,
3350  0b00000000);
3351  Simulator::Schedule(Seconds(9.1),
3352  &TestAmpduReception::CheckRxDroppedBitmapAmpdu1,
3353  this,
3354  0b00000111);
3355 
3356  // All MPDUs of A-MPDU 2 should have been received with errors.
3357  Simulator::Schedule(Seconds(9.1),
3358  &TestAmpduReception::CheckRxSuccessBitmapAmpdu2,
3359  this,
3360  0b00000000);
3361  Simulator::Schedule(Seconds(9.1),
3362  &TestAmpduReception::CheckRxFailureBitmapAmpdu2,
3363  this,
3364  0b00000111);
3365  Simulator::Schedule(Seconds(9.1),
3366  &TestAmpduReception::CheckRxDroppedBitmapAmpdu2,
3367  this,
3368  0b00000000);
3369 
3370  Simulator::Schedule(Seconds(9.2), &TestAmpduReception::ResetBitmaps, this);
3371 
3373  // CASE 10: receive two A-MPDUs (containing each 3 MPDUs) with the same power.
3374  // The second A-MPDU is received 2 microseconds after the first A-MPDU (i.e. during preamble
3375  // detection).
3377 
3378  // A-MPDU 1
3379  Simulator::Schedule(Seconds(10.0),
3380  &TestAmpduReception::SendAmpduWithThreeMpdus,
3381  this,
3382  rxPowerDbm,
3383  1000);
3384 
3385  // A-MPDU 2
3386  Simulator::Schedule(Seconds(10.0) + MicroSeconds(2),
3387  &TestAmpduReception::SendAmpduWithThreeMpdus,
3388  this,
3389  rxPowerDbm,
3390  1300);
3391 
3392  // All MPDUs of A-MPDU 1 should have been dropped (preamble detection failed).
3393  Simulator::Schedule(Seconds(10.1),
3394  &TestAmpduReception::CheckRxSuccessBitmapAmpdu1,
3395  this,
3396  0b00000000);
3397  Simulator::Schedule(Seconds(10.1),
3398  &TestAmpduReception::CheckRxFailureBitmapAmpdu1,
3399  this,
3400  0b00000000);
3401  Simulator::Schedule(Seconds(10.1),
3402  &TestAmpduReception::CheckRxDroppedBitmapAmpdu1,
3403  this,
3404  0b00000111);
3405 
3406  // All MPDUs of A-MPDU 2 should have been dropped as well.
3407  Simulator::Schedule(Seconds(10.1),
3408  &TestAmpduReception::CheckRxSuccessBitmapAmpdu2,
3409  this,
3410  0b00000000);
3411  Simulator::Schedule(Seconds(10.1),
3412  &TestAmpduReception::CheckRxFailureBitmapAmpdu2,
3413  this,
3414  0b00000000);
3415  Simulator::Schedule(Seconds(10.1),
3416  &TestAmpduReception::CheckRxDroppedBitmapAmpdu2,
3417  this,
3418  0b00000111);
3419 
3420  Simulator::Schedule(Seconds(10.2), &TestAmpduReception::ResetBitmaps, this);
3421 
3423  // CASE 11: receive two A-MPDUs (containing each 3 MPDUs) with the first A-MPDU having a power 3
3424  // dB higher. The second A-MPDU is received 2 microseconds after the first A-MPDU (i.e. during
3425  // preamble detection).
3427 
3428  // A-MPDU 1
3429  Simulator::Schedule(Seconds(11.0),
3430  &TestAmpduReception::SendAmpduWithThreeMpdus,
3431  this,
3432  rxPowerDbm + 3,
3433  1000);
3434 
3435  // A-MPDU 2
3436  Simulator::Schedule(Seconds(11.0) + MicroSeconds(2),
3437  &TestAmpduReception::SendAmpduWithThreeMpdus,
3438  this,
3439  rxPowerDbm,
3440  1300);
3441 
3442  // All MPDUs of A-MPDU 1 should have been received with errors.
3443  Simulator::Schedule(Seconds(11.1),
3444  &TestAmpduReception::CheckRxSuccessBitmapAmpdu1,
3445  this,
3446  0b00000000);
3447  Simulator::Schedule(Seconds(11.1),
3448  &TestAmpduReception::CheckRxFailureBitmapAmpdu1,
3449  this,
3450  0b00000111);
3451  Simulator::Schedule(Seconds(11.1),
3452  &TestAmpduReception::CheckRxDroppedBitmapAmpdu1,
3453  this,
3454  0b00000000);
3455 
3456  // All MPDUs of A-MPDU 2 should have been dropped.
3457  Simulator::Schedule(Seconds(11.1),
3458  &TestAmpduReception::CheckRxSuccessBitmapAmpdu2,
3459  this,
3460  0b00000000);
3461  Simulator::Schedule(Seconds(11.1),
3462  &TestAmpduReception::CheckRxFailureBitmapAmpdu2,
3463  this,
3464  0b00000000);
3465  Simulator::Schedule(Seconds(11.1),
3466  &TestAmpduReception::CheckRxDroppedBitmapAmpdu2,
3467  this,
3468  0b00000111);
3469 
3470  Simulator::Schedule(Seconds(11.2), &TestAmpduReception::ResetBitmaps, this);
3471 
3473  // CASE 12: receive two A-MPDUs (containing each 3 MPDUs) with the second A-MPDU having a power
3474  // 3 dB higher. The second A-MPDU is received 10 microseconds after the first A-MPDU (i.e.
3475  // during the frame capture window).
3477 
3478  // A-MPDU 1
3479  Simulator::Schedule(Seconds(12.0),
3480  &TestAmpduReception::SendAmpduWithThreeMpdus,
3481  this,
3482  rxPowerDbm,
3483  1000);
3484 
3485  // A-MPDU 2
3486  Simulator::Schedule(Seconds(12.0) + MicroSeconds(10),
3487  &TestAmpduReception::SendAmpduWithThreeMpdus,
3488  this,
3489  rxPowerDbm + 3,
3490  1300);
3491 
3492  // All MPDUs of A-MPDU 1 should have been received with errors (PHY header reception failed and
3493  // thus incorrect decoding of payload).
3494  Simulator::Schedule(Seconds(12.1),
3495  &TestAmpduReception::CheckRxSuccessBitmapAmpdu1,
3496  this,
3497  0b00000000);
3498  Simulator::Schedule(Seconds(12.1),
3499  &TestAmpduReception::CheckRxFailureBitmapAmpdu1,
3500  this,
3501  0b00000000);
3502  Simulator::Schedule(Seconds(12.1),
3503  &TestAmpduReception::CheckRxDroppedBitmapAmpdu1,
3504  this,
3505  0b00000111);
3506 
3507  // All MPDUs of A-MPDU 2 should have been dropped (even though TX power is higher, it is not
3508  // high enough to get the PHY reception switched)
3509  Simulator::Schedule(Seconds(12.1),
3510  &TestAmpduReception::CheckRxSuccessBitmapAmpdu2,
3511  this,
3512  0b00000000);
3513  Simulator::Schedule(Seconds(12.1),
3514  &TestAmpduReception::CheckRxFailureBitmapAmpdu2,
3515  this,
3516  0b00000000);
3517  Simulator::Schedule(Seconds(12.1),
3518  &TestAmpduReception::CheckRxDroppedBitmapAmpdu2,
3519  this,
3520  0b00000111);
3521 
3522  Simulator::Schedule(Seconds(12.2), &TestAmpduReception::ResetBitmaps, this);
3523 
3525  // CASE 13: receive two A-MPDUs (containing each 3 MPDUs) with the same power.
3526  // The second A-MPDU is received 10 microseconds after the first A-MPDU (i.e. during the frame
3527  // capture window).
3529 
3530  // A-MPDU 1
3531  Simulator::Schedule(Seconds(13.0),
3532  &TestAmpduReception::SendAmpduWithThreeMpdus,
3533  this,
3534  rxPowerDbm,
3535  1000);
3536 
3537  // A-MPDU 2
3538  Simulator::Schedule(Seconds(13.0) + MicroSeconds(10),
3539  &TestAmpduReception::SendAmpduWithThreeMpdus,
3540  this,
3541  rxPowerDbm,
3542  1300);
3543 
3544  // All MPDUs of A-MPDU 1 should have been received with errors (PHY header reception failed and
3545  // thus incorrect decoding of payload).
3546  Simulator::Schedule(Seconds(13.1),
3547  &TestAmpduReception::CheckRxSuccessBitmapAmpdu1,
3548  this,
3549  0b00000000);
3550  Simulator::Schedule(Seconds(13.1),
3551  &TestAmpduReception::CheckRxFailureBitmapAmpdu1,
3552  this,
3553  0b00000000);
3554  Simulator::Schedule(Seconds(13.1),
3555  &TestAmpduReception::CheckRxDroppedBitmapAmpdu1,
3556  this,
3557  0b00000111);
3558 
3559  // All MPDUs of A-MPDU 2 should have been dropped as well.
3560  Simulator::Schedule(Seconds(13.1),
3561  &TestAmpduReception::CheckRxSuccessBitmapAmpdu2,
3562  this,
3563  0b00000000);
3564  Simulator::Schedule(Seconds(13.1),
3565  &TestAmpduReception::CheckRxFailureBitmapAmpdu2,
3566  this,
3567  0b00000000);
3568  Simulator::Schedule(Seconds(13.1),
3569  &TestAmpduReception::CheckRxDroppedBitmapAmpdu2,
3570  this,
3571  0b00000111);
3572 
3573  Simulator::Schedule(Seconds(13.2), &TestAmpduReception::ResetBitmaps, this);
3574 
3576  // CASE 14: receive two A-MPDUs (containing each 3 MPDUs) with the first A-MPDU having a power 3
3577  // dB higher. The second A-MPDU is received 10 microseconds after the first A-MPDU (i.e. during
3578  // the frame capture window).
3580 
3581  // A-MPDU 1
3582  Simulator::Schedule(Seconds(14.0),
3583  &TestAmpduReception::SendAmpduWithThreeMpdus,
3584  this,
3585  rxPowerDbm + 3,
3586  1000);
3587 
3588  // A-MPDU 2
3589  Simulator::Schedule(Seconds(14.0) + MicroSeconds(10),
3590  &TestAmpduReception::SendAmpduWithThreeMpdus,
3591  this,
3592  rxPowerDbm,
3593  1300);
3594 
3595  // All MPDUs of A-MPDU 1 should have been received with errors.
3596  Simulator::Schedule(Seconds(14.1),
3597  &TestAmpduReception::CheckRxSuccessBitmapAmpdu1,
3598  this,
3599  0b00000000);
3600  Simulator::Schedule(Seconds(14.1),
3601  &TestAmpduReception::CheckRxFailureBitmapAmpdu1,
3602  this,
3603  0b00000111);
3604  Simulator::Schedule(Seconds(14.1),
3605  &TestAmpduReception::CheckRxDroppedBitmapAmpdu1,
3606  this,
3607  0b00000000);
3608 
3609  // All MPDUs of A-MPDU 2 should have been dropped.
3610  Simulator::Schedule(Seconds(14.1),
3611  &TestAmpduReception::CheckRxSuccessBitmapAmpdu2,
3612  this,
3613  0b00000000);
3614  Simulator::Schedule(Seconds(14.1),
3615  &TestAmpduReception::CheckRxFailureBitmapAmpdu2,
3616  this,
3617  0b00000000);
3618  Simulator::Schedule(Seconds(14.1),
3619  &TestAmpduReception::CheckRxDroppedBitmapAmpdu2,
3620  this,
3621  0b00000111);
3622 
3623  Simulator::Schedule(Seconds(14.2), &TestAmpduReception::ResetBitmaps, this);
3624 
3626  // CASE 15: receive two A-MPDUs (containing each 3 MPDUs) with the second A-MPDU having a power
3627  // 6 dB higher. The second A-MPDU is received 10 microseconds after the first A-MPDU (i.e.
3628  // during the frame capture window).
3630 
3631  // A-MPDU 1
3632  Simulator::Schedule(Seconds(15.0),
3633  &TestAmpduReception::SendAmpduWithThreeMpdus,
3634  this,
3635  rxPowerDbm,
3636  1000);
3637 
3638  // A-MPDU 2
3639  Simulator::Schedule(Seconds(15.0) + MicroSeconds(10),
3640  &TestAmpduReception::SendAmpduWithThreeMpdus,
3641  this,
3642  rxPowerDbm + 6,
3643  1300);
3644 
3645  // All MPDUs of A-MPDU 1 should have been dropped because PHY reception switched to A-MPDU 2.
3646  Simulator::Schedule(Seconds(15.1),
3647  &TestAmpduReception::CheckRxSuccessBitmapAmpdu1,
3648  this,
3649  0b00000000);
3650  Simulator::Schedule(Seconds(15.1),
3651  &TestAmpduReception::CheckRxFailureBitmapAmpdu1,
3652  this,
3653  0b00000000);
3654  Simulator::Schedule(Seconds(15.1),
3655  &TestAmpduReception::CheckRxDroppedBitmapAmpdu1,
3656  this,
3657  0b00000111);
3658 
3659  // All MPDUs of A-MPDU 2 should have been successfully received
3660  Simulator::Schedule(Seconds(15.1),
3661  &TestAmpduReception::CheckRxSuccessBitmapAmpdu2,
3662  this,
3663  0b00000111);
3664  Simulator::Schedule(Seconds(15.1),
3665  &TestAmpduReception::CheckRxFailureBitmapAmpdu2,
3666  this,
3667  0b00000000);
3668  Simulator::Schedule(Seconds(15.1),
3669  &TestAmpduReception::CheckRxDroppedBitmapAmpdu2,
3670  this,
3671  0b00000000);
3672 
3673  Simulator::Schedule(Seconds(15.2), &TestAmpduReception::ResetBitmaps, this);
3674 
3676  // CASE 16: receive two A-MPDUs (containing each 3 MPDUs) with the first A-MPDU having a power 6
3677  // dB higher. The second A-MPDU is received 10 microseconds after the first A-MPDU (i.e. during
3678  // the frame capture window).
3680 
3681  // A-MPDU 1
3682  Simulator::Schedule(Seconds(16.0),
3683  &TestAmpduReception::SendAmpduWithThreeMpdus,
3684  this,
3685  rxPowerDbm + 6,
3686  1000);
3687 
3688  // A-MPDU 2
3689  Simulator::Schedule(Seconds(16.0) + MicroSeconds(10),
3690  &TestAmpduReception::SendAmpduWithThreeMpdus,
3691  this,
3692  rxPowerDbm,
3693  1300);
3694 
3695  // All MPDUs of A-MPDU 1 should have been successfully received.
3696  Simulator::Schedule(Seconds(16.1),
3697  &TestAmpduReception::CheckRxSuccessBitmapAmpdu1,
3698  this,
3699  0b00000111);
3700  Simulator::Schedule(Seconds(16.1),
3701  &TestAmpduReception::CheckRxFailureBitmapAmpdu1,
3702  this,
3703  0b00000000);
3704  Simulator::Schedule(Seconds(16.1),
3705  &TestAmpduReception::CheckRxDroppedBitmapAmpdu1,
3706  this,
3707  0b00000000);
3708 
3709  // All MPDUs of A-MPDU 2 should have been dropped.
3710  Simulator::Schedule(Seconds(16.1),
3711  &TestAmpduReception::CheckRxSuccessBitmapAmpdu2,
3712  this,
3713  0b00000000);
3714  Simulator::Schedule(Seconds(16.1),
3715  &TestAmpduReception::CheckRxFailureBitmapAmpdu2,
3716  this,
3717  0b00000000);
3718  Simulator::Schedule(Seconds(16.1),
3719  &TestAmpduReception::CheckRxDroppedBitmapAmpdu2,
3720  this,
3721  0b00000111);
3722 
3723  Simulator::Schedule(Seconds(16.2), &TestAmpduReception::ResetBitmaps, this);
3724 
3726  // CASE 17: receive two A-MPDUs (containing each 3 MPDUs) with the second A-MPDU having a power
3727  // 6 dB higher. The second A-MPDU is received 25 microseconds after the first A-MPDU (i.e. after
3728  // the frame capture window, but still during PHY header).
3730 
3731  // A-MPDU 1
3732  Simulator::Schedule(Seconds(17.0),
3733  &TestAmpduReception::SendAmpduWithThreeMpdus,
3734  this,
3735  rxPowerDbm,
3736  1000);
3737 
3738  // A-MPDU 2
3739  Simulator::Schedule(Seconds(17.0) + MicroSeconds(25),
3740  &TestAmpduReception::SendAmpduWithThreeMpdus,
3741  this,
3742  rxPowerDbm + 6,
3743  1300);
3744 
3745  // All MPDUs of A-MPDU 1 should have been received with errors.
3746  Simulator::Schedule(Seconds(17.1),
3747  &TestAmpduReception::CheckRxSuccessBitmapAmpdu1,
3748  this,
3749  0b00000000);
3750  Simulator::Schedule(Seconds(17.1),
3751  &TestAmpduReception::CheckRxFailureBitmapAmpdu1,
3752  this,
3753  0b00000000);
3754  Simulator::Schedule(Seconds(17.1),
3755  &TestAmpduReception::CheckRxDroppedBitmapAmpdu1,
3756  this,
3757  0b00000111);
3758 
3759  // All MPDUs of A-MPDU 2 should have been dropped (no reception switch, MPDUs dropped because
3760  // PHY is already in RX state).
3761  Simulator::Schedule(Seconds(17.1),
3762  &TestAmpduReception::CheckRxSuccessBitmapAmpdu2,
3763  this,
3764  0b00000000);
3765  Simulator::Schedule(Seconds(17.1),
3766  &TestAmpduReception::CheckRxFailureBitmapAmpdu2,
3767  this,
3768  0b00000000);
3769  Simulator::Schedule(Seconds(17.1),
3770  &TestAmpduReception::CheckRxDroppedBitmapAmpdu2,
3771  this,
3772  0b00000111);
3773 
3774  Simulator::Schedule(Seconds(17.2), &TestAmpduReception::ResetBitmaps, this);
3775 
3777  // CASE 18: receive two A-MPDUs (containing each 3 MPDUs) with the first A-MPDU having a power 6
3778  // dB higher. The second A-MPDU is received 25 microseconds after the first A-MPDU (i.e. after
3779  // the frame capture window, but still during PHY header).
3781 
3782  // A-MPDU 1
3783  Simulator::Schedule(Seconds(18.0),
3784  &TestAmpduReception::SendAmpduWithThreeMpdus,
3785  this,
3786  rxPowerDbm + 6,
3787  1000);
3788 
3789  // A-MPDU 2
3790  Simulator::Schedule(Seconds(18.0) + MicroSeconds(25),
3791  &TestAmpduReception::SendAmpduWithThreeMpdus,
3792  this,
3793  rxPowerDbm,
3794  1300);
3795 
3796  // All MPDUs of A-MPDU 1 should have been successfully received.
3797  Simulator::Schedule(Seconds(18.1),
3798  &TestAmpduReception::CheckRxSuccessBitmapAmpdu1,
3799  this,
3800  0b00000111);
3801  Simulator::Schedule(Seconds(18.1),
3802  &TestAmpduReception::CheckRxFailureBitmapAmpdu1,
3803  this,
3804  0b00000000);
3805  Simulator::Schedule(Seconds(18.1),
3806  &TestAmpduReception::CheckRxDroppedBitmapAmpdu1,
3807  this,
3808  0b00000000);
3809 
3810  // All MPDUs of A-MPDU 2 should have been dropped.
3811  Simulator::Schedule(Seconds(18.1),
3812  &TestAmpduReception::CheckRxSuccessBitmapAmpdu2,
3813  this,
3814  0b00000000);
3815  Simulator::Schedule(Seconds(18.1),
3816  &TestAmpduReception::CheckRxFailureBitmapAmpdu2,
3817  this,
3818  0b00000000);
3819  Simulator::Schedule(Seconds(18.1),
3820  &TestAmpduReception::CheckRxDroppedBitmapAmpdu2,
3821  this,
3822  0b00000111);
3823 
3824  Simulator::Schedule(Seconds(18.2), &TestAmpduReception::ResetBitmaps, this);
3825 
3827  // CASE 19: receive two A-MPDUs (containing each 3 MPDUs) with the same power.
3828  // The second A-MPDU is received 25 microseconds after the first A-MPDU (i.e. after the frame
3829  // capture window, but still during PHY header).
3831 
3832  // A-MPDU 1
3833  Simulator::Schedule(Seconds(19.0),
3834  &TestAmpduReception::SendAmpduWithThreeMpdus,
3835  this,
3836  rxPowerDbm,
3837  1000);
3838 
3839  // A-MPDU 2
3840  Simulator::Schedule(Seconds(19.0) + MicroSeconds(25),
3841  &TestAmpduReception::SendAmpduWithThreeMpdus,
3842  this,
3843  rxPowerDbm,
3844  1300);
3845 
3846  // All MPDUs of A-MPDU 1 should have been received with errors.
3847  Simulator::Schedule(Seconds(19.1),
3848  &TestAmpduReception::CheckRxSuccessBitmapAmpdu1,
3849  this,
3850  0b00000000);
3851  Simulator::Schedule(Seconds(19.1),
3852  &TestAmpduReception::CheckRxFailureBitmapAmpdu1,
3853  this,
3854  0b00000000);
3855  Simulator::Schedule(Seconds(19.1),
3856  &TestAmpduReception::CheckRxDroppedBitmapAmpdu1,
3857  this,
3858  0b00000111);
3859 
3860  // All MPDUs of A-MPDU 2 should have been dropped.
3861  Simulator::Schedule(Seconds(19.1),
3862  &TestAmpduReception::CheckRxSuccessBitmapAmpdu2,
3863  this,
3864  0b00000000);
3865  Simulator::Schedule(Seconds(19.1),
3866  &TestAmpduReception::CheckRxFailureBitmapAmpdu2,
3867  this,
3868  0b00000000);
3869  Simulator::Schedule(Seconds(19.1),
3870  &TestAmpduReception::CheckRxDroppedBitmapAmpdu2,
3871  this,
3872  0b00000111);
3873 
3874  Simulator::Schedule(Seconds(19.2), &TestAmpduReception::ResetBitmaps, this);
3875 
3877  // CASE 20: receive two A-MPDUs (containing each 3 MPDUs) with the second A-MPDU having a power
3878  // 6 dB higher. The second A-MPDU is received 100 microseconds after the first A-MPDU (i.e.
3879  // during the payload of MPDU #1).
3881 
3882  // A-MPDU 1
3883  Simulator::Schedule(Seconds(20.0),
3884  &TestAmpduReception::SendAmpduWithThreeMpdus,
3885  this,
3886  rxPowerDbm,
3887  1000);
3888 
3889  // A-MPDU 2
3890  Simulator::Schedule(Seconds(20.0) + MicroSeconds(100),
3891  &TestAmpduReception::SendAmpduWithThreeMpdus,
3892  this,
3893  rxPowerDbm + 6,
3894  1300);
3895 
3896  // All MPDUs of A-MPDU 1 should have been received with errors.
3897  Simulator::Schedule(Seconds(20.1),
3898  &TestAmpduReception::CheckRxSuccessBitmapAmpdu1,
3899  this,
3900  0b00000000);
3901  Simulator::Schedule(Seconds(20.1),
3902  &TestAmpduReception::CheckRxFailureBitmapAmpdu1,
3903  this,
3904  0b00000111);
3905  Simulator::Schedule(Seconds(20.1),
3906  &TestAmpduReception::CheckRxDroppedBitmapAmpdu1,
3907  this,
3908  0b00000000);
3909 
3910  // All MPDUs of A-MPDU 2 should have been dropped (no reception switch, MPDUs dropped because
3911  // PHY is already in RX state).
3912  Simulator::Schedule(Seconds(20.1),
3913  &TestAmpduReception::CheckRxSuccessBitmapAmpdu2,
3914  this,
3915  0b00000000);
3916  Simulator::Schedule(Seconds(20.1),
3917  &TestAmpduReception::CheckRxFailureBitmapAmpdu2,
3918  this,
3919  0b00000000);
3920  Simulator::Schedule(Seconds(20.1),
3921  &TestAmpduReception::CheckRxDroppedBitmapAmpdu2,
3922  this,
3923  0b00000111);
3924 
3925  Simulator::Schedule(Seconds(20.2), &TestAmpduReception::ResetBitmaps, this);
3926 
3928  // CASE 21: receive two A-MPDUs (containing each 3 MPDUs) with the first A-MPDU having a power 6
3929  // dB higher. The second A-MPDU is received 100 microseconds after the first A-MPDU (i.e. during
3930  // the payload of MPDU #1).
3932 
3933  // A-MPDU 1
3934  Simulator::Schedule(Seconds(21.0),
3935  &TestAmpduReception::SendAmpduWithThreeMpdus,
3936  this,
3937  rxPowerDbm + 6,
3938  1000);
3939 
3940  // A-MPDU 2
3941  Simulator::Schedule(Seconds(21.0) + MicroSeconds(100),
3942  &TestAmpduReception::SendAmpduWithThreeMpdus,
3943  this,
3944  rxPowerDbm,
3945  1300);
3946 
3947  // All MPDUs of A-MPDU 1 should have been successfully received.
3948  Simulator::Schedule(Seconds(21.1),
3949  &TestAmpduReception::CheckRxSuccessBitmapAmpdu1,
3950  this,
3951  0b00000111);
3952  Simulator::Schedule(Seconds(21.1),
3953  &TestAmpduReception::CheckRxFailureBitmapAmpdu1,
3954  this,
3955  0b00000000);
3956  Simulator::Schedule(Seconds(21.1),
3957  &TestAmpduReception::CheckRxDroppedBitmapAmpdu1,
3958  this,
3959  0b00000000);
3960 
3961  // All MPDUs of A-MPDU 2 should have been dropped.
3962  Simulator::Schedule(Seconds(21.1),
3963  &TestAmpduReception::CheckRxSuccessBitmapAmpdu2,
3964  this,
3965  0b00000000);
3966  Simulator::Schedule(Seconds(21.1),
3967  &TestAmpduReception::CheckRxFailureBitmapAmpdu2,
3968  this,
3969  0b00000000);
3970  Simulator::Schedule(Seconds(21.1),
3971  &TestAmpduReception::CheckRxDroppedBitmapAmpdu2,
3972  this,
3973  0b00000111);
3974 
3975  Simulator::Schedule(Seconds(21.2), &TestAmpduReception::ResetBitmaps, this);
3976 
3978  // CASE 22: receive two A-MPDUs (containing each 3 MPDUs) with the same power.
3979  // The second A-MPDU is received 100 microseconds after the first A-MPDU (i.e. during the
3980  // payload of MPDU #1).
3982 
3983  // A-MPDU 1
3984  Simulator::Schedule(Seconds(22.0),
3985  &TestAmpduReception::SendAmpduWithThreeMpdus,
3986  this,
3987  rxPowerDbm,
3988  1000);
3989 
3990  // A-MPDU 2
3991  Simulator::Schedule(Seconds(22.0) + MicroSeconds(100),
3992  &TestAmpduReception::SendAmpduWithThreeMpdus,
3993  this,
3994  rxPowerDbm,
3995  1300);
3996 
3997  // All MPDUs of A-MPDU 1 should have been received with errors.
3998  Simulator::Schedule(Seconds(22.1),
3999  &TestAmpduReception::CheckRxSuccessBitmapAmpdu1,
4000  this,
4001  0b00000000);
4002  Simulator::Schedule(Seconds(22.1),
4003  &TestAmpduReception::CheckRxFailureBitmapAmpdu1,
4004  this,
4005  0b00000111);
4006  Simulator::Schedule(Seconds(22.1),
4007  &TestAmpduReception::CheckRxDroppedBitmapAmpdu1,
4008  this,
4009  0b00000000);
4010 
4011  // All MPDUs of A-MPDU 2 should have been dropped.
4012  Simulator::Schedule(Seconds(22.1),
4013  &TestAmpduReception::CheckRxSuccessBitmapAmpdu2,
4014  this,
4015  0b00000000);
4016  Simulator::Schedule(Seconds(22.1),
4017  &TestAmpduReception::CheckRxFailureBitmapAmpdu2,
4018  this,
4019  0b00000000);
4020  Simulator::Schedule(Seconds(22.1),
4021  &TestAmpduReception::CheckRxDroppedBitmapAmpdu2,
4022  this,
4023  0b00000111);
4024 
4025  Simulator::Schedule(Seconds(22.2), &TestAmpduReception::ResetBitmaps, this);
4026 
4028  // CASE 23: receive two A-MPDUs (containing each 3 MPDUs) with the same power.
4029  // The second A-MPDU is received during the payload of MPDU #2.
4031 
4032  // A-MPDU 1
4033  Simulator::Schedule(Seconds(23.0),
4034  &TestAmpduReception::SendAmpduWithThreeMpdus,
4035  this,
4036  rxPowerDbm,
4037  1000);
4038 
4039  // A-MPDU 2
4040  Simulator::Schedule(Seconds(23.0) + NanoSeconds(1100000),
4041  &TestAmpduReception::SendAmpduWithThreeMpdus,
4042  this,
4043  rxPowerDbm,
4044  1300);
4045 
4046  // The first MPDU of A-MPDU 1 should have been successfully received (no interference).
4047  // The two other MPDUs failed due to interference and are marked as failure (and dropped).
4048  Simulator::Schedule(Seconds(23.1),
4049  &TestAmpduReception::CheckRxSuccessBitmapAmpdu1,
4050  this,
4051  0b00000001);
4052  Simulator::Schedule(Seconds(23.1),
4053  &TestAmpduReception::CheckRxFailureBitmapAmpdu1,
4054  this,
4055  0b00000110);
4056  Simulator::Schedule(Seconds(23.1),
4057  &TestAmpduReception::CheckRxDroppedBitmapAmpdu1,
4058  this,
4059  0b00000000);
4060 
4061  // The two first MPDUs of A-MPDU 2 are dropped because PHY is already in RX state (receiving
4062  // A-MPDU 1). The last MPDU of A-MPDU 2 is interference free (A-MPDU 1 transmission is finished)
4063  // but is dropped because its PHY preamble and header were not received.
4064  Simulator::Schedule(Seconds(23.1),
4065  &TestAmpduReception::CheckRxSuccessBitmapAmpdu2,
4066  this,
4067  0b00000000);
4068  Simulator::Schedule(Seconds(23.1),
4069  &TestAmpduReception::CheckRxFailureBitmapAmpdu2,
4070  this,
4071  0b00000000);
4072  Simulator::Schedule(Seconds(23.1),
4073  &TestAmpduReception::CheckRxDroppedBitmapAmpdu2,
4074  this,
4075  0b00000111);
4076 
4077  Simulator::Schedule(Seconds(23.2), &TestAmpduReception::ResetBitmaps, this);
4078 
4079  Simulator::Run();
4080  Simulator::Destroy();
4081 }
4082 
4103 class TestUnsupportedModulationReception : public TestCase
4104 {
4105  public:
4109  TestUnsupportedModulationReception();
4110  ~TestUnsupportedModulationReception() override;
4111 
4118  void Dropped(std::string context, Ptr<const Packet> packet, WifiPhyRxfailureReason reason);
4122  void CheckResults();
4123 
4124  private:
4125  void DoRun() override;
4126  uint16_t m_dropped;
4127 };
4128 
4129 TestUnsupportedModulationReception::TestUnsupportedModulationReception()
4130  : TestCase("Check correct behavior when a STA is receiving a transmission using an unsupported "
4131  "modulation"),
4132  m_dropped(0)
4133 {
4134 }
4135 
4136 TestUnsupportedModulationReception::~TestUnsupportedModulationReception()
4137 {
4138 }
4139 
4140 void
4141 TestUnsupportedModulationReception::Dropped(std::string context,
4142  Ptr<const Packet> packet,
4143  WifiPhyRxfailureReason reason)
4144 {
4145  // Print if the test is executed through test-runner
4146  if (reason == RXING)
4147  {
4148  std::cout << "Dropped a packet because already receiving" << std::endl;
4149  m_dropped++;
4150  }
4151 }
4152 
4153 void
4154 TestUnsupportedModulationReception::DoRun()
4155 {
4156  uint16_t m_nStations = 2;
4157  NetDeviceContainer m_staDevices;
4158  NetDeviceContainer m_apDevices;
4159 
4160  // RngSeedManager::SetSeed (1);
4161  // RngSeedManager::SetRun (40);
4162  int64_t streamNumber = 100;
4163 
4164  NodeContainer wifiApNode;
4165  wifiApNode.Create(1);
4166 
4167  NodeContainer wifiStaNodes;
4168  wifiStaNodes.Create(m_nStations);
4169 
4170  Ptr<MultiModelSpectrumChannel> spectrumChannel = CreateObject<MultiModelSpectrumChannel>();
4171  Ptr<FriisPropagationLossModel> lossModel = CreateObject<FriisPropagationLossModel>();
4172  spectrumChannel->AddPropagationLossModel(lossModel);
4173  Ptr<ConstantSpeedPropagationDelayModel> delayModel =
4174  CreateObject<ConstantSpeedPropagationDelayModel>();
4175  spectrumChannel->SetPropagationDelayModel(delayModel);
4176 
4177  SpectrumWifiPhyHelper phy;
4178  phy.SetChannel(spectrumChannel);
4179 
4180  Config::SetDefault("ns3::WifiRemoteStationManager::RtsCtsThreshold", UintegerValue(65535));
4181 
4182  WifiHelper wifi;
4183  wifi.SetRemoteStationManager("ns3::IdealWifiManager");
4184 
4185  WifiMacHelper mac;
4186  mac.SetType("ns3::StaWifiMac",
4187  "QosSupported",
4188  BooleanValue(true),
4189  "Ssid",
4190  SsidValue(Ssid("non-existent-ssid")));
4191 
4192  wifi.SetStandard(WIFI_STANDARD_80211ax);
4193  m_staDevices.Add(wifi.Install(phy, mac, wifiStaNodes.Get(0)));
4194  wifi.SetStandard(WIFI_STANDARD_80211ac);
4195  m_staDevices.Add(wifi.Install(phy, mac, wifiStaNodes.Get(1)));
4196 
4197  wifi.SetStandard(WIFI_STANDARD_80211ax);
4198  mac.SetType("ns3::ApWifiMac",
4199  "QosSupported",
4200  BooleanValue(true),
4201  "Ssid",
4202  SsidValue(Ssid("wifi-backoff-ssid")),
4203  "BeaconInterval",
4204  TimeValue(MicroSeconds(102400)),
4205  "EnableBeaconJitter",
4206  BooleanValue(false));
4207 
4208  m_apDevices = wifi.Install(phy, mac, wifiApNode);
4209 
4210  // schedule association requests at different times
4211  Time init = MilliSeconds(100);
4212  Ptr<WifiNetDevice> dev;
4213 
4214  for (uint16_t i = 0; i < m_nStations; i++)
4215  {
4216  dev = DynamicCast<WifiNetDevice>(m_staDevices.Get(i));
4217  Simulator::Schedule(init + i * MicroSeconds(102400),
4218  &WifiMac::SetSsid,
4219  dev->GetMac(),
4220  Ssid("wifi-backoff-ssid"));
4221  }
4222 
4223  // Assign fixed streams to random variables in use
4224  wifi.AssignStreams(m_apDevices, streamNumber);
4225 
4226  MobilityHelper mobility;
4227  Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator>();
4228 
4229  positionAlloc->Add(Vector(0.0, 0.0, 0.0));
4230  positionAlloc->Add(Vector(1.0, 0.0, 0.0));
4231  positionAlloc->Add(Vector(0.0, 1.0, 0.0));
4232  positionAlloc->Add(Vector(-1.0, 0.0, 0.0));
4233  mobility.SetPositionAllocator(positionAlloc);
4234 
4235  mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
4236  mobility.Install(wifiApNode);
4237  mobility.Install(wifiStaNodes);
4238 
4239  // set the TXOP limit on BE AC
4240  dev = DynamicCast<WifiNetDevice>(m_apDevices.Get(0));
4241  PointerValue ptr;
4242  dev->GetMac()->GetAttribute("BE_Txop", ptr);
4243 
4244  PacketSocketHelper packetSocket;
4245  packetSocket.Install(wifiApNode);
4246  packetSocket.Install(wifiStaNodes);
4247 
4248  // UL Traffic
4249  for (uint16_t i = 0; i < m_nStations; i++)
4250  {
4251  PacketSocketAddress socket;
4252  socket.SetSingleDevice(m_staDevices.Get(0)->GetIfIndex());
4253  socket.SetPhysicalAddress(m_apDevices.Get(0)->GetAddress());
4254  socket.SetProtocol(1);
4255  Ptr<PacketSocketClient> client = CreateObject<PacketSocketClient>();
4256  client->SetAttribute("PacketSize", UintegerValue(1500));
4257  client->SetAttribute("MaxPackets", UintegerValue(200));
4258  client->SetAttribute("Interval", TimeValue(MicroSeconds(0)));
4259  client->SetRemote(socket);
4260  wifiStaNodes.Get(i)->AddApplication(client);
4261  client->SetStartTime(MicroSeconds(400000));
4262  client->SetStopTime(Seconds(1.0));
4263  Ptr<PacketSocketClient> legacyStaClient = CreateObject<PacketSocketClient>();
4264  legacyStaClient->SetAttribute("PacketSize", UintegerValue(1500));
4265  legacyStaClient->SetAttribute("MaxPackets", UintegerValue(200));
4266  legacyStaClient->SetAttribute("Interval", TimeValue(MicroSeconds(0)));
4267  legacyStaClient->SetRemote(socket);
4268  wifiStaNodes.Get(i)->AddApplication(legacyStaClient);
4269  legacyStaClient->SetStartTime(MicroSeconds(400000));
4270  legacyStaClient->SetStopTime(Seconds(1.0));
4271  Ptr<PacketSocketServer> server = CreateObject<PacketSocketServer>();
4272  server->SetLocal(socket);
4273  wifiApNode.Get(0)->AddApplication(server);
4274  server->SetStartTime(Seconds(0.0));
4275  server->SetStopTime(Seconds(1.0));
4276  }
4277 
4278  // Trace dropped packets
4279  Config::Connect("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/PhyRxDrop",
4280  MakeCallback(&TestUnsupportedModulationReception::Dropped, this));
4281 
4282  Simulator::Stop(Seconds(1));
4283  Simulator::Run();
4284 
4285  CheckResults();
4286 
4287  Simulator::Destroy();
4288 }
4289 
4290 void
4291 TestUnsupportedModulationReception::CheckResults()
4292 {
4293  NS_TEST_EXPECT_MSG_EQ(m_dropped, 0, "Dropped some packets unexpectedly");
4294 }
4295 
4307 class TestUnsupportedBandwidthReception : public TestCase
4308 {
4309  public:
4310  TestUnsupportedBandwidthReception();
4311 
4312  private:
4313  void DoSetup() override;
4314  void DoTeardown() override;
4315  void DoRun() override;
4316 
4324  void SendPpdu(WifiPhyBand band, uint16_t centerFreqMhz, uint16_t bandwidthMhz);
4325 
4333  void RxSuccess(Ptr<const WifiPsdu> psdu,
4334  RxSignalInfo rxSignalInfo,
4335  WifiTxVector txVector,
4336  std::vector<bool> statusPerMpdu);
4337 
4342  void RxFailure(Ptr<const WifiPsdu> psdu);
4343 
4349  void RxDropped(Ptr<const Packet> packet, WifiPhyRxfailureReason reason);
4350 
4362  void CheckRx(uint32_t expectedCountRxSuccess,
4363  uint32_t expectedCountRxFailure,
4364  uint32_t expectedCountRxDropped,
4365  std::optional<Time> expectedLastRxSucceeded,
4366  std::optional<Time> expectedLastRxFailed,
4367  std::optional<Time> expectedLastRxDropped);
4368 
4369  uint32_t m_countRxSuccess;
4370  uint32_t m_countRxFailure;
4371  uint32_t m_countRxDropped;
4372 
4373  std::optional<Time> m_lastRxSucceeded;
4374  std::optional<Time> m_lastRxFailed;
4375  std::optional<Time> m_lastRxDropped;
4376 
4377  Ptr<SpectrumWifiPhy> m_phy;
4378 };
4379 
4380 TestUnsupportedBandwidthReception::TestUnsupportedBandwidthReception()
4381  : TestCase("Check correct behavior when a STA is receiving a transmission using an unsupported "
4382  "bandwidth"),
4383  m_countRxSuccess(0),
4384  m_countRxFailure(0),
4385  m_countRxDropped(0),
4386  m_lastRxSucceeded(std::nullopt),
4387  m_lastRxFailed(std::nullopt),
4388  m_lastRxDropped(std::nullopt)
4389 {
4390 }
4391 
4392 void
4393 TestUnsupportedBandwidthReception::SendPpdu(WifiPhyBand band,
4394  uint16_t centerFreqMhz,
4395  uint16_t bandwidthMhz)
4396 {
4397  auto txVector =
4398  WifiTxVector(HePhy::GetHeMcs0(), 0, WIFI_PREAMBLE_HE_SU, 800, 1, 1, 0, bandwidthMhz, false);
4399 
4400  auto pkt = Create<Packet>(1000);
4401  WifiMacHeader hdr;
4402 
4403  hdr.SetType(WIFI_MAC_QOSDATA);
4404  hdr.SetQosTid(0);
4405 
4406  Ptr<WifiPsdu> psdu = Create<WifiPsdu>(pkt, hdr);
4407  Time txDuration = m_phy->CalculateTxDuration(psdu->GetSize(), txVector, m_phy->GetPhyBand());
4408 
4409  auto ppdu = Create<HePpdu>(psdu, txVector, centerFreqMhz, txDuration, WIFI_PHY_BAND_5GHZ, 0);
4410 
4411  auto txPowerSpectrum =
4412  WifiSpectrumValueHelper::CreateHeOfdmTxPowerSpectralDensity(centerFreqMhz,
4413  bandwidthMhz,
4414  DbmToW(-50),
4415  bandwidthMhz);
4416 
4417  auto txParams = Create<WifiSpectrumSignalParameters>();
4418  txParams->psd = txPowerSpectrum;
4419  txParams->txPhy = nullptr;
4420  txParams->duration = txDuration;
4421  txParams->ppdu = ppdu;
4422  txParams->txWidth = bandwidthMhz;
4423 
4424  m_phy->StartRx(txParams);
4425 }
4426 
4427 void
4428 TestUnsupportedBandwidthReception::RxSuccess(Ptr<const WifiPsdu> psdu,
4429  RxSignalInfo rxSignalInfo,
4430  WifiTxVector txVector,
4431  std::vector<bool> statusPerMpdu)
4432 {
4433  NS_LOG_FUNCTION(this << *psdu << rxSignalInfo << txVector);
4434  m_countRxSuccess++;
4435  m_lastRxSucceeded = Simulator::Now();
4436 }
4437 
4438 void
4439 TestUnsupportedBandwidthReception::RxFailure(Ptr<const WifiPsdu> psdu)
4440 {
4441  NS_LOG_FUNCTION(this << *psdu);
4442  m_countRxFailure++;
4443  m_lastRxFailed = Simulator::Now();
4444 }
4445 
4446 void
4447 TestUnsupportedBandwidthReception::RxDropped(Ptr<const Packet> p, WifiPhyRxfailureReason reason)
4448 {
4449  NS_LOG_FUNCTION(this << p << reason);
4450  NS_ASSERT(reason == UNSUPPORTED_SETTINGS);
4451  m_countRxDropped++;
4452  m_lastRxDropped = Simulator::Now();
4453 }
4454 
4455 void
4456 TestUnsupportedBandwidthReception::CheckRx(uint32_t expectedCountRxSuccess,
4457  uint32_t expectedCountRxFailure,
4458  uint32_t expectedCountRxDropped,
4459  std::optional<Time> expectedLastRxSucceeded,
4460  std::optional<Time> expectedLastRxFailed,
4461  std::optional<Time> expectedLastRxDropped)
4462 {
4463  NS_TEST_ASSERT_MSG_EQ(m_countRxSuccess,
4464  expectedCountRxSuccess,
4465  "Didn't receive right number of successful packets");
4466 
4467  NS_TEST_ASSERT_MSG_EQ(m_countRxFailure,
4468  expectedCountRxFailure,
4469  "Didn't receive right number of unsuccessful packets");
4470 
4471  NS_TEST_ASSERT_MSG_EQ(m_countRxDropped,
4472  expectedCountRxDropped,
4473  "Didn't receive right number of dropped packets");
4474 
4475  if (expectedCountRxSuccess > 0)
4476  {
4477  NS_ASSERT(m_lastRxSucceeded.has_value());
4478  NS_ASSERT(expectedLastRxSucceeded.has_value());
4479  NS_TEST_ASSERT_MSG_EQ(m_lastRxSucceeded.value(),
4480  expectedLastRxSucceeded.value(),
4481  "Didn't receive the last successful packet at the expected time");
4482  }
4483 
4484  if (expectedCountRxFailure > 0)
4485  {
4486  NS_ASSERT(m_lastRxFailed.has_value());
4487  NS_ASSERT(expectedLastRxFailed.has_value());
4488  NS_TEST_ASSERT_MSG_EQ(m_lastRxFailed.value(),
4489  expectedLastRxFailed.value(),
4490  "Didn't receive the last unsuccessful packet at the expected time");
4491  }
4492 
4493  if (expectedCountRxDropped > 0)
4494  {
4495  NS_ASSERT(m_lastRxDropped.has_value());
4496  NS_ASSERT(expectedLastRxDropped.has_value());
4497  NS_TEST_ASSERT_MSG_EQ(m_lastRxDropped.value(),
4498  expectedLastRxDropped.value(),
4499  "Didn't drop the last filtered packet at the expected time");
4500  }
4501 }
4502 
4503 void
4504 TestUnsupportedBandwidthReception::DoSetup()
4505 {
4506  m_phy = CreateObject<SpectrumWifiPhy>();
4507  m_phy->ConfigureStandard(WIFI_STANDARD_80211ax);
4508  auto interferenceHelper = CreateObject<InterferenceHelper>();
4509  m_phy->SetInterferenceHelper(interferenceHelper);
4510  auto error = CreateObject<NistErrorRateModel>();
4511  m_phy->SetErrorRateModel(error);
4512 
4513  m_phy->SetReceiveOkCallback(MakeCallback(&TestUnsupportedBandwidthReception::RxSuccess, this));
4514  m_phy->SetReceiveErrorCallback(
4515  MakeCallback(&TestUnsupportedBandwidthReception::RxFailure, this));
4516  m_phy->TraceConnectWithoutContext(
4517  "PhyRxDrop",
4518  MakeCallback(&TestUnsupportedBandwidthReception::RxDropped, this));
4519 }
4520 
4521 void
4522 TestUnsupportedBandwidthReception::DoTeardown()
4523 {
4524  m_phy->Dispose();
4525  m_phy = nullptr;
4526 }
4527 
4528 void
4529 TestUnsupportedBandwidthReception::DoRun()
4530 {
4531  RngSeedManager::SetSeed(1);
4532  RngSeedManager::SetRun(1);
4533 
4534  int64_t streamNumber = 0;
4535  m_phy->AssignStreams(streamNumber);
4536 
4537  // Case 1: the PHY is operating on channel 36 (20 MHz) and receives a 40 MHz PPDU (channel 38).
4538  // The PPDU should be dropped once HE-SIG-A is successfully received, since it contains
4539  // indication about the BW used for the transmission and the PHY shall detect it is larger than
4540  // its operating BW.
4541  m_phy->SetOperatingChannel(WifiPhy::ChannelTuple{36, 20, WIFI_PHY_BAND_5GHZ, 0});
4542 
4543  Simulator::Schedule(Seconds(1.0),
4544  &TestUnsupportedBandwidthReception::SendPpdu,
4545  this,
4546  WIFI_PHY_BAND_5GHZ,
4547  5190,
4548  40);
4549 
4550  auto heSigAExpectedRxTime = Seconds(1.0) + MicroSeconds(32);
4551  Simulator::Schedule(Seconds(1.5),
4552  &TestUnsupportedBandwidthReception::CheckRx,
4553  this,
4554  0,
4555  0,
4556  1,
4557  std::nullopt,
4558  std::nullopt,
4559  heSigAExpectedRxTime);
4560 
4561  // TODO: this test can be extended with other scenarios
4562 
4563  Simulator::Run();
4564  Simulator::Destroy();
4565 }
4566 
4575 class TestPrimary20CoveredByPpdu : public TestCase
4576 {
4577  public:
4578  TestPrimary20CoveredByPpdu();
4579 
4580  private:
4581  void DoSetup() override;
4582  void DoRun() override;
4583  void DoTeardown() override;
4584 
4592  Ptr<HePpdu> CreatePpdu(WifiPhyBand band, uint16_t ppduCenterFreqMhz);
4593 
4606  void RunOne(WifiPhyBand band,
4607  uint16_t phyCenterFreqMhz,
4608  uint8_t p20Index,
4609  uint16_t ppduCenterFreqMhz,
4610  bool expectedP20Overlap,
4611  bool expectedP20Covered);
4612 
4613  Ptr<SpectrumWifiPhy> m_phy;
4614 };
4615 
4616 TestPrimary20CoveredByPpdu::TestPrimary20CoveredByPpdu()
4617  : TestCase("Check correct detection of whether P20 is fully covered (hence it can be received) "
4618  "or overlaps with the bandwidth of an incoming PPDU")
4619 {
4620 }
4621 
4622 Ptr<HePpdu>
4623 TestPrimary20CoveredByPpdu::CreatePpdu(WifiPhyBand band, uint16_t ppduCenterFreqMhz)
4624 {
4625  [[maybe_unused]] auto [channelNumber, centerFreq, channelWidth, type, phyBand] =
4626  (*WifiPhyOperatingChannel::FindFirst(0, ppduCenterFreqMhz, 0, WIFI_STANDARD_80211ax, band));
4627 
4628  auto txVector =
4629  WifiTxVector(HePhy::GetHeMcs7(), 0, WIFI_PREAMBLE_HE_SU, 800, 1, 1, 0, channelWidth, false);
4630 
4631  auto pkt = Create<Packet>(1000);
4632  WifiMacHeader hdr(WIFI_MAC_QOSDATA);
4633 
4634  auto psdu = Create<WifiPsdu>(pkt, hdr);
4635  auto txDuration = m_phy->CalculateTxDuration(psdu->GetSize(), txVector, band);
4636 
4637  return Create<HePpdu>(psdu, txVector, ppduCenterFreqMhz, txDuration, band, 0);
4638 }
4639 
4640 void
4641 TestPrimary20CoveredByPpdu::DoSetup()
4642 {
4643  m_phy = CreateObject<SpectrumWifiPhy>();
4644  m_phy->ConfigureStandard(WIFI_STANDARD_80211ax);
4645  auto interferenceHelper = CreateObject<InterferenceHelper>();
4646  m_phy->SetInterferenceHelper(interferenceHelper);
4647  auto error = CreateObject<NistErrorRateModel>();
4648  m_phy->SetErrorRateModel(error);
4649 }
4650 
4651 void
4652 TestPrimary20CoveredByPpdu::DoTeardown()
4653 {
4654  m_phy->Dispose();
4655  m_phy = nullptr;
4656 }
4657 
4658 void
4659 TestPrimary20CoveredByPpdu::RunOne(WifiPhyBand band,
4660  uint16_t phyCenterFreqMhz,
4661  uint8_t p20Index,
4662  uint16_t ppduCenterFreqMhz,
4663  bool expectedP20Overlap,
4664  bool expectedP20Covered)
4665 {
4666  [[maybe_unused]] const auto [channelNumber, centerFreq, channelWidth, type, phyBand] =
4667  (*WifiPhyOperatingChannel::FindFirst(0, phyCenterFreqMhz, 0, WIFI_STANDARD_80211ax, band));
4668 
4669  m_phy->SetOperatingChannel(WifiPhy::ChannelTuple{channelNumber, channelWidth, band, p20Index});
4670  auto p20CenterFreq = m_phy->GetOperatingChannel().GetPrimaryChannelCenterFrequency(20);
4671  auto p20MinFreq = p20CenterFreq - 10;
4672  auto p20MaxFreq = p20CenterFreq + 10;
4673 
4674  auto ppdu = CreatePpdu(band, ppduCenterFreqMhz);
4675 
4676  auto p20Overlap = ppdu->DoesOverlapChannel(p20MinFreq, p20MaxFreq);
4677  NS_TEST_ASSERT_MSG_EQ(p20Overlap,
4678  expectedP20Overlap,
4679  "PPDU is " << (expectedP20Overlap ? "expected" : "not expected")
4680  << " to overlap with the P20");
4681 
4682  auto p20Covered =
4683  m_phy->GetPhyEntity(WIFI_STANDARD_80211ax)
4684  ->CanStartRx(
4685  ppdu,
4686  ppdu->GetTxVector()
4687  .GetChannelWidth()); // CanStartRx returns true is the P20 is fully covered
4688  NS_TEST_ASSERT_MSG_EQ(p20Covered,
4689  expectedP20Covered,
4690  "PPDU is " << (expectedP20Covered ? "expected" : "not expected")
4691  << " to cover the whole P20");
4692 }
4693 
4694 void
4695 TestPrimary20CoveredByPpdu::DoRun()
4696 {
4697  /*
4698  * Receiver PHY Operating Channel: 2.4 GHz Channel 4 (2417 MHz – 2437 MHz)
4699  * Transmitted 20 MHz PPDU: 2.4 GHz Channel 4 (2417 MHz – 2437 MHz)
4700  * Overlap with primary 20 MHz: yes
4701  * Primary 20 MHz fully covered: yes
4702  */
4703  RunOne(WIFI_PHY_BAND_2_4GHZ, 2427, 0, 2427, true, true);
4704 
4705  /*
4706  * Receiver PHY Operating Channel: 2.4 GHz Channel 4 (2417 MHz – 2437 MHz)
4707  * Transmitted 40 MHz PPDU: 2.4 GHz Channel 6 (2427 MHz – 2447 MHz)
4708  * Overlap with primary 20 MHz: yes
4709  * Primary 20 MHz fully covered: no
4710  */
4711  RunOne(WIFI_PHY_BAND_2_4GHZ, 2427, 0, 2437, true, false);
4712 
4713  /*
4714  * Receiver PHY Operating Channel: 5 GHz Channel 36 (5170 MHz – 5190 MHz)
4715  * Transmitted 40 MHz PPDU: 5 GHz Channel 38 (5170 MHz – 5210 MHz)
4716  * Overlap with primary 20 MHz: yes
4717  * Primary 20 MHz fully covered: yes
4718  */
4719  RunOne(WIFI_PHY_BAND_5GHZ, 5180, 0, 5190, true, true);
4720 
4721  /*
4722  * Receiver PHY Operating Channel: 5 GHz Channel 36 (5170 MHz–5190 MHz)
4723  * Transmitted 20 MHz PPDU: 5 GHz Channel 40 (5190 MHz – 5210 MHz)
4724  * Overlap with primary 20 MHz: no
4725  * Primary 20 MHz fully covered: no
4726  */
4727  RunOne(WIFI_PHY_BAND_5GHZ, 5180, 0, 5200, false, false);
4728 
4729  /*
4730  * Receiver PHY Operating Channel: 5 GHz Channel 38 (5170 MHz – 5210 MHz) with P20 index 0
4731  * Transmitted 20 MHz PPDU: 5 GHz Channel 36 (5170 MHz – 5190 MHz)
4732  * Overlap with primary 20 MHz: yes
4733  * Primary 20 MHz fully covered: yes
4734  */
4735  RunOne(WIFI_PHY_BAND_5GHZ, 5190, 0, 5180, true, true);
4736 
4737  /*
4738  * Receiver PHY Operating Channel: 5 GHz Channel 38 (5170 MHz – 5210 MHz) with P20 index 1
4739  * Transmitted 20 MHz PPDU: 5 GHz Channel 36 (5170 MHz – 5190 MHz)
4740  * Overlap with primary 20 MHz: no
4741  * Primary 20 MHz fully covered: no
4742  */
4743  RunOne(WIFI_PHY_BAND_5GHZ, 5190, 1, 5180, false, false);
4744 
4745  Simulator::Destroy();
4746 }
4747 
4754 class WifiPhyReceptionTestSuite : public TestSuite
4755 {
4756  public:
4757  WifiPhyReceptionTestSuite();
4758 };
4759 
4760 WifiPhyReceptionTestSuite::WifiPhyReceptionTestSuite()
4761  : TestSuite("wifi-phy-reception", UNIT)
4762 {
4763  AddTestCase(new TestThresholdPreambleDetectionWithoutFrameCapture, TestCase::QUICK);
4764  AddTestCase(new TestThresholdPreambleDetectionWithFrameCapture, TestCase::QUICK);
4765  AddTestCase(new TestSimpleFrameCaptureModel, TestCase::QUICK);
4766  AddTestCase(new TestPhyHeadersReception, TestCase::QUICK);
4767  AddTestCase(new TestAmpduReception, TestCase::QUICK);
4768  AddTestCase(new TestUnsupportedModulationReception(), TestCase::QUICK);
4769  AddTestCase(new TestUnsupportedBandwidthReception(), TestCase::QUICK);
4770  AddTestCase(new TestPrimary20CoveredByPpdu(), TestCase::QUICK);
4771 }
4772 
4773 static WifiPhyReceptionTestSuite wifiPhyReceptionTestSuite;
TestAmpduReception
A-MPDU reception test.
Definition: wifi-phy-reception-test.cc:2516
TestAmpduReception::RxSuccess
void RxSuccess(Ptr< const WifiPsdu > psdu, RxSignalInfo rxSignalInfo, WifiTxVector txVector, std::vector< bool > statusPerMpdu)
RX success function.
Definition: wifi-phy-reception-test.cc:2655
TestAmpduReception::IncrementSuccessBitmap
void IncrementSuccessBitmap(uint32_t size)
Increment reception success bitmap.
Definition: wifi-phy-reception-test.cc:2683
TestAmpduReception::m_rxDroppedBitmapAmpdu2
uint8_t m_rxDroppedBitmapAmpdu2
bitmap of dropped MPDUs in A-MPDU #2
Definition: wifi-phy-reception-test.cc:2621
TestAmpduReception::CheckRxSuccessBitmapAmpdu2
void CheckRxSuccessBitmapAmpdu2(uint8_t expected)
Check the RX success bitmap for A-MPDU 2.
Definition: wifi-phy-reception-test.cc:2789
TestAmpduReception::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition: wifi-phy-reception-test.cc:2916
TestAmpduReception::CheckRxDroppedBitmapAmpdu1
void CheckRxDroppedBitmapAmpdu1(uint8_t expected)
Check the RX dropped bitmap for A-MPDU 1.
Definition: wifi-phy-reception-test.cc:2813
TestAmpduReception::m_rxSuccessBitmapAmpdu1
uint8_t m_rxSuccessBitmapAmpdu1
bitmap of successfully received MPDUs in A-MPDU #1
Definition: wifi-phy-reception-test.cc:2614
TestAmpduReception::m_rxFailureBitmapAmpdu1
uint8_t m_rxFailureBitmapAmpdu1
bitmap of unsuccessfuly received MPDUs in A-MPDU #1
Definition: wifi-phy-reception-test.cc:2617
TestAmpduReception::m_rxFailureBitmapAmpdu2
uint8_t m_rxFailureBitmapAmpdu2
bitmap of unsuccessfuly received MPDUs in A-MPDU #2
Definition: wifi-phy-reception-test.cc:2618
TestAmpduReception::RxDropped
void RxDropped(Ptr< const Packet > p, WifiPhyRxfailureReason reason)
RX dropped function.
Definition: wifi-phy-reception-test.cc:2751
TestAmpduReception::SendAmpduWithThreeMpdus
void SendAmpduWithThreeMpdus(double rxPowerDbm, uint32_t referencePacketSize)
Send A-MPDU with 3 MPDUs of different size (i-th MSDU will have 100 bytes more than (i-1)-th).
Definition: wifi-phy-reception-test.cc:2843
TestAmpduReception::RxFailure
void RxFailure(Ptr< const WifiPsdu > psdu)
RX failure function.
Definition: wifi-phy-reception-test.cc:2712
TestAmpduReception::DoTeardown
void DoTeardown() override
Implementation to do any local setup required for this TestCase.
Definition: wifi-phy-reception-test.cc:2909
TestAmpduReception::CheckRxFailureBitmapAmpdu2
void CheckRxFailureBitmapAmpdu2(uint8_t expected)
Check the RX failure bitmap for A-MPDU 2.
Definition: wifi-phy-reception-test.cc:2805
TestAmpduReception::m_rxDroppedBitmapAmpdu1
uint8_t m_rxDroppedBitmapAmpdu1
bitmap of dropped MPDUs in A-MPDU #1
Definition: wifi-phy-reception-test.cc:2620
TestAmpduReception::IncrementFailureBitmap
void IncrementFailureBitmap(uint32_t size)
Increment reception failure bitmap.
Definition: wifi-phy-reception-test.cc:2722
TestAmpduReception::DoSetup
void DoSetup() override
Implementation to do any local setup required for this TestCase.
Definition: wifi-phy-reception-test.cc:2882
TestAmpduReception::ResetBitmaps
void ResetBitmaps()
Reset bitmaps function.
Definition: wifi-phy-reception-test.cc:2644
TestAmpduReception::CheckPhyState
void CheckPhyState(WifiPhyState expectedState)
Check the PHY state.
Definition: wifi-phy-reception-test.cc:2829
TestAmpduReception::CheckRxSuccessBitmapAmpdu1
void CheckRxSuccessBitmapAmpdu1(uint8_t expected)
Check the RX success bitmap for A-MPDU 1.
Definition: wifi-phy-reception-test.cc:2781
TestAmpduReception::CheckRxFailureBitmapAmpdu1
void CheckRxFailureBitmapAmpdu1(uint8_t expected)
Check the RX failure bitmap for A-MPDU 1.
Definition: wifi-phy-reception-test.cc:2797
TestAmpduReception::m_rxSuccessBitmapAmpdu2
uint8_t m_rxSuccessBitmapAmpdu2
bitmap of successfully received MPDUs in A-MPDU #2
Definition: wifi-phy-reception-test.cc:2615
TestAmpduReception::m_phy
Ptr< SpectrumWifiPhy > m_phy
Phy.
Definition: wifi-phy-reception-test.cc:2612
TestAmpduReception::CheckRxDroppedBitmapAmpdu2
void CheckRxDroppedBitmapAmpdu2(uint8_t expected)
Check the RX dropped bitmap for A-MPDU 2.
Definition: wifi-phy-reception-test.cc:2821
TestPhyHeadersReception
Test PHY state upon success or failure of L-SIG and SIG-A.
Definition: wifi-phy-reception-test.cc:2085
TestPhyHeadersReception::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition: wifi-phy-reception-test.cc:2204
TestPhyHeadersReception::SendPacket
void SendPacket(double rxPowerDbm)
Send packet function.
Definition: wifi-phy-reception-test.cc:2124
TestPhyHeadersReception::m_phy
Ptr< SpectrumWifiPhy > m_phy
Phy.
Definition: wifi-phy-reception-test.cc:2093
TestPhyHeadersReception::CheckPhyState
void CheckPhyState(WifiPhyState expectedState)
Schedule now to check the PHY state.
Definition: wifi-phy-reception-test.cc:2157
TestPhyHeadersReception::DoSetup
void DoSetup() override
Implementation to do any local setup required for this TestCase.
Definition: wifi-phy-reception-test.cc:2185
TestPhyHeadersReception::DoCheckPhyState
void DoCheckPhyState(WifiPhyState expectedState)
Check the PHY state now.
Definition: wifi-phy-reception-test.cc:2165
TestPhyHeadersReception::m_uid
uint64_t m_uid
the UID to use for the PPDU
Definition: wifi-phy-reception-test.cc:2114
TestPhyHeadersReception::DoTeardown
void DoTeardown() override
Implementation to do any local setup required for this TestCase.
Definition: wifi-phy-reception-test.cc:2197
TestPrimary20CoveredByPpdu
Primary 20 MHz Covered By Ppdu Test This test checks whether the functions WifiPpdu::DoesOverlapChann...
Definition: wifi-phy-reception-test.cc:4576
TestPrimary20CoveredByPpdu::RunOne
void RunOne(WifiPhyBand band, uint16_t phyCenterFreqMhz, uint8_t p20Index, uint16_t ppduCenterFreqMhz, bool expectedP20Overlap, bool expectedP20Covered)
Run one function.
Definition: wifi-phy-reception-test.cc:4659
TestPrimary20CoveredByPpdu::m_phy
Ptr< SpectrumWifiPhy > m_phy
PHY.
Definition: wifi-phy-reception-test.cc:4613
TestPrimary20CoveredByPpdu::DoSetup
void DoSetup() override
Implementation to do any local setup required for this TestCase.
Definition: wifi-phy-reception-test.cc:4641
TestPrimary20CoveredByPpdu::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition: wifi-phy-reception-test.cc:4695
TestPrimary20CoveredByPpdu::CreatePpdu
Ptr< HePpdu > CreatePpdu(WifiPhyBand band, uint16_t ppduCenterFreqMhz)
Function to create a PPDU.
Definition: wifi-phy-reception-test.cc:4623
TestPrimary20CoveredByPpdu::DoTeardown
void DoTeardown() override
Implementation to do any local setup required for this TestCase.
Definition: wifi-phy-reception-test.cc:4652
TestSimpleFrameCaptureModel
Simple frame capture model test.
Definition: wifi-phy-reception-test.cc:1781
TestSimpleFrameCaptureModel::Expect1000BPacketReceived
void Expect1000BPacketReceived()
Verify whether 1000 bytes packet has been received.
Definition: wifi-phy-reception-test.cc:1933
TestSimpleFrameCaptureModel::m_rxDropped1500B
bool m_rxDropped1500B
count dropped packets with 1500B payload
Definition: wifi-phy-reception-test.cc:1843
TestSimpleFrameCaptureModel::DoSetup
void DoSetup() override
Implementation to do any local setup required for this TestCase.
Definition: wifi-phy-reception-test.cc:1962
TestSimpleFrameCaptureModel::Expect1500BPacketDropped
void Expect1500BPacketDropped()
Verify whether 1500 bytes packet has been dropped.
Definition: wifi-phy-reception-test.cc:1951
TestSimpleFrameCaptureModel::Expect1000BPacketDropped
void Expect1000BPacketDropped()
Verify whether 1000 bytes packet has been dropped.
Definition: wifi-phy-reception-test.cc:1945
TestSimpleFrameCaptureModel::SendPacket
void SendPacket(double rxPowerDbm, uint32_t packetSize)
Send packet function.
Definition: wifi-phy-reception-test.cc:1859
TestSimpleFrameCaptureModel::m_phy
Ptr< SpectrumWifiPhy > m_phy
Phy.
Definition: wifi-phy-reception-test.cc:1838
TestSimpleFrameCaptureModel::RxSuccess
void RxSuccess(Ptr< const WifiPsdu > psdu, RxSignalInfo rxSignalInfo, WifiTxVector txVector, std::vector< bool > statusPerMpdu)
Spectrum wifi receive success function.
Definition: wifi-phy-reception-test.cc:1892
TestSimpleFrameCaptureModel::RxDropped
void RxDropped(Ptr< const Packet > p, WifiPhyRxfailureReason reason)
RX dropped function.
Definition: wifi-phy-reception-test.cc:1910
TestSimpleFrameCaptureModel::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition: wifi-phy-reception-test.cc:1995
TestSimpleFrameCaptureModel::m_rxSuccess1000B
bool m_rxSuccess1000B
count received packets with 1000B payload
Definition: wifi-phy-reception-test.cc:1840
TestSimpleFrameCaptureModel::m_rxSuccess1500B
bool m_rxSuccess1500B
count received packets with 1500B payload
Definition: wifi-phy-reception-test.cc:1841
TestSimpleFrameCaptureModel::Expect1500BPacketReceived
void Expect1500BPacketReceived()
Verify whether 1500 bytes packet has been received.
Definition: wifi-phy-reception-test.cc:1939
TestSimpleFrameCaptureModel::m_uid
uint64_t m_uid
the UID to use for the PPDU
Definition: wifi-phy-reception-test.cc:1845
TestSimpleFrameCaptureModel::DoTeardown
void DoTeardown() override
Implementation to do any local setup required for this TestCase.
Definition: wifi-phy-reception-test.cc:1988
TestSimpleFrameCaptureModel::m_rxDropped1000B
bool m_rxDropped1000B
count dropped packets with 1000B payload
Definition: wifi-phy-reception-test.cc:1842
TestThresholdPreambleDetectionWithFrameCapture
Preamble detection test w/o frame capture.
Definition: wifi-phy-reception-test.cc:745
TestThresholdPreambleDetectionWithFrameCapture::CheckPhyState
void CheckPhyState(WifiPhyState expectedState)
Schedule now to check the PHY state.
Definition: wifi-phy-reception-test.cc:844
TestThresholdPreambleDetectionWithFrameCapture::SendPacket
void SendPacket(double rxPowerDbm)
Send packet function.
Definition: wifi-phy-reception-test.cc:811
TestThresholdPreambleDetectionWithFrameCapture::RxFailure
void RxFailure(Ptr< const WifiPsdu > psdu)
Spectrum wifi receive failure function.
Definition: wifi-phy-reception-test.cc:891
TestThresholdPreambleDetectionWithFrameCapture::DoSetup
void DoSetup() override
Implementation to do any local setup required for this TestCase.
Definition: wifi-phy-reception-test.cc:903
TestThresholdPreambleDetectionWithFrameCapture::DoTeardown
void DoTeardown() override
Implementation to do any local setup required for this TestCase.
Definition: wifi-phy-reception-test.cc:930
TestThresholdPreambleDetectionWithFrameCapture::RxSuccess
void RxSuccess(Ptr< const WifiPsdu > psdu, RxSignalInfo rxSignalInfo, WifiTxVector txVector, std::vector< bool > statusPerMpdu)
Spectrum wifi receive success function.
Definition: wifi-phy-reception-test.cc:881
TestThresholdPreambleDetectionWithFrameCapture::DoCheckPhyState
void DoCheckPhyState(WifiPhyState expectedState)
Check the PHY state now.
Definition: wifi-phy-reception-test.cc:854
TestThresholdPreambleDetectionWithFrameCapture::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition: wifi-phy-reception-test.cc:937
TestThresholdPreambleDetectionWithFrameCapture::CheckRxPacketCount
void CheckRxPacketCount(uint32_t expectedSuccessCount, uint32_t expectedFailureCount)
Check the number of received packets.
Definition: wifi-phy-reception-test.cc:869
TestThresholdPreambleDetectionWithoutFrameCapture
Preamble detection test w/o frame capture.
Definition: wifi-phy-reception-test.cc:71
TestThresholdPreambleDetectionWithoutFrameCapture::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition: wifi-phy-reception-test.cc:260
TestThresholdPreambleDetectionWithoutFrameCapture::RxSuccess
void RxSuccess(Ptr< const WifiPsdu > psdu, RxSignalInfo rxSignalInfo, WifiTxVector txVector, std::vector< bool > statusPerMpdu)
Spectrum wifi receive success function.
Definition: wifi-phy-reception-test.cc:208
TestThresholdPreambleDetectionWithoutFrameCapture::CheckRxPacketCount
void CheckRxPacketCount(uint32_t expectedSuccessCount, uint32_t expectedFailureCount)
Check the number of received packets.
Definition: wifi-phy-reception-test.cc:196
TestThresholdPreambleDetectionWithoutFrameCapture::DoCheckPhyState
void DoCheckPhyState(WifiPhyState expectedState)
Check the PHY state now.
Definition: wifi-phy-reception-test.cc:181
TestThresholdPreambleDetectionWithoutFrameCapture::DoTeardown
void DoTeardown() override
Implementation to do any local setup required for this TestCase.
Definition: wifi-phy-reception-test.cc:253
TestThresholdPreambleDetectionWithoutFrameCapture::DoSetup
void DoSetup() override
Implementation to do any local setup required for this TestCase.
Definition: wifi-phy-reception-test.cc:231
TestThresholdPreambleDetectionWithoutFrameCapture::SendPacket
void SendPacket(double rxPowerDbm)
Send packet function.
Definition: wifi-phy-reception-test.cc:137
TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState
void CheckPhyState(WifiPhyState expectedState)
Schedule now to check the PHY state.
Definition: wifi-phy-reception-test.cc:171
TestThresholdPreambleDetectionWithoutFrameCapture::RxFailure
void RxFailure(Ptr< const WifiPsdu > psdu)
Spectrum wifi receive failure function.
Definition: wifi-phy-reception-test.cc:218
TestUnsupportedBandwidthReception
Unsupported Bandwidth Reception Test This test checks whether a PHY receiving a PPDU sent over a chan...
Definition: wifi-phy-reception-test.cc:4308
TestUnsupportedBandwidthReception::DoSetup
void DoSetup() override
Implementation to do any local setup required for this TestCase.
Definition: wifi-phy-reception-test.cc:4504
TestUnsupportedBandwidthReception::m_lastRxDropped
std::optional< Time > m_lastRxDropped
time of last RX drop, if any
Definition: wifi-phy-reception-test.cc:4375
TestUnsupportedBandwidthReception::m_lastRxSucceeded
std::optional< Time > m_lastRxSucceeded
time of last RX success, if any
Definition: wifi-phy-reception-test.cc:4373
TestUnsupportedBandwidthReception::DoTeardown
void DoTeardown() override
Implementation to do any local setup required for this TestCase.
Definition: wifi-phy-reception-test.cc:4522
TestUnsupportedBandwidthReception::CheckRx
void CheckRx(uint32_t expectedCountRxSuccess, uint32_t expectedCountRxFailure, uint32_t expectedCountRxDropped, std::optional< Time > expectedLastRxSucceeded, std::optional< Time > expectedLastRxFailed, std::optional< Time > expectedLastRxDropped)
Check the reception results.
Definition: wifi-phy-reception-test.cc:4456
TestUnsupportedBandwidthReception::RxFailure
void RxFailure(Ptr< const WifiPsdu > psdu)
Function called upon a PSDU received unsuccessfuly.
Definition: wifi-phy-reception-test.cc:4439
TestUnsupportedBandwidthReception::RxSuccess
void RxSuccess(Ptr< const WifiPsdu > psdu, RxSignalInfo rxSignalInfo, WifiTxVector txVector, std::vector< bool > statusPerMpdu)
Function called upon a PSDU received successfully.
Definition: wifi-phy-reception-test.cc:4428
TestUnsupportedBandwidthReception::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition: wifi-phy-reception-test.cc:4529
TestUnsupportedBandwidthReception::m_lastRxFailed
std::optional< Time > m_lastRxFailed
time of last RX failure, if any
Definition: wifi-phy-reception-test.cc:4374
TestUnsupportedBandwidthReception::SendPpdu
void SendPpdu(WifiPhyBand band, uint16_t centerFreqMhz, uint16_t bandwidthMhz)
Function to create a PPDU.
Definition: wifi-phy-reception-test.cc:4393
TestUnsupportedBandwidthReception::RxDropped
void RxDropped(Ptr< const Packet > packet, WifiPhyRxfailureReason reason)
Function called upon a PSDU dropped by the PHY.
Definition: wifi-phy-reception-test.cc:4447
TestUnsupportedModulationReception
Unsupported Modulation Reception Test This test creates a mixed network, in which an HE STA and a VHT...
Definition: wifi-phy-reception-test.cc:4104
TestUnsupportedModulationReception::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition: wifi-phy-reception-test.cc:4154
TestUnsupportedModulationReception::CheckResults
void CheckResults()
Check correctness of transmitted frames.
Definition: wifi-phy-reception-test.cc:4291
TestUnsupportedModulationReception::Dropped
void Dropped(std::string context, Ptr< const Packet > packet, WifiPhyRxfailureReason reason)
Callback invoked when PHY drops an incoming packet.
Definition: wifi-phy-reception-test.cc:4141
TestUnsupportedModulationReception::m_dropped
uint16_t m_dropped
number of packets dropped by the AP because it was already receiving
Definition: wifi-phy-reception-test.cc:4126
WifiPhyReceptionTestSuite
wifi PHY reception Test Suite
Definition: wifi-phy-reception-test.cc:4755
ns3::BooleanValue
AttributeValue implementation for Boolean.
Definition: boolean.h:37
ns3::DoubleValue
This class can be used to hold variables of floating point type such as 'double' or 'float'.
Definition: double.h:42
ns3::MobilityHelper
Helper class used to assign positions and mobility models to nodes.
Definition: mobility-helper.h:44
ns3::NetDeviceContainer
holds a vector of ns3::NetDevice pointers
Definition: net-device-container.h:43
ns3::NetDeviceContainer::Add
void Add(NetDeviceContainer other)
Append the contents of another NetDeviceContainer to the end of this container.
Definition: net-device-container.cc:73
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::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::GetAttribute
void GetAttribute(std::string name, AttributeValue &value) const
Get the value of an attribute, raising fatal errors if unsuccessful.
Definition: object-base.cc:240
ns3::Object::Dispose
void Dispose()
Dispose of this Object.
Definition: object.cc:219
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::PacketSocketAddress
an address for a packet socket
Definition: packet-socket-address.h:40
ns3::PacketSocketAddress::SetProtocol
void SetProtocol(uint16_t protocol)
Set the protocol.
Definition: packet-socket-address.cc:35
ns3::PacketSocketAddress::SetPhysicalAddress
void SetPhysicalAddress(const Address address)
Set the destination address.
Definition: packet-socket-address.cc:58
ns3::PacketSocketAddress::SetSingleDevice
void SetSingleDevice(uint32_t device)
Set the address to match only a specified NetDevice.
Definition: packet-socket-address.cc:50
ns3::PacketSocketHelper
Give ns3::PacketSocket powers to ns3::Node.
Definition: packet-socket-helper.h:32
ns3::PacketSocketHelper::Install
void Install(Ptr< Node > node) const
Aggregate an instance of a ns3::PacketSocketFactory onto the provided node.
Definition: packet-socket-helper.cc:38
ns3::PointerValue
Hold objects of type Ptr<T>.
Definition: pointer.h:37
ns3::PointerValue::Get
Ptr< T > Get() const
Definition: pointer.h:206
ns3::SpectrumWifiPhyHelper
Make it easy to create and manage PHY objects for the spectrum model.
Definition: spectrum-wifi-helper.h:38
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::Ssid
The IEEE 802.11 SSID Information Element.
Definition: ssid.h:36
SsidValue
AttributeValue implementation for Ssid.
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::UintegerValue
Hold an unsigned integer type.
Definition: uinteger.h:45
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::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::SetQosTid
void SetQosTid(uint8_t tid)
Set the TID for the QoS header.
Definition: wifi-mac-header.cc:366
ns3::WifiMacHelper
create MAC layers for a ns3::WifiNetDevice.
Definition: wifi-mac-helper.h:48
ns3::WifiNetDevice::GetMac
Ptr< WifiMac > GetMac() const
Definition: wifi-net-device.cc:289
ns3::WifiPhy::SetInterferenceHelper
virtual void SetInterferenceHelper(const Ptr< InterferenceHelper > helper)
Sets the interference helper.
Definition: wifi-phy.cc:624
ns3::WifiPhy::SetErrorRateModel
void SetErrorRateModel(const Ptr< ErrorRateModel > model)
Sets the error rate model.
Definition: wifi-phy.cc:632
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::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::GetPhyEntity
Ptr< PhyEntity > GetPhyEntity(WifiModulationClass modulation) const
Get the supported PHY entity corresponding to the modulation class.
Definition: wifi-phy.cc:704
ns3::WifiPhy::SetPreambleDetectionModel
void SetPreambleDetectionModel(const Ptr< PreambleDetectionModel > preambleDetectionModel)
Sets the preamble detection model.
Definition: wifi-phy.cc:652
ns3::WifiPhy::SetReceiveOkCallback
void SetReceiveOkCallback(RxOkCallback callback)
Definition: wifi-phy.cc:442
ns3::WifiPhy::SetFrameCaptureModel
void SetFrameCaptureModel(const Ptr< FrameCaptureModel > frameCaptureModel)
Sets the frame capture model.
Definition: wifi-phy.cc:646
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::GetOperatingChannel
const WifiPhyOperatingChannel & GetOperatingChannel() const
Get a const reference to the operating channel.
Definition: wifi-phy.cc:1008
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::WifiPhyOperatingChannel::GetPrimaryChannelCenterFrequency
uint16_t GetPrimaryChannelCenterFrequency(uint16_t primaryChannelWidth) const
Get the center frequency of the primary channel of the given width.
Definition: wifi-phy-operating-channel.cc:492
ns3::WifiPhyStateHelper
This objects implements the PHY state machine of the Wifi device.
Definition: wifi-phy-state-helper.h:69
ns3::WifiPsdu::end
std::vector< Ptr< WifiMpdu > >::const_iterator end() const
Return a const iterator to past-the-last MPDU.
Definition: wifi-psdu.cc:345
ns3::WifiPsdu::begin
std::vector< Ptr< WifiMpdu > >::const_iterator begin() const
Return a const iterator to the first MPDU.
Definition: wifi-psdu.cc:333
ns3::WifiPsdu::GetSize
uint32_t GetSize() const
Return the size of the PSDU in bytes.
Definition: wifi-psdu.cc:273
ns3::WifiPsdu::IsAggregate
bool IsAggregate() const
Return true if the PSDU is an S-MPDU or A-MPDU.
Definition: wifi-psdu.cc:83
ns3::WifiPsdu::IsSingle
bool IsSingle() const
Return true if the PSDU is an S-MPDU.
Definition: wifi-psdu.cc:77
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
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
ns3::Config::SetDefault
void SetDefault(std::string name, const AttributeValue &value)
Definition: config.cc:891
ns3::Config::Connect
void Connect(std::string path, const CallbackBase &cb)
Definition: config.cc:975
NS_ABORT_MSG_IF
#define NS_ABORT_MSG_IF(cond, msg)
Abnormal program termination if a condition is true, with a message.
Definition: abort.h:108
NS_LOG_COMPONENT_DEFINE
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:202
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
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_EXPECT_MSG_EQ
#define NS_TEST_EXPECT_MSG_EQ(actual, limit, msg)
Test that an actual and expected (limit) value are equal and report if not.
Definition: test.h:251
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::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::WIFI_STANDARD_80211ax
@ WIFI_STANDARD_80211ax
Definition: wifi-standards.h:47
ns3::WIFI_STANDARD_80211ac
@ WIFI_STANDARD_80211ac
Definition: wifi-standards.h:45
ns3::UNSUPPORTED_SETTINGS
@ UNSUPPORTED_SETTINGS
Definition: wifi-phy-common.h:316
ns3::RXING
@ RXING
Definition: wifi-phy-common.h:318
ns3::WIFI_PREAMBLE_HE_SU
@ WIFI_PREAMBLE_HE_SU
Definition: wifi-phy-common.h:88
ns3::WIFI_PHY_BAND_2_4GHZ
@ WIFI_PHY_BAND_2_4GHZ
The 2.4 GHz band.
Definition: wifi-phy-band.h:35
ns3::WIFI_PHY_BAND_5GHZ
@ WIFI_PHY_BAND_5GHZ
The 5 GHz band.
Definition: wifi-phy-band.h:37
ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.
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::DbmToW
double DbmToW(double dBm)
Convert from dBm to Watts.
Definition: wifi-utils.cc:40
ns3::WIFI_MAC_QOSDATA
@ WIFI_MAC_QOSDATA
Definition: wifi-mac-header.h:80
third.mac
mac
Definition: third.py:85
third.wifi
wifi
Definition: third.py:88
third.wifiApNode
wifiApNode
Definition: third.py:79
third.mobility
mobility
Definition: third.py:96
third.wifiStaNodes
wifiStaNodes
Definition: third.py:77
third.phy
phy
Definition: third.py:82
ns3::RxSignalInfo
RxSignalInfo structure containing info on the received signal.
Definition: phy-entity.h:70
CHANNEL_NUMBER
static const uint8_t CHANNEL_NUMBER
Definition: wifi-phy-reception-test.cc:58
GUARD_WIDTH
static const uint16_t GUARD_WIDTH
Definition: wifi-phy-reception-test.cc:61
CHANNEL_WIDTH
static const uint16_t CHANNEL_WIDTH
Definition: wifi-phy-reception-test.cc:60
wifiPhyReceptionTestSuite
static WifiPhyReceptionTestSuite wifiPhyReceptionTestSuite
the test suite
Definition: wifi-phy-reception-test.cc:4773
FREQUENCY
static const uint32_t FREQUENCY
Definition: wifi-phy-reception-test.cc:59
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
packetSize
static const uint32_t packetSize
Packet size generated at the AP.
Definition: wifi-power-adaptation-distance.cc:111
SendPacket
void SendPacket(Ptr< NetDevice > sourceDevice, Address &destination)
This example (inspired from tv-trans-example) enables to generate the transmitted spectra of Wi-Fi st...
Definition: wifi-trans-example.cc:47