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