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