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