20#include "ns3/ap-wifi-mac.h"
21#include "ns3/boolean.h"
22#include "ns3/constant-position-mobility-model.h"
23#include "ns3/he-configuration.h"
24#include "ns3/he-phy.h"
25#include "ns3/interference-helper.h"
27#include "ns3/mobility-helper.h"
28#include "ns3/multi-model-spectrum-channel.h"
29#include "ns3/nist-error-rate-model.h"
31#include "ns3/non-communicating-net-device.h"
32#include "ns3/rng-seed-manager.h"
33#include "ns3/simulator.h"
34#include "ns3/spectrum-wifi-helper.h"
35#include "ns3/spectrum-wifi-phy.h"
36#include "ns3/sta-wifi-mac.h"
38#include "ns3/waveform-generator.h"
39#include "ns3/wifi-mac-header.h"
40#include "ns3/wifi-net-device.h"
41#include "ns3/wifi-psdu.h"
42#include "ns3/wifi-spectrum-signal-parameters.h"
43#include "ns3/wifi-spectrum-value-helper.h"
44#include "ns3/wifi-utils.h"
205 using StasParams = std::vector<std::tuple<WifiStandard, uint16_t, uint8_t>>;
218 uint16_t apFrequency,
221 std::vector<bool> per20MhzInterference = {});
226 void DoRun()
override;
240 std::vector<bool> statusPerMpdu);
297 std::vector<Ptr<WaveformGenerator>>
303 uint16_t apFrequency,
306 std::vector<bool> per20MhzInterference)
307 :
TestCase{
"non-HT duplicate PHY reception test"},
308 m_apStandard{apStandard},
309 m_apFrequency{apFrequency},
310 m_apP20Index{apP20Index},
311 m_stasParams{stasParams},
312 m_per20MhzInterference{per20MhzInterference},
313 m_countRxSuccessStas{},
314 m_countRxFailureStas{},
365 interferer->SetTxPowerSpectralDensity(interferencePsd);
366 interferer->SetPeriod(duration);
404 NS_LOG_FUNCTION(
this << index << expectedRxSuccess << expectedRxFailure);
407 "The number of successfully received packets by STA "
408 << index <<
" is not correct!");
411 "The number of unsuccessfully received packets by STA "
412 << index <<
" is not correct!");
418 auto spectrumChannel = CreateObject<MultiModelSpectrumChannel>();
419 auto lossModel = CreateObject<FriisPropagationLossModel>();
421 spectrumChannel->AddPropagationLossModel(lossModel);
422 auto delayModel = CreateObject<ConstantSpeedPropagationDelayModel>();
423 spectrumChannel->SetPropagationDelayModel(delayModel);
425 auto apNode = CreateObject<Node>();
426 auto apDev = CreateObject<WifiNetDevice>();
427 m_phyAp = CreateObject<SpectrumWifiPhy>();
428 auto apInterferenceHelper = CreateObject<InterferenceHelper>();
430 auto apErrorModel = CreateObject<NistErrorRateModel>();
435 auto apMobility = CreateObject<ConstantPositionMobilityModel>();
438 apNode->AggregateObject(apMobility);
439 apNode->AddDevice(apDev);
443 auto staNode = CreateObject<Node>();
444 auto staDev = CreateObject<WifiNetDevice>();
445 auto staPhy = CreateObject<SpectrumWifiPhy>();
446 auto sta1InterferenceHelper = CreateObject<InterferenceHelper>();
447 staPhy->SetInterferenceHelper(sta1InterferenceHelper);
448 auto sta1ErrorModel = CreateObject<NistErrorRateModel>();
449 staPhy->SetErrorRateModel(sta1ErrorModel);
450 staPhy->SetDevice(staDev);
451 staPhy->AddChannel(spectrumChannel);
452 staPhy->ConfigureStandard(std::get<0>(staParams));
453 staPhy->SetReceiveOkCallback(
455 staPhy->SetReceiveErrorCallback(
457 auto staMobility = CreateObject<ConstantPositionMobilityModel>();
458 staPhy->SetMobility(staMobility);
459 staDev->SetPhy(staPhy);
460 staNode->AggregateObject(staMobility);
461 staNode->AddDevice(staDev);
469 [[maybe_unused]]
auto [channelNum, centerFreq, apChannelWidth, type, phyBand] =
478 auto interfererNode = CreateObject<Node>();
479 auto interfererDev = CreateObject<NonCommunicatingNetDevice>();
480 auto phyInterferer = CreateObject<WaveformGenerator>();
481 phyInterferer->SetDevice(interfererDev);
482 phyInterferer->SetChannel(spectrumChannel);
483 phyInterferer->SetDutyCycle(1);
484 interfererNode->AddDevice(interfererDev);
502 phyInterferer->Dispose();
503 phyInterferer =
nullptr;
512 int64_t streamNumber = 0;
516 phySta->AssignStreams(streamNumber);
519 [[maybe_unused]]
auto [apChannelNum, centerFreq, apChannelWidth, type, phyBand] =
529 for (
const auto& [staStandard, staFrequency, staP20Index] :
m_stasParams)
531 [[maybe_unused]]
auto [staChannelNum, centerFreq, staChannelWidth, type, phyBand] =
537 m_phyStas.at(index++)->SetOperatingChannel(
542 const auto minApCenterFrequency =
544 for (
auto channelWidth = 20; channelWidth <= apChannelWidth; channelWidth *= 2, ++index)
555 bandInfo.
fc = (minApCenterFrequency + (i * 20)) * 1e6;
556 bandInfo.
fl = bandInfo.
fc - (5 * 1e6);
557 bandInfo.
fh = bandInfo.
fc + (5 * 1e6);
559 bands.push_back(bandInfo);
560 auto spectrumInterference = Create<SpectrumModel>(bands);
561 auto interferencePsd = Create<SpectrumValue>(spectrumInterference);
562 auto interferencePower = 0.005;
564 *interferencePsd = interferencePower / 10e6;
573 const auto apCenterFreq =
575 const auto apMinFreq = apCenterFreq - (channelWidth / 2);
576 const auto apMaxFreq = apCenterFreq + (channelWidth / 2);
583 const auto p20Width = 20;
584 const auto staP20Freq =
585 m_phyStas.at(i)->GetOperatingChannel().GetPrimaryChannelCenterFrequency(p20Width);
586 const auto staP20MinFreq = staP20Freq - (p20Width / 2);
587 const auto staP20MaxFreq = staP20Freq + (p20Width / 2);
588 bool expectRx = (staP20MinFreq >= apMinFreq && staP20MaxFreq <= apMaxFreq);
589 bool expectSuccess =
true;
592 const auto index20MhzSubBand = ((staP20Freq - minApCenterFrequency) / 20);
599 expectRx ? expectSuccess : 0,
600 expectRx ? !expectSuccess : 0);
633 void DoRun()
override;
660 std::vector<bool> statusPerMpdu);
673 void CheckResults(std::size_t expectedRxCtsSuccess, std::size_t expectedRxCtsFailure);
688 const std::vector<uint16_t>& bwPerSta)
689 :
TestCase{
"test PHY reception of multiple CTS frames following a MU-RTS frame"},
690 m_bwPerSta{bwPerSta},
691 m_countRxCtsSuccess{0},
692 m_countRxCtsFailure{0},
693 m_stasTxPowerDbm(10.0)
712 phySta->SetPpduUid(0);
741 auto pkt = Create<Packet>();
742 auto mpdu = Create<WifiMpdu>(pkt, hdr);
743 auto psdu = Create<WifiPsdu>(mpdu,
false);
745 phy->Send(psdu, txVector);
758 "RX power is not correct!");
771 std::size_t expectedRxCtsFailure)
774 expectedRxCtsSuccess,
775 "The number of successfully received CTS frames by AP is not correct!");
777 expectedRxCtsFailure,
778 "The number of unsuccessfully received CTS frames by AP is not correct!");
786 int64_t streamNumber = 0;
788 auto spectrumChannel = CreateObject<MultiModelSpectrumChannel>();
789 auto lossModel = CreateObject<FriisPropagationLossModel>();
791 spectrumChannel->AddPropagationLossModel(lossModel);
792 auto delayModel = CreateObject<ConstantSpeedPropagationDelayModel>();
793 spectrumChannel->SetPropagationDelayModel(delayModel);
795 auto apNode = CreateObject<Node>();
796 auto apDev = CreateObject<WifiNetDevice>();
797 auto apMac = CreateObject<ApWifiMac>();
798 apMac->SetAttribute(
"BeaconGeneration",
BooleanValue(
false));
799 apDev->SetMac(apMac);
800 m_phyAp = CreateObject<MuRtsCtsSpectrumWifiPhy>();
801 apDev->SetHeConfiguration(CreateObject<HeConfiguration>());
802 auto apInterferenceHelper = CreateObject<InterferenceHelper>();
804 auto apErrorModel = CreateObject<NistErrorRateModel>();
817 auto apChannelNum = std::get<0>(
822 auto apMobility = CreateObject<ConstantPositionMobilityModel>();
826 apDev->SetHeConfiguration(CreateObject<HeConfiguration>());
828 apNode->AggregateObject(apMobility);
829 apNode->AddDevice(apDev);
831 for (std::size_t i = 0; i <
m_bwPerSta.size(); ++i)
833 auto staNode = CreateObject<Node>();
834 auto staDev = CreateObject<WifiNetDevice>();
835 auto phySta = CreateObject<MuRtsCtsSpectrumWifiPhy>();
836 auto staInterferenceHelper = CreateObject<InterferenceHelper>();
837 phySta->SetInterferenceHelper(staInterferenceHelper);
838 auto staErrorModel = CreateObject<NistErrorRateModel>();
839 phySta->SetErrorRateModel(staErrorModel);
840 phySta->SetDevice(staDev);
841 phySta->AddChannel(spectrumChannel);
843 phySta->AssignStreams(streamNumber);
853 phySta->SetOperatingChannel(
856 auto staMobility = CreateObject<ConstantPositionMobilityModel>();
857 phySta->SetMobility(staMobility);
858 staDev->SetPhy(phySta);
860 staDev->SetHeConfiguration(CreateObject<HeConfiguration>());
861 staNode->AggregateObject(staMobility);
862 staNode->AddDevice(staDev);
867 auto nonHeStaNode = CreateObject<Node>();
868 auto nonHeStaDev = CreateObject<WifiNetDevice>();
870 auto nonHeStaInterferenceHelper = CreateObject<InterferenceHelper>();
872 auto nonHeStaErrorModel = CreateObject<NistErrorRateModel>();
879 auto nonHeStaMobility = CreateObject<ConstantPositionMobilityModel>();
884 nonHeStaNode->AggregateObject(nonHeStaMobility);
885 nonHeStaNode->AddDevice(nonHeStaDev);
910 std::size_t index = 1;
995 {
false,
true,
false,
false}),
HE PHY used for testing MU-RTS/CTS.
void SetPreviousTxPpduUid(uint64_t uid)
Set the previous TX PPDU UID counter.
void SetMuRtsTxVector(const WifiTxVector &muRtsTxVector)
Set the TXVECTOR of the previously transmitted MU-RTS.
~MuRtsCtsHePhy() override
Spectrum PHY used for testing MU-RTS/CTS.
void DoDispose() override
Destructor implementation.
MuRtsCtsSpectrumWifiPhy()
~MuRtsCtsSpectrumWifiPhy() override
Ptr< MuRtsCtsHePhy > m_muRtsCtsHePhy
Pointer to HE PHY instance used for MU-RTS/CTS PHY test.
void SetPpduUid(uint64_t uid)
Set the global PPDU UID counter.
void SetMuRtsTxVector(const WifiTxVector &muRtsTxVector)
Set the TXVECTOR of the previously transmitted MU-RTS.
void DoInitialize() override
Initialize() implementation.
static TypeId GetTypeId()
Get the type ID.
test PHY reception of multiple CTS frames as a response to a MU-RTS frame.
void FakePreviousMuRts(uint16_t bw)
Function called to fake the transmission of a MU-RTS.
Ptr< SpectrumWifiPhy > m_nonHePhySta
non-HE STA PHY
void DoSetup() override
Implementation to do any local setup required for this TestCase.
void RxCtsFailure(Ptr< const WifiPsdu > psdu)
CTS RX failure function.
TestMultipleCtsResponsesFromMuRts(const std::vector< uint16_t > &bwPerSta)
Constructor.
std::vector< uint16_t > m_bwPerSta
Bandwidth per STA in MHz.
std::size_t m_countRxCtsFailure
count the number of unsuccessfully received CTS frames
void RxCtsSuccess(Ptr< const WifiPsdu > psdu, RxSignalInfo rxSignalInfo, WifiTxVector txVector, std::vector< bool > statusPerMpdu)
CTS RX success function.
std::vector< Ptr< MuRtsCtsSpectrumWifiPhy > > m_phyStas
STAs PHYs.
std::size_t m_countRxCtsSuccess
count the number of successfully received CTS frames
void DoTeardown() override
Implementation to do any local setup required for this TestCase.
void DoRun() override
Implementation to actually run this TestCase.
void CheckResults(std::size_t expectedRxCtsSuccess, std::size_t expectedRxCtsFailure)
Check the results.
Ptr< MuRtsCtsSpectrumWifiPhy > m_phyAp
AP PHY.
double m_stasTxPowerDbm
TX power in dBm configured for the STAs.
void TxNonHtDuplicateCts(Ptr< SpectrumWifiPhy > phy, uint16_t bw)
Function called to trigger a CTS frame sent by a STA using non-HT duplicate.
non-HT duplicate PHY reception test The test consists in an AP sending a single non-HT duplicate PPDU...
void GenerateInterference(Ptr< WaveformGenerator > interferer, Ptr< SpectrumValue > interferencePsd, Time duration)
Generate interference function.
std::vector< bool > m_per20MhzInterference
flags per 20 MHz subchannel whether an interference should be generated on that subchannel
void DoTeardown() override
Implementation to do any local setup required for this TestCase.
void ResetResults()
Reset the results.
std::vector< Ptr< SpectrumWifiPhy > > m_phyStas
PHYs of STAs.
void RxFailure(std::size_t index, Ptr< const WifiPsdu > psdu)
Receive failure function.
std::vector< uint32_t > m_countRxFailureStas
count RX failure for STAs
void SendNonHtDuplicatePpdu(uint16_t channelWidth)
Send non-HT duplicate PPDU function.
StasParams m_stasParams
the parameters of the STAs
std::vector< std::tuple< WifiStandard, uint16_t, uint8_t > > StasParams
A vector containing parameters per STA: the standard, the center frequency and the P20 index.
void CheckResults(std::size_t index, uint32_t expectedRxSuccess, uint32_t expectedRxFailure)
Check the results.
void StopInterference(Ptr< WaveformGenerator > interferer)
Stop interference function.
void DoSetup() override
Implementation to do any local setup required for this TestCase.
TestNonHtDuplicatePhyReception(WifiStandard apStandard, uint16_t apFrequency, uint8_t apP20Index, StasParams stasParams, std::vector< bool > per20MhzInterference={})
Constructor.
void RxSuccess(std::size_t index, Ptr< const WifiPsdu > psdu, RxSignalInfo rxSignalInfo, WifiTxVector txVector, std::vector< bool > statusPerMpdu)
Receive success function.
WifiStandard m_apStandard
the standard to use for the AP
Ptr< SpectrumWifiPhy > m_phyAp
PHY of AP.
uint8_t m_apP20Index
the index of the primary 20 MHz channel of the AP
void DoRun() override
Implementation to actually run this TestCase.
std::vector< uint32_t > m_countRxSuccessStas
count RX success for STAs
std::vector< Ptr< WaveformGenerator > > m_phyInterferers
PHYs of interferers (1 interferer per 20 MHz subchannel)
uint16_t m_apFrequency
the center frequency of the AP (in MHz)
wifi non-HT duplicate Test Suite
WifiNonHtDuplicateTestSuite()
AttributeValue implementation for Boolean.
std::optional< WifiTxVector > m_currentTxVector
If the STA is an AP STA, this holds the TXVECTOR of the PPDU that has been sent.
uint64_t m_previouslyTxPpduUid
UID of the previously sent PPDU, used by AP to recognize response HE TB PPDUs.
void Dispose()
Dispose of this Object.
static WifiMode GetOfdmRate54Mbps()
Return a WifiMode for OFDM at 54 Mbps.
static WifiMode GetOfdmRate24Mbps()
Return a WifiMode for OFDM at 24 Mbps.
void SetOwner(Ptr< WifiPhy > wifiPhy)
Set the WifiPhy owning this PHY entity.
Smart pointer class similar to boost::intrusive_ptr.
static void SetRun(uint64_t run)
Set the run number of simulation.
static void SetSeed(uint32_t seed)
Set the seed.
static EventId Schedule(const Time &delay, FUNC f, Ts &&... args)
Schedule an event to expire after delay.
static void Destroy()
Execute the events scheduled with ScheduleDestroy().
static void Run()
Run the simulation.
void SetDevice(const Ptr< WifiNetDevice > device) override
Sets the device this PHY is associated with.
void DoInitialize() override
Initialize() implementation.
void AddChannel(const Ptr< SpectrumChannel > channel, const FrequencyRange &freqRange=WHOLE_WIFI_SPECTRUM)
Attach a SpectrumChannel to use for a given frequency range.
void DoDispose() override
Destructor implementation.
void AddTestCase(TestCase *testCase, TestDuration duration=QUICK)
Add an individual child TestCase to this test suite.
Simulation virtual time values and global simulation resolution.
a unique identifier for an interface.
TypeId SetParent(TypeId tid)
Set the parent TypeId.
virtual void SetInterferenceHelper(const Ptr< InterferenceHelper > helper)
Sets the interference helper.
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.
void SetErrorRateModel(const Ptr< ErrorRateModel > model)
Sets the error rate model.
uint16_t GetChannelWidth() const
uint16_t GetFrequency() const
void SetReceiveErrorCallback(RxErrorCallback callback)
virtual void ConfigureStandard(WifiStandard standard)
Configure the PHY-level parameters for different Wi-Fi standard.
static Time CalculateTxDuration(uint32_t size, const WifiTxVector &txVector, WifiPhyBand band, uint16_t staId=SU_STA_ID)
std::map< WifiModulationClass, Ptr< PhyEntity > > m_phyEntities
This map holds the supported PHY entities.
void SetOperatingChannel(const ChannelTuple &channelTuple)
If the standard for this object has not been set yet, store the given channel settings.
WifiPhyBand GetPhyBand() const
Get the configured Wi-Fi band.
uint64_t m_previouslyRxPpduUid
UID of the previously received PPDU, reset to UINT64_MAX upon transmission.
void SetMobility(const Ptr< MobilityModel > mobility)
assign a mobility model to this device
void SetReceiveOkCallback(RxOkCallback callback)
std::tuple< uint8_t, uint16_t, int, uint8_t > ChannelTuple
Tuple identifying an operating channel.
const WifiPhyOperatingChannel & GetOperatingChannel() const
Get a const reference to the operating channel.
virtual int64_t AssignStreams(int64_t stream)
Assign a fixed random variable stream number to the random variables used by this model.
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.
uint16_t GetPrimaryChannelCenterFrequency(uint16_t primaryChannelWidth) const
Get the center frequency of the primary channel of the given width.
This class mimics the TXVECTOR which is to be passed to the PHY in order to define the parameters whi...
void SetChannelWidth(uint16_t channelWidth)
Sets the selected channelWidth (in MHz)
void SetTriggerResponding(bool triggerResponding)
Set the Trigger Responding parameter to the given value.
#define NS_ASSERT(condition)
At runtime, in debugging builds, if this condition is not true, the program prints the source file,...
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
#define NS_LOG_FUNCTION(parameters)
If log level LOG_FUNCTION is enabled, this macro will output all input parameters separated by ",...
#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.
#define NS_TEST_EXPECT_MSG_EQ_TOL(actual, limit, tol, msg)
Test that actual and expected (limit) values are equal to plus or minus some tolerance and report if ...
Time NanoSeconds(uint64_t value)
Construct a Time in the indicated unit.
Time Seconds(double value)
Construct a Time in the indicated unit.
WifiStandard
Identifies the IEEE 802.11 specifications that a Wifi device can be configured to use.
@ WIFI_PHY_BAND_5GHZ
The 5 GHz band.
@ WIFI_MOD_CLASS_HE
HE (Clause 27)
Every class exported by the ns3 library is enclosed in the ns3 namespace.
std::unordered_map< uint16_t, Ptr< const WifiPsdu > > WifiConstPsduMap
Map of const PSDUs indexed by STA-ID.
double WToDbm(double w)
Convert from Watts to dBm.
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...
std::vector< BandInfo > Bands
Container of BandInfo.
double DbmToW(double dBm)
Convert from dBm to Watts.
static constexpr uint16_t SU_STA_ID
STA_ID to identify a single user (SU)
The building block of a SpectrumModel.
double fc
center frequency
double fl
lower limit of subband
double fh
upper limit of subband
RxSignalInfo structure containing info on the received signal.
static WifiNonHtDuplicateTestSuite wifiNonHtDuplicateTestSuite
the test suite
constexpr uint32_t DEFAULT_FREQUENCY