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