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