9#include "ns3/constant-obss-pd-algorithm.h"
10#include "ns3/he-phy.h"
11#include "ns3/he-ppdu.h"
12#include "ns3/ht-ppdu.h"
13#include "ns3/interference-helper.h"
15#include "ns3/multi-model-spectrum-channel.h"
16#include "ns3/nist-error-rate-model.h"
17#include "ns3/non-communicating-net-device.h"
18#include "ns3/ofdm-ppdu.h"
19#include "ns3/pointer.h"
20#include "ns3/rng-seed-manager.h"
21#include "ns3/spectrum-wifi-helper.h"
22#include "ns3/spectrum-wifi-phy.h"
24#include "ns3/threshold-preamble-detection-model.h"
25#include "ns3/vht-configuration.h"
26#include "ns3/vht-ppdu.h"
27#include "ns3/waveform-generator.h"
28#include "ns3/wifi-mac-header.h"
29#include "ns3/wifi-net-device.h"
30#include "ns3/wifi-phy-listener.h"
31#include "ns3/wifi-psdu.h"
32#include "ns3/wifi-spectrum-value-helper.h"
33#include "ns3/wifi-utils.h"
72 void DoRun()
override;
124 dBm_u expectedCcaThreshold);
143 :
TestCase(
"Wi-Fi PHY CCA thresholds test"),
144 m_CcaEdThreshold{-62.0},
145 m_CcaSensitivity{-82.0},
146 m_secondaryCcaSensitivityThresholds{
dBm_u{-72},
dBm_u{-72},
dBm_u{-69}},
230 dBm_u expectedCcaThreshold)
233 const auto actualThreshold = phy->GetCcaThreshold(ppdu, channelType);
234 NS_LOG_INFO((ppdu ==
nullptr ?
"any signal" :
"a PPDU")
235 <<
" in " << channelType <<
" channel: " << actualThreshold <<
"dBm");
237 expectedCcaThreshold,
239 "Actual CCA threshold for "
240 << (ppdu ==
nullptr ?
"any signal" :
"a PPDU") <<
" in "
241 << channelType <<
" channel " << actualThreshold
242 <<
"dBm does not match expected threshold "
243 << expectedCcaThreshold <<
"dBm");
642 const std::vector<Time>& per20MhzDurations)
override
644 NS_LOG_FUNCTION(
this << duration << channelType << per20MhzDurations.size());
703 void DoRun()
override;
749 const std::vector<Time>& expectedPer20MhzDurations);
811 const std::vector<TxSignalInfo>& generatedSignals,
812 const std::vector<TxPpduInfo>& generatedPpdus,
813 const std::vector<StateCheckPoint>& stateCheckpoints,
814 const std::vector<CcaCheckPoint>& ccaCheckpoints);
833 std::shared_ptr<CcaTestPhyListener>
841 :
TestCase(
"Wi-Fi PHY CCA indication test"),
842 m_numSignalGenerators(2),
844 m_channelWidth(
MHz_u{20})
855 NS_LOG_FUNCTION(
this << signalGenerator << txPower << frequency << bandwidth << duration);
859 bandInfo.
fl = bandInfo.
fc -
MHzToHz(bandwidth / 2);
860 bandInfo.
fh = bandInfo.
fc +
MHzToHz(bandwidth / 2);
862 bands.push_back(bandInfo);
868 signalGenerator->SetTxPowerSpectralDensity(signalPsd);
869 signalGenerator->SetPeriod(duration);
870 signalGenerator->Start();
878 signalGenerator->Stop();
911 m_txPhy->SetTxPowerStart(txPower);
912 m_txPhy->SetTxPowerEnd(txPower);
930 m_rxPhy->GetAttribute(
"State", ptr);
932 currentState = state->GetState();
935 "PHY State " << currentState <<
" does not match expected state "
941 Time expectedEndTime,
943 const std::vector<Time>& expectedPer20MhzDurations)
948 <<
" does not match expected time " << expectedEndTime
953 <<
" does not match expected channel type "
956 expectedPer20MhzDurations.size(),
957 "PHY CCA-BUSY per-20 MHz durations does not match expected vector"
959 for (std::size_t i = 0; i < expectedPer20MhzDurations.size(); ++i)
962 expectedPer20MhzDurations.at(i),
963 "PHY CCA-BUSY per-20 MHz duration at index "
964 << i <<
" does not match expected duration at "
977 const std::vector<TxSignalInfo>& generatedSignals,
978 const std::vector<TxPpduInfo>& generatedPpdus,
979 const std::vector<StateCheckPoint>& stateCheckpoints,
980 const std::vector<CcaCheckPoint>& ccaCheckpoints)
982 for (
const auto& generatedPpdu : generatedPpdus)
988 generatedPpdu.centerFreq,
989 generatedPpdu.bandwidth);
992 std::size_t index = 0;
993 for (
const auto& generatedSignal : generatedSignals)
999 generatedSignal.power,
1000 generatedSignal.centerFreq,
1001 generatedSignal.bandwidth,
1002 generatedSignal.duration);
1005 for (
const auto& checkpoint : ccaCheckpoints)
1011 checkpoint.expectedChannelListType,
1012 checkpoint.expectedPer20MhzDurations);
1015 for (
const auto& checkpoint : stateCheckpoints)
1020 checkpoint.expectedPhyState);
1044 rxDev->SetVhtConfiguration(vhtConfiguration);
1049 m_rxPhy->SetInterferenceHelper(rxInterferenceHelper);
1051 m_rxPhy->SetErrorRateModel(rxErrorModel);
1054 m_rxPhy->SetPreambleDetectionModel(preambleDetectionModel);
1055 m_rxPhy->AddChannel(spectrumChannel);
1059 rxNode->AddDevice(rxDev);
1066 m_txPhy->SetInterferenceHelper(txInterferenceHelper);
1068 m_txPhy->SetErrorRateModel(txErrorModel);
1069 m_txPhy->AddChannel(spectrumChannel);
1073 txNode->AddDevice(txDev);
1081 signalGenerator->SetDevice(signalGeneratorDev);
1082 signalGenerator->SetChannel(spectrumChannel);
1083 signalGenerator->SetDutyCycle(1);
1084 signalGeneratorNode->AddDevice(signalGeneratorDev);
1094 int64_t streamNumber = 0;
1095 m_rxPhy->AssignStreams(streamNumber);
1096 m_txPhy->AssignStreams(streamNumber);
1110 std::vector<Time> expectedPer20MhzCcaBusyDurations{};
1121 "Reception of a signal that occupies P20 below ED threshold");
1129 WifiPhyState::IDLE},
1142 "Reception of signal that occupies P20 above ED threshold");
1148 {
aCcaTime, WifiPhyState::CCA_BUSY},
1150 WifiPhyState::CCA_BUSY},
1172 : std::vector<Time>{})}});
1181 "Reception of two 20 MHz signals that occupies P20 below ED threshold with "
1182 "sum above ED threshold");
1191 WifiPhyState::CCA_BUSY},
1213 : std::vector<Time>{})}});
1223 "Reception of a 20 MHz HE PPDU that occupies P20 below CCA sensitivity threshold");
1230 WifiPhyState::IDLE},
1245 "Reception of a 20 MHz HE PPDU that occupies P20 above CCA sensitivity threshold");
1251 {
aCcaTime, WifiPhyState::CCA_BUSY},
1263 ? std::vector<Time>{
Seconds(0),
1273 : std::vector<Time>{})}});
1283 "Reception of a 40 MHz HE PPDU that occupies P20 below CCA sensitivity threshold");
1290 WifiPhyState::IDLE},
1305 "Reception of a 40 MHz HE PPDU that occupies P40 above CCA sensitivity threshold");
1311 {
aCcaTime, WifiPhyState::CCA_BUSY},
1315 : WifiPhyState::CCA_BUSY},
1325 ? std::vector<Time>{
Seconds(0),
1335 : std::vector<Time>{})}});
1346 "Reception of a 20 MHz signal that occupies S20 below ED threshold");
1354 WifiPhyState::IDLE},
1367 "Reception of a 20 MHz signal that occupies S20 above ED threshold");
1375 WifiPhyState::IDLE},
1404 "Reception of a 40 MHz signal that occupies P40 above ED threshold");
1410 {
aCcaTime, WifiPhyState::CCA_BUSY},
1412 WifiPhyState::CCA_BUSY},
1440 "Reception of a signal that occupies S20 followed by the reception of "
1441 "another signal that occupies P20");
1450 WifiPhyState::CCA_BUSY},
1453 WifiPhyState::CCA_BUSY},
1497 "Reception of a signal that occupies P20 followed by the reception of "
1498 "another signal that occupies S20");
1505 {
aCcaTime, WifiPhyState::CCA_BUSY},
1507 WifiPhyState::CCA_BUSY},
1510 WifiPhyState::CCA_BUSY},
1555 "Reception of a 20 MHz HE PPDU that occupies S20 below CCA sensitivity threshold");
1562 WifiPhyState::IDLE},
1576 "Reception of a 20 MHz HE PPDU that occupies S20 above CCA sensitivity threshold");
1584 WifiPhyState::IDLE},
1615 "Reception of a 20 MHz signal that occupies S20 above ED threshold followed by a 40 "
1616 "MHz HE PPDU that occupies P40 below CCA sensitivity threshold");
1649 : std::vector<Time>{})},
1677 "Reception of a 20 MHz signal that occupies the first subchannel of "
1678 "S40 below ED threshold");
1689 WifiPhyState::IDLE},
1704 "Reception of a 20 MHz signal that occupies the first subchannel of "
1705 "S40 above ED threshold");
1716 WifiPhyState::IDLE},
1743 "Reception of a 20 MHz signal that occupies the second subchannel of "
1744 "S40 below ED threshold");
1755 WifiPhyState::IDLE},
1770 "Reception of a 20 MHz signal that occupies the second subchannel of "
1771 "S40 above ED threshold");
1782 WifiPhyState::IDLE},
1809 "Reception of a 40 MHz signal that occupies S40 below ED threshold");
1817 WifiPhyState::IDLE},
1832 "Reception of a 20 MHz signal that occupies the second subchannel of "
1833 "S40 above ED threshold");
1841 WifiPhyState::IDLE},
1868 "Reception of a 80 MHz signal that occupies P80 above ED threshold");
1874 {
aCcaTime, WifiPhyState::CCA_BUSY},
1876 WifiPhyState::CCA_BUSY},
1903 "Reception of a 20 MHz signal that occupies S40 followed by the "
1904 "reception of another 20 MHz signal that occupies P20");
1917 WifiPhyState::CCA_BUSY},
1920 WifiPhyState::CCA_BUSY},
1962 "Reception of a signal that occupies S40 followed by the reception of "
1963 "another signal that occupies S20");
1977 WifiPhyState::IDLE},
2020 "Reception of a 40 MHz HE PPDU that occupies S40 below CCA sensitivity threshold");
2027 WifiPhyState::IDLE},
2041 "Reception of a 40 MHz HE PPDU that occupies S40 above CCA sensitivity threshold");
2049 WifiPhyState::IDLE},
2078 "Reception of a 40 MHz signal that occupies S40 above ED threshold followed by a 80 "
2079 "MHz HE PPDU that occupies P80 below CCA sensitivity threshold");
2134 "Reception of a 80 MHz HE PPDU that occupies the 40 MHz band above CCA "
2135 "sensitivity threshold");
2140 {
aCcaTime, WifiPhyState::CCA_BUSY},
2142 WifiPhyState::CCA_BUSY},
2159 : std::vector<Time>{
Seconds(0),
2164 : std::vector<Time>{})},
2178 : std::vector<Time>{
Seconds(0),
2183 : std::vector<Time>{})}});
2193 "Reception of a 80 MHz HE PPDU that occupies the 40 MHz band above CCA "
2194 "sensitivity threshold");
2200 {
aCcaTime, WifiPhyState::CCA_BUSY},
2202 WifiPhyState::CCA_BUSY},
2224 : std::vector<Time>{})},
2243 : std::vector<Time>{})}});
2253 "Reception of a 40 MHz HE PPDU that does not occupy the operational channel");
2260 WifiPhyState::IDLE},
2268 if (m_channelWidth >
MHz_u{80})
2276 "Reception of a 20 MHz signal that occupies the first subchannel of "
2277 "S80 below ED threshold");
2288 WifiPhyState::IDLE},
2302 "Reception of a 20 MHz signal that occupies the first subchannel of "
2303 "S80 above ED threshold");
2314 WifiPhyState::IDLE},
2337 "Reception of a 20 MHz signal that occupies the second subchannel of "
2338 "S80 below ED threshold");
2349 WifiPhyState::IDLE},
2363 "Reception of a 20 MHz signal that occupies the second subchannel of "
2364 "S80 above ED threshold");
2375 WifiPhyState::IDLE},
2398 "Reception of a 20 MHz signal that occupies the third subchannel of "
2399 "S80 below ED threshold");
2410 WifiPhyState::IDLE},
2424 "Reception of a 20 MHz signal that occupies the third subchannel of "
2425 "S80 above ED threshold");
2436 WifiPhyState::IDLE},
2459 "Reception of a 20 MHz signal that occupies the fourth subchannel of "
2460 "S80 below ED threshold");
2471 WifiPhyState::IDLE},
2485 "Reception of a 20 MHz signal that occupies the fourth subchannel of "
2486 "S80 above ED threshold");
2497 WifiPhyState::IDLE},
2520 "Reception of a 40 MHz signal that occupies the first and second "
2521 "subchannels of S80 below ED threshold");
2532 WifiPhyState::IDLE},
2546 "Reception of a 40 MHz signal that occupies the first and second "
2547 "subchannels of S80 above ED threshold");
2558 WifiPhyState::IDLE},
2581 "Reception of a 40 MHz signal that occupies the third and fourth "
2582 "subchannels of S80 below ED threshold");
2593 WifiPhyState::IDLE},
2607 "Reception of a 40 MHz signal that occupies the third and fourth "
2608 "subchannels of S80 above ED threshold");
2619 WifiPhyState::IDLE},
2642 "Reception of a 80 MHz signal that occupies S80 below ED threshold");
2650 WifiPhyState::IDLE},
2664 "Reception of a 80 MHz signal that occupies S80 above ED threshold");
2672 WifiPhyState::IDLE},
2696 "Reception of a 160 MHz signal that occupies the whole band below ED threshold");
2704 WifiPhyState::IDLE},
2719 "Reception of a 160 MHz signal that occupies the whole band above ED threshold");
2725 {
aCcaTime, WifiPhyState::CCA_BUSY},
2727 WifiPhyState::CCA_BUSY},
2750 "Reception of a 20 MHz signal that occupies S80 followed by the "
2751 "reception of another 20 MHz signal that occupies P20");
2764 WifiPhyState::CCA_BUSY},
2767 WifiPhyState::CCA_BUSY},
2801 "Reception of a signal that occupies S80 followed by the reception of "
2802 "another signal that occupies S40");
2820 WifiPhyState::IDLE},
2854 "Reception of a signal that occupies S80 followed by the reception of "
2855 "another signal that occupies S20");
2869 WifiPhyState::IDLE},
2904 "Reception of a 40 MHz HE PPDU that occupies S40 below CCA sensitivity threshold");
2911 WifiPhyState::IDLE},
2925 "Reception of a 80 MHz HE PPDU that occupies S80 above CCA sensitivity threshold");
2932 WifiPhyState::IDLE},
2955 "Reception of a 20 MHz signal that generates a per20bitmap parameter "
2956 "change when previous CCA indication reports IDLE");
2967 WifiPhyState::IDLE},
2991 "Reception of a 20 MHz signal that generates a per20bitmap parameter change when "
2992 "previous CCA indication reports BUSY for the primary channel");
3003 {
aCcaTime, WifiPhyState::CCA_BUSY},
3005 WifiPhyState::CCA_BUSY},
3068 signalGenerator->Dispose();
3069 signalGenerator =
nullptr;
PHY listener for CCA tests.
void NotifyOn() override
Notify listeners that we went to switch on.
WifiChannelListType m_lastCcaBusyChannelType
Channel type indication for the last CCA-BUSY notification.
void NotifyRxEndError() override
We have received the last bit of a packet for which NotifyRxStart was invoked first and,...
void NotifyTxStart(Time duration, dBm_u txPower) override
void NotifyCcaBusyStart(Time duration, WifiChannelListType channelType, const std::vector< Time > &per20MhzDurations) override
void NotifySleep() override
Notify listeners that we went to sleep.
void NotifyRxEndOk() override
We have received the last bit of a packet for which NotifyRxStart was invoked first and,...
CcaTestPhyListener()=default
void NotifyOff() override
Notify listeners that we went to switch off.
std::size_t m_notifications
Number of CCA notifications.
void NotifyRxStart(Time duration) override
Time m_endCcaBusy
End of the CCA-BUSY duration.
void Reset()
Reset function.
void NotifyWakeup() override
Notify listeners that we woke up.
std::vector< Time > m_lastPer20MhzCcaBusyDurations
End of the CCA-BUSY durations per 20 MHz.
void NotifySwitchingStart(Time duration) override
Wifi Phy Threshold Test base class.
MHz_u m_channelWidth
Operating channel width.
std::size_t m_numSignalGenerators
The number of non-wifi signals generators needed for the test.
void CheckPhyState(WifiPhyState expectedState)
Check the PHY state.
void DoTeardown() override
Implementation to do any local setup required for this TestCase.
void CheckLastCcaBusyNotification(Time expectedEndTime, WifiChannelListType expectedChannelType, const std::vector< Time > &expectedPer20MhzDurations)
Check the last CCA-BUSY notification.
MHz_u m_frequency
Operating frequency.
void StartSignal(Ptr< WaveformGenerator > signalGenerator, dBm_u txPower, MHz_u frequency, MHz_u bandwidth, Time duration)
Start to generate a signal.
void RunOne()
Run one function.
void SendHeSuPpdu(dBm_u txPower, MHz_u frequency, MHz_u bandwidth)
Send an HE SU PPDU.
void DoCheckPhyState(WifiPhyState expectedState)
Check the PHY state.
std::shared_ptr< CcaTestPhyListener > m_rxPhyStateListener
Listener for PHY state transitions.
std::vector< Ptr< WaveformGenerator > > m_signalGenerators
Generators of non-wifi signals.
void ScheduleTest(Time delay, const std::vector< TxSignalInfo > &generatedSignals, const std::vector< TxPpduInfo > &generatedPpdus, const std::vector< StateCheckPoint > &stateCheckpoints, const std::vector< CcaCheckPoint > &ccaCheckpoints)
Schedule test to perform.
void DoSetup() override
Implementation to do any local setup required for this TestCase.
void DoRun() override
Implementation to actually run this TestCase.
void LogScenario(const std::string &log) const
Log scenario description.
void Reset()
Reset function.
Ptr< SpectrumWifiPhy > m_rxPhy
PHY object of the receiver.
Ptr< SpectrumWifiPhy > m_txPhy
PHY object of the transmitter.
void StopSignal(Ptr< WaveformGenerator > signalGenerator)
Stop to generate a signal.
WifiPhyCcaIndicationTest()
Wi-Fi PHY CCA Test Suite.
void VerifyCcaThreshold(const Ptr< PhyEntity > phy, const Ptr< const WifiPpdu > ppdu, WifiChannelListType channelType, dBm_u expectedCcaThreshold)
Function to verify the CCA threshold that is being reported by a given PHY entity upon reception of a...
Ptr< WifiNetDevice > m_device
The WifiNetDevice.
void DoSetup() override
Implementation to do any local setup required for this TestCase.
void DoTeardown() override
Implementation to do any local setup required for this TestCase.
Ptr< SpectrumWifiPhy > m_phy
The spectrum PHY.
Ptr< ObssPdAlgorithm > m_obssPdAlgorithm
The OBSS-PD algorithm.
dBm_u m_obssPdLevel
The current OBSS-PD level.
Ptr< WifiPsdu > CreateDummyPsdu()
Create a dummy PSDU whose payload is 1000 bytes.
VhtConfiguration::SecondaryCcaSensitivityThresholds m_secondaryCcaSensitivityThresholds
The current CCA sensitivity thresholds for signals that do not occupy the primary 20 MHz channel.
void RunOne()
Run tests for given CCA attributes.
Ptr< VhtConfiguration > m_vhtConfiguration
The VHT configuration.
void DoRun() override
Implementation to actually run this TestCase.
Ptr< VhtPpdu > CreateDummyVhtPpdu(MHz_u bandwidth, const WifiPhyOperatingChannel &channel)
Create a VHT PPDU.
Ptr< HtPpdu > CreateDummyHtPpdu(MHz_u bandwidth, const WifiPhyOperatingChannel &channel)
Create a HT PPDU.
Ptr< OfdmPpdu > CreateDummyNonHtPpdu(const WifiPhyOperatingChannel &channel)
Create a non-HT PPDU.
dBm_u m_CcaEdThreshold
The current CCA-ED threshold for a 20 MHz subchannel.
WifiPhyCcaThresholdsTest()
dBm_u m_CcaSensitivity
The current CCA sensitivity threshold for signals that occupy the primary 20 MHz channel.
Ptr< HePpdu > CreateDummyHePpdu(MHz_u bandwidth, const WifiPhyOperatingChannel &channel)
Create a HE PPDU.
static WifiMode GetHeMcs0()
Return MCS 0 from HE MCS values.
static WifiMode GetHtMcs0()
Return MCS 0 from HT MCS values.
static WifiMode GetOfdmRate6Mbps()
Return a WifiMode for OFDM at 6 Mbps.
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 Time Now()
Return the current simulation virtual time.
static void Run()
Run the simulation.
static EventId ScheduleNow(FUNC f, Ts &&... args)
Schedule an event to expire Now.
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.
AttributeValue implementation for Time.
std::tuple< dBm_u, dBm_u, dBm_u > SecondaryCcaSensitivityThresholds
Tuple identifying CCA sensitivity thresholds for secondary channels.
static WifiMode GetVhtMcs0()
Return MCS 0 from VHT MCS values.
std::tuple< uint8_t, MHz_u, WifiPhyBand, uint8_t > ChannelTuple
Tuple identifying a segment of an operating channel.
receive notifications about PHY events.
Class that keeps track of all information about the current PHY operating channel.
static ConstIterator FindFirst(uint8_t number, MHz_u frequency, MHz_u width, WifiStandard standard, WifiPhyBand band, ConstIterator start=m_frequencyChannels.begin())
Find the first frequency segment matching the specified parameters.
This objects implements the PHY state machine of the Wifi device.
This class mimics the TXVECTOR which is to be passed to the PHY in order to define the parameters whi...
#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_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Ptr< T > CreateObject(Args &&... args)
Create an object by type, with varying number of constructor parameters.
Ptr< T > Create(Ts &&... args)
Create class instances by constructors with varying numbers of arguments and return them by Ptr.
#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 MicroSeconds(uint64_t value)
Construct a Time in the indicated unit.
Time NanoSeconds(uint64_t value)
Construct a Time in the indicated unit.
Time Seconds(double value)
Construct a Time in the indicated unit.
WifiChannelListType
Enumeration of the possible channel-list parameter elements defined in Table 8-5 of IEEE 802....
@ WIFI_PHY_BAND_5GHZ
The 5 GHz band.
@ WIFI_MOD_CLASS_OFDM
OFDM (Clause 17)
@ WIFI_MOD_CLASS_HT
HT (Clause 19)
@ WIFI_MOD_CLASS_VHT
VHT (Clause 22)
@ WIFI_MOD_CLASS_HE
HE (Clause 27)
@ WIFI_CHANLIST_SECONDARY40
@ WIFI_CHANLIST_SECONDARY
@ WIFI_CHANLIST_SECONDARY80
Every class exported by the ns3 library is enclosed in the ns3 namespace.
WifiPhyState
The state of the PHY layer.
std::vector< BandInfo > Bands
Container of BandInfo.
Ptr< T1 > DynamicCast(const Ptr< T2 > &p)
Cast a Ptr.
Watt_u DbmToW(dBm_u val)
Convert from dBm to Watts.
Hz_u MHzToHz(MHz_u val)
Convert from MHz to Hz.
structure that holds information to perform CCA check
Time expectedCcaEndTime
expected CCA_BUSY end time
Time timePoint
time at which the check will performed
std::vector< Time > expectedPer20MhzDurations
expected per-20 MHz CCA duration
WifiChannelListType expectedChannelListType
expected channel list type
structure that holds information to perform PHY state check
WifiPhyState expectedPhyState
expected PHY state
Time timePoint
time at which the check will performed
structure that holds information to generate PPDUs
dBm_u power
transmit power to use
Time startTime
time at which transmission will be started
MHz_u centerFreq
center frequency to use
MHz_u bandwidth
bandwidth to use
structure that holds information to generate signals
MHz_u centerFreq
center frequency to use
Time startTime
time at which transmission will be started
MHz_u bandwidth
bandwidth to use
Time duration
the duration of the transmission
dBm_u power
transmit power to use
The building block of a SpectrumModel.
double fc
center frequency
double fl
lower limit of subband
double fh
upper limit of subband
constexpr MHz_u S80_CENTER_FREQUENCY
static WifiPhyCcaTestSuite WifiPhyCcaTestSuite
the test suite
constexpr MHz_u S20_CENTER_FREQUENCY
constexpr MHz_u P20_CENTER_FREQUENCY
constexpr MHz_u S40_CENTER_FREQUENCY
constexpr MHz_u P160_CENTER_FREQUENCY
constexpr MHz_u P80_CENTER_FREQUENCY
constexpr MHz_u P40_CENTER_FREQUENCY
const std::map< MHz_u, Time > PpduDurations