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/pointer.h"
33#include "ns3/rng-seed-manager.h"
34#include "ns3/simulator.h"
35#include "ns3/spectrum-wifi-helper.h"
36#include "ns3/spectrum-wifi-phy.h"
37#include "ns3/sta-wifi-mac.h"
38#include "ns3/string.h"
41#include "ns3/waveform-generator.h"
42#include "ns3/wifi-mac-header.h"
43#include "ns3/wifi-net-device.h"
44#include "ns3/wifi-psdu.h"
45#include "ns3/wifi-spectrum-signal-parameters.h"
46#include "ns3/wifi-spectrum-value-helper.h"
47#include "ns3/wifi-utils.h"
208 using StasParams = std::vector<std::tuple<WifiStandard, uint16_t, uint8_t>>;
221 uint16_t apFrequency,
224 std::vector<bool> per20MhzInterference = {});
229 void DoRun()
override;
243 std::vector<bool> statusPerMpdu);
300 std::vector<Ptr<WaveformGenerator>>
306 uint16_t apFrequency,
309 std::vector<bool> per20MhzInterference)
310 :
TestCase{
"non-HT duplicate PHY reception test"},
311 m_apStandard{apStandard},
312 m_apFrequency{apFrequency},
313 m_apP20Index{apP20Index},
314 m_stasParams{stasParams},
315 m_per20MhzInterference{per20MhzInterference},
316 m_countRxSuccessStas{},
317 m_countRxFailureStas{},
368 interferer->SetTxPowerSpectralDensity(interferencePsd);
369 interferer->SetPeriod(duration);
392 const auto expectedWidth =
396 "Incorrect channel width in TXVECTOR");
412 NS_LOG_FUNCTION(
this << index << expectedRxSuccess << expectedRxFailure);
415 "The number of successfully received packets by STA "
416 << index <<
" is not correct!");
419 "The number of unsuccessfully received packets by STA "
420 << index <<
" is not correct!");
426 auto spectrumChannel = CreateObject<MultiModelSpectrumChannel>();
427 auto lossModel = CreateObject<FriisPropagationLossModel>();
429 spectrumChannel->AddPropagationLossModel(lossModel);
430 auto delayModel = CreateObject<ConstantSpeedPropagationDelayModel>();
431 spectrumChannel->SetPropagationDelayModel(delayModel);
433 auto apNode = CreateObject<Node>();
434 auto apDev = CreateObject<WifiNetDevice>();
435 m_phyAp = CreateObject<SpectrumWifiPhy>();
436 auto apInterferenceHelper = CreateObject<InterferenceHelper>();
438 auto apErrorModel = CreateObject<NistErrorRateModel>();
443 auto apMobility = CreateObject<ConstantPositionMobilityModel>();
446 apNode->AggregateObject(apMobility);
447 apNode->AddDevice(apDev);
451 auto staNode = CreateObject<Node>();
452 auto staDev = CreateObject<WifiNetDevice>();
453 auto staPhy = CreateObject<SpectrumWifiPhy>();
454 auto sta1InterferenceHelper = CreateObject<InterferenceHelper>();
455 staPhy->SetInterferenceHelper(sta1InterferenceHelper);
456 auto sta1ErrorModel = CreateObject<NistErrorRateModel>();
457 staPhy->SetErrorRateModel(sta1ErrorModel);
458 staPhy->SetDevice(staDev);
459 staPhy->AddChannel(spectrumChannel);
460 staPhy->ConfigureStandard(std::get<0>(staParams));
461 staPhy->SetReceiveOkCallback(
463 staPhy->SetReceiveErrorCallback(
465 auto staMobility = CreateObject<ConstantPositionMobilityModel>();
466 staPhy->SetMobility(staMobility);
467 staDev->SetPhy(staPhy);
468 staNode->AggregateObject(staMobility);
469 staNode->AddDevice(staDev);
477 [[maybe_unused]]
auto [channelNum, centerFreq, apChannelWidth, type, phyBand] =
486 auto interfererNode = CreateObject<Node>();
487 auto interfererDev = CreateObject<NonCommunicatingNetDevice>();
488 auto phyInterferer = CreateObject<WaveformGenerator>();
489 phyInterferer->SetDevice(interfererDev);
490 phyInterferer->SetChannel(spectrumChannel);
491 phyInterferer->SetDutyCycle(1);
492 interfererNode->AddDevice(interfererDev);
510 phyInterferer->Dispose();
511 phyInterferer =
nullptr;
520 int64_t streamNumber = 0;
524 phySta->AssignStreams(streamNumber);
527 [[maybe_unused]]
auto [apChannelNum, centerFreq, apChannelWidth, type, phyBand] =
537 for (
const auto& [staStandard, staFrequency, staP20Index] :
m_stasParams)
539 [[maybe_unused]]
auto [staChannelNum, centerFreq, staChannelWidth, type, phyBand] =
545 m_phyStas.at(index++)->SetOperatingChannel(
550 const auto minApCenterFrequency =
552 for (
auto channelWidth = 20; channelWidth <= apChannelWidth; channelWidth *= 2, ++index)
563 bandInfo.
fc = (minApCenterFrequency + (i * 20)) * 1e6;
564 bandInfo.
fl = bandInfo.
fc - (5 * 1e6);
565 bandInfo.
fh = bandInfo.
fc + (5 * 1e6);
567 bands.push_back(bandInfo);
568 auto spectrumInterference = Create<SpectrumModel>(bands);
569 auto interferencePsd = Create<SpectrumValue>(spectrumInterference);
570 auto interferencePower = 0.005;
572 *interferencePsd = interferencePower / 10e6;
581 const auto apCenterFreq =
583 const auto apMinFreq = apCenterFreq - (channelWidth / 2);
584 const auto apMaxFreq = apCenterFreq + (channelWidth / 2);
591 const auto p20Width = 20;
592 const auto staP20Freq =
593 m_phyStas.at(i)->GetOperatingChannel().GetPrimaryChannelCenterFrequency(p20Width);
594 const auto staP20MinFreq = staP20Freq - (p20Width / 2);
595 const auto staP20MaxFreq = staP20Freq + (p20Width / 2);
596 bool expectRx = (staP20MinFreq >= apMinFreq && staP20MaxFreq <= apMaxFreq);
597 bool expectSuccess =
true;
600 const auto index20MhzSubBand = ((staP20Freq - minApCenterFrequency) / 20);
607 expectRx ? expectSuccess : 0,
608 expectRx ? !expectSuccess : 0);
651 void DoRun()
override;
677 std::vector<bool> statusPerMpdu);
709 const std::vector<CtsTxInfos>& ctsTxInfosPerSta)
710 :
TestCase{
"test PHY reception of multiple CTS frames following a MU-RTS frame"},
711 m_ctsTxInfosPerSta{ctsTxInfosPerSta},
712 m_countApRxCtsSuccess{0},
713 m_countApRxCtsFailure{0},
714 m_countStaRxCtsSuccess{0},
715 m_countStaRxCtsFailure{0},
716 m_stasTxPowerDbm(10.0)
728 [](
const auto& lhs,
const auto& rhs) { return lhs.bw < rhs.bw; })
740 phySta->SetPpduUid(0);
776 auto pkt = Create<Packet>();
777 auto mpdu = Create<WifiMpdu>(pkt, hdr);
778 auto psdu = Create<WifiPsdu>(mpdu,
false);
780 m_phyStas.at(phyIndex)->Send(psdu, txVector);
790 NS_LOG_FUNCTION(
this << phyIndex << *psdu << rxSignalInfo << txVector);
791 std::vector<CtsTxInfos> successfulCtsInfos{};
794 std::back_inserter(successfulCtsInfos),
795 [](
const auto& info) { return !info.discard; });
796 const auto isAp = (phyIndex == 0);
802 "RX power is not correct!");
805 std::max_element(successfulCtsInfos.cbegin(),
806 successfulCtsInfos.cend(),
807 [](
const auto& lhs,
const auto& rhs) { return lhs.bw < rhs.bw; })
815 "Incorrect channel width in TXVECTOR");
830 const auto isAp = (phyIndex == 0);
846 "The number of successfully received CTS frames by AP is not correct!");
850 "The number of successfully received CTS frames by non-participating STAs is not correct!");
853 "The number of unsuccessfully received CTS frames by AP is not correct!");
856 "The number of unsuccessfully received CTS frames by non-participating "
857 "STAs is not correct!");
865 int64_t streamNumber = 0;
867 auto spectrumChannel = CreateObject<MultiModelSpectrumChannel>();
868 auto lossModel = CreateObject<FriisPropagationLossModel>();
870 spectrumChannel->AddPropagationLossModel(lossModel);
871 auto delayModel = CreateObject<ConstantSpeedPropagationDelayModel>();
872 spectrumChannel->SetPropagationDelayModel(delayModel);
874 auto apNode = CreateObject<Node>();
875 auto apDev = CreateObject<WifiNetDevice>();
876 auto apMac = CreateObjectWithAttributes<ApWifiMac>(
879 apMac->SetAttribute(
"BeaconGeneration",
BooleanValue(
false));
880 apDev->SetMac(apMac);
881 m_phyAp = CreateObject<MuRtsCtsSpectrumWifiPhy>();
882 apDev->SetHeConfiguration(CreateObject<HeConfiguration>());
883 auto apInterferenceHelper = CreateObject<InterferenceHelper>();
885 auto apErrorModel = CreateObject<NistErrorRateModel>();
900 [](
const auto& lhs,
const auto& rhs) { return lhs.bw < rhs.bw; })
902 auto apChannelNum = std::get<0>(
907 auto apMobility = CreateObject<ConstantPositionMobilityModel>();
911 apDev->SetHeConfiguration(CreateObject<HeConfiguration>());
913 apNode->AggregateObject(apMobility);
914 apNode->AddDevice(apDev);
918 auto staNode = CreateObject<Node>();
919 auto staDev = CreateObject<WifiNetDevice>();
920 auto phySta = CreateObject<MuRtsCtsSpectrumWifiPhy>();
921 auto staInterferenceHelper = CreateObject<InterferenceHelper>();
922 phySta->SetInterferenceHelper(staInterferenceHelper);
923 auto staErrorModel = CreateObject<NistErrorRateModel>();
924 phySta->SetErrorRateModel(staErrorModel);
925 phySta->SetDevice(staDev);
926 phySta->AddChannel(spectrumChannel);
928 phySta->AssignStreams(streamNumber);
939 phySta->SetOperatingChannel(
942 auto staMobility = CreateObject<ConstantPositionMobilityModel>();
943 phySta->SetMobility(staMobility);
944 staDev->SetPhy(phySta);
946 staDev->SetHeConfiguration(CreateObject<HeConfiguration>());
947 staNode->AggregateObject(staMobility);
948 staNode->AddDevice(staDev);
952 auto nonParticipatingHeStaNode = CreateObject<Node>();
953 auto nonParticipatingHeStaDev = CreateObject<WifiNetDevice>();
954 auto nonParticipatingHePhySta = CreateObject<SpectrumWifiPhy>();
955 auto nonParticipatingHeStaInterferenceHelper = CreateObject<InterferenceHelper>();
956 nonParticipatingHePhySta->SetInterferenceHelper(nonParticipatingHeStaInterferenceHelper);
957 auto nonParticipatingHeStaErrorModel = CreateObject<NistErrorRateModel>();
958 nonParticipatingHePhySta->SetErrorRateModel(nonParticipatingHeStaErrorModel);
959 nonParticipatingHePhySta->SetDevice(nonParticipatingHeStaDev);
960 nonParticipatingHePhySta->AddChannel(spectrumChannel);
963 nonParticipatingHePhySta->SetOperatingChannel(
966 auto nonParticipatingHeStaMobility = CreateObject<ConstantPositionMobilityModel>();
967 nonParticipatingHePhySta->SetMobility(nonParticipatingHeStaMobility);
968 nonParticipatingHeStaDev->SetPhy(nonParticipatingHePhySta);
970 nonParticipatingHeStaDev->SetHeConfiguration(CreateObject<HeConfiguration>());
971 nonParticipatingHePhySta->AssignStreams(streamNumber);
972 nonParticipatingHeStaNode->AggregateObject(nonParticipatingHeStaMobility);
973 nonParticipatingHeStaNode->AddDevice(nonParticipatingHeStaDev);
975 nonParticipatingHePhySta->SetReceiveOkCallback(
977 nonParticipatingHePhySta->SetReceiveErrorCallback(
982 auto nonHeStaNode = CreateObject<Node>();
983 auto nonHeStaDev = CreateObject<WifiNetDevice>();
984 auto nonHePhySta = CreateObject<SpectrumWifiPhy>();
985 auto nonHeStaInterferenceHelper = CreateObject<InterferenceHelper>();
986 nonHePhySta->SetInterferenceHelper(nonHeStaInterferenceHelper);
987 auto nonHeStaErrorModel = CreateObject<NistErrorRateModel>();
988 nonHePhySta->SetErrorRateModel(nonHeStaErrorModel);
989 nonHePhySta->SetDevice(nonHeStaDev);
990 nonHePhySta->AddChannel(spectrumChannel);
992 nonHePhySta->SetOperatingChannel(
994 auto nonHeStaMobility = CreateObject<ConstantPositionMobilityModel>();
995 nonHePhySta->SetMobility(nonHeStaMobility);
996 nonHeStaDev->SetPhy(nonHePhySta);
998 nonHePhySta->AssignStreams(streamNumber);
999 nonHeStaNode->AggregateObject(nonHeStaMobility);
1000 nonHeStaNode->AddDevice(nonHeStaDev);
1022 for (std::size_t index = 0; index <
m_phyStas.size(); ++index)
1026 const auto delay = (index + 1) *
NanoSeconds(1.0);
1096 TestCase::Duration::QUICK);
1104 {
false,
true,
false,
false}),
1105 TestCase::Duration::QUICK);
1109 TestCase::Duration::QUICK);
1112 TestCase::Duration::QUICK);
1115 TestCase::Duration::QUICK);
1118 TestCase::Duration::QUICK);
1122 TestCase::Duration::QUICK);
1126 TestCase::Duration::QUICK);
1130 TestCase::Duration::QUICK);
1134 TestCase::Duration::QUICK);
1138 TestCase::Duration::QUICK);
1142 TestCase::Duration::QUICK);
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.
TestMultipleCtsResponsesFromMuRts(const std::vector< CtsTxInfos > &ctsTxInfosPerSta)
Constructor.
std::size_t m_countApRxCtsFailure
count the number of unsuccessfully received CTS frames by the AP
void DoSetup() override
Implementation to do any local setup required for this TestCase.
std::size_t m_countStaRxCtsFailure
count the number of unsuccessfully received CTS frames by the non-participating STA
void RxCtsSuccess(std::size_t phyIndex, Ptr< const WifiPsdu > psdu, RxSignalInfo rxSignalInfo, WifiTxVector txVector, std::vector< bool > statusPerMpdu)
CTS RX success function.
void FakePreviousMuRts()
Function called to fake the transmission of a MU-RTS.
std::vector< CtsTxInfos > m_ctsTxInfosPerSta
information about CTS responses
std::vector< Ptr< MuRtsCtsSpectrumWifiPhy > > m_phyStas
STAs PHYs.
void TxNonHtDuplicateCts(std::size_t phyIndex)
Function called to trigger a CTS frame sent by a STA using non-HT duplicate.
void DoTeardown() override
Implementation to do any local setup required for this TestCase.
void DoRun() override
Implementation to actually run this TestCase.
std::size_t m_countApRxCtsSuccess
count the number of successfully received CTS frames by the AP
Ptr< MuRtsCtsSpectrumWifiPhy > m_phyAp
AP PHY.
void RxCtsFailure(std::size_t phyIndex, Ptr< const WifiPsdu > psdu)
CTS RX failure function.
double m_stasTxPowerDbm
TX power in dBm configured for the STAs.
std::size_t m_countStaRxCtsSuccess
count the number of successfully received CTS frames by the non-participating STA
void CheckResults()
Check the results.
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.
AttributeValue implementation for Pointer.
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.
Hold variables of type string.
void AddTestCase(TestCase *testCase, Duration duration=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.
std::tuple< uint8_t, uint16_t, WifiPhyBand, uint8_t > ChannelTuple
Tuple identifying an operating channel.
void SetMobility(const Ptr< MobilityModel > mobility)
assign a mobility model to this device
void SetReceiveOkCallback(RxOkCallback callback)
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.
uint16_t GetChannelWidth() const
#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)
Information about CTS responses to expect in the test.
uint16_t bw
the width in MHz of the CTS response
bool discard
flag whether the CTS response shall be discarded
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