Attachment #3225 for bug #2460

View | Details | Raw Unified | Return to bug 2460
Collapse All | Expand All

(-)a/CHANGES.html (+4 lines)

Lines 65-70 us a note on ns-developers mailing list.</p>	Link Here

    RandomRectanglePositionAllocator, RandomDiscPositionAllocator,

    RandomRectanglePositionAllocator, RandomDiscPositionAllocator,

    UniformDiscPositionAllocator.

    UniformDiscPositionAllocator.

  </li>

  </li>

  <li>

    The WifiPhy attribute "CcaMode1Threshold" has been renamed to "CcaEdThreshold",

    and the WifiPhy attribute "EnergyDetectionThreshold" has been replaced by a new attribute called "RxSensitivity"

  </li>

</ul>

</ul>

<h2>Changes to build system:</h2>

<h2>Changes to build system:</h2>

<ul>

<ul>




  double interval = 1;          // seconds
  double startTime = 0.0;       // seconds
  double distanceToRx = 100.0;  // meters
  /*
   * This is a magic number used to set the transmit power, based on other
   * configuration.
   */
  double offset = 81;

  CommandLine cmd;
  cmd.AddValue ("phyMode", "Wifi Phy mode", phyMode);

  /** Wifi PHY **/
  /***************************************************************************/
  YansWifiPhyHelper wifiPhy = YansWifiPhyHelper::Default ();
  wifiPhy.Set ("RxGain", DoubleValue (-10));
  wifiPhy.Set ("TxGain", DoubleValue (offset + Prss));
  wifiPhy.Set ("CcaMode1Threshold", DoubleValue (0.0));
  /***************************************************************************/

  /** wifi channel **/
  YansWifiChannelHelper wifiChannel;
  wifiChannel.SetPropagationDelay ("ns3::ConstantSpeedPropagationDelayModel");
  wifiChannel.AddPropagationLoss ("ns3::FriisPropagationLossModel");
  
  // create wifi channel
  Ptr<YansWifiChannel> wifiChannelPtr = wifiChannel.Create ();
  wifiPhy.SetChannel (wifiChannelPtr);




  double interval = 1;          // seconds
  double startTime = 0.0;       // seconds
  double distanceToRx = 100.0;  // meters
  /*
   * This is a magic number used to set the transmit power, based on other
   * configuration.
   */
  double offset = 81;
  
  // Energy Harvester variables
  double harvestingUpdateInterval = 1;  // seconds

  /** Wifi PHY **/
  /***************************************************************************/
  YansWifiPhyHelper wifiPhy = YansWifiPhyHelper::Default ();
  wifiPhy.Set ("RxGain", DoubleValue (-10));
  wifiPhy.Set ("TxGain", DoubleValue (offset + Prss));
  wifiPhy.Set ("CcaMode1Threshold", DoubleValue (0.0));
  /***************************************************************************/

  /** wifi channel **/
  YansWifiChannelHelper wifiChannel;
  wifiChannel.SetPropagationDelay ("ns3::ConstantSpeedPropagationDelayModel");
  wifiChannel.AddPropagationLoss ("ns3::FriisPropagationLossModel");

  // create wifi channel
  Ptr<YansWifiChannel> wifiChannelPtr = wifiChannel.Create ();
  wifiPhy.SetChannel (wifiChannelPtr);

(-)a/examples/wireless/wifi-clear-channel-cmu.cc (-2 lines)

Lines 208-215 int main (int argc, char *argv[])	Link Here

208

209

          NS_LOG_DEBUG (modes[i]);

209

          NS_LOG_DEBUG (modes[i]);

210

          experiment = Experiment (modes[i]);

210

          experiment = Experiment (modes[i]);

211

          wifiPhy.Set ("EnergyDetectionThreshold", DoubleValue (-110.0) );

212

          wifiPhy.Set ("CcaMode1Threshold", DoubleValue (-110.0) );

213

          wifiPhy.Set ("TxPowerStart", DoubleValue (15.0) );

211

          wifiPhy.Set ("TxPowerStart", DoubleValue (15.0) );

214

          wifiPhy.Set ("TxPowerEnd", DoubleValue (15.0) );

212

          wifiPhy.Set ("TxPowerEnd", DoubleValue (15.0) );

215

          wifiPhy.Set ("RxGain", DoubleValue (0) );

213

          wifiPhy.Set ("RxGain", DoubleValue (0) );




  wifi.SetStandard (WIFI_PHY_STANDARD_80211b);

  YansWifiPhyHelper wifiPhy =  YansWifiPhyHelper::Default ();
  // set it to zero; otherwise, gain will be added
  wifiPhy.Set ("RxGain", DoubleValue (0) );
  wifiPhy.Set ("CcaMode1Threshold", DoubleValue (0.0) );

  // ns-3 supports RadioTap and Prism tracing extensions for 802.11b
  wifiPhy.SetPcapDataLinkType (WifiPhyHelper::DLT_IEEE802_11_RADIO);

  NetDeviceContainer devices = wifi.Install (wifiPhy, wifiMac, c.Get (0));
  // This will disable these sending devices from detecting a signal
  // so that they do not backoff
  wifiPhy.Set ("EnergyDetectionThreshold", DoubleValue (0.0) );
  wifiPhy.Set ("TxGain", DoubleValue (offset + Prss) );
  devices.Add (wifi.Install (wifiPhy, wifiMac, c.Get (1)));
  wifiPhy.Set ("TxGain", DoubleValue (offset + Irss) );

(-)a/examples/wireless/wifi-spectrum-per-example.cc (-3 lines)

Lines 183-191 int main (int argc, char *argv[])	Link Here

183

184

      else if (wifiType == "ns3::SpectrumWifiPhy")

184

      else if (wifiType == "ns3::SpectrumWifiPhy")

185

186

          //Bug 2460: CcaMode1Threshold default should be set to -62 dBm when using Spectrum

187

          Config::SetDefault ("ns3::WifiPhy::CcaMode1Threshold", DoubleValue (-62.0));

188

189

          Ptr<MultiModelSpectrumChannel> spectrumChannel

186

          Ptr<MultiModelSpectrumChannel> spectrumChannel

190

            = CreateObject<MultiModelSpectrumChannel> ();

187

            = CreateObject<MultiModelSpectrumChannel> ();

191

          Ptr<FriisPropagationLossModel> lossModel

188

          Ptr<FriisPropagationLossModel> lossModel

(-)a/examples/wireless/wifi-spectrum-per-interference.cc (-3 lines)

Lines 212-220 int main (int argc, char *argv[])	Link Here

212

213

      else if (wifiType == "ns3::SpectrumWifiPhy")

213

      else if (wifiType == "ns3::SpectrumWifiPhy")

214

215

          //Bug 2460: CcaMode1Threshold default should be set to -62 dBm when using Spectrum

216

          Config::SetDefault ("ns3::WifiPhy::CcaMode1Threshold", DoubleValue (-62.0));

217

218

          spectrumChannel

215

          spectrumChannel

219

            = CreateObject<MultiModelSpectrumChannel> ();

216

            = CreateObject<MultiModelSpectrumChannel> ();

220

          Ptr<FriisPropagationLossModel> lossModel

217

          Ptr<FriisPropagationLossModel> lossModel

(-)a/examples/wireless/wifi-spectrum-saturation-example.cc (-3 lines)

Lines 178-186 int main (int argc, char *argv[])	Link Here

178

179

      else if (wifiType == "ns3::SpectrumWifiPhy")

179

      else if (wifiType == "ns3::SpectrumWifiPhy")

180

181

          //Bug 2460: CcaMode1Threshold default should be set to -62 dBm when using Spectrum

182

          Config::SetDefault ("ns3::WifiPhy::CcaMode1Threshold", DoubleValue (-62.0));

183

184

          Ptr<MultiModelSpectrumChannel> spectrumChannel

181

          Ptr<MultiModelSpectrumChannel> spectrumChannel

185

            = CreateObject<MultiModelSpectrumChannel> ();

182

            = CreateObject<MultiModelSpectrumChannel> ();

186

          Ptr<FriisPropagationLossModel> lossModel

183

          Ptr<FriisPropagationLossModel> lossModel




  /* Setup Physical Layer */
  YansWifiPhyHelper wifiPhy = YansWifiPhyHelper::Default ();
  wifiPhy.SetChannel (wifiChannel.Create ());
  wifiPhy.Set ("TxPowerStart", DoubleValue (10.0));
  wifiPhy.Set ("TxPowerEnd", DoubleValue (10.0));
  wifiPhy.Set ("TxPowerLevels", UintegerValue (1));
  wifiPhy.Set ("TxGain", DoubleValue (0));
  wifiPhy.Set ("RxGain", DoubleValue (0));
  wifiPhy.Set ("RxNoiseFigure", DoubleValue (10));
  wifiPhy.Set ("CcaMode1Threshold", DoubleValue (-79));
  wifiPhy.Set ("EnergyDetectionThreshold", DoubleValue (-79 + 3));
  wifiPhy.SetErrorRateModel ("ns3::YansErrorRateModel");
  wifiHelper.SetRemoteStationManager ("ns3::ConstantRateWifiManager",
                                      "DataMode", StringValue (phyRate),

(-)a/src/aodv/test/aodv-regression.cc (-2 / +1 lines)

Lines 168-175 ChainRegressionTest::CreateDevices ()	Link Here

168

  YansWifiChannelHelper wifiChannel = YansWifiChannelHelper::Default ();

168

  YansWifiChannelHelper wifiChannel = YansWifiChannelHelper::Default ();

169

  Ptr<YansWifiChannel> chan = wifiChannel.Create ();

169

  Ptr<YansWifiChannel> chan = wifiChannel.Create ();

170

  wifiPhy.SetChannel (chan);

170

  wifiPhy.SetChannel (chan);

171

  wifiPhy.Set ("TxGain", DoubleValue (1.0)); //this configuration should go away in future revision to the test

171

172

  wifiPhy.Set ("RxGain", DoubleValue (1.0)); //this configuration should go away in future revision to the test

173

  // This test suite output was originally based on YansErrorRateModel

172

  // This test suite output was originally based on YansErrorRateModel

174

  wifiPhy.SetErrorRateModel ("ns3::YansErrorRateModel");

173

  wifiPhy.SetErrorRateModel ("ns3::YansErrorRateModel");

175

  WifiHelper wifi;

174

  WifiHelper wifi;

(-)a/src/mesh/test/dot11s/hwmp-proactive-regression.cc (-2 / +1 lines)

Lines 113-120 HwmpProactiveRegressionTest::CreateDevices ()	Link Here

113

  YansWifiChannelHelper wifiChannel = YansWifiChannelHelper::Default ();

113

  YansWifiChannelHelper wifiChannel = YansWifiChannelHelper::Default ();

114

  Ptr<YansWifiChannel> chan = wifiChannel.Create ();

114

  Ptr<YansWifiChannel> chan = wifiChannel.Create ();

115

  wifiPhy.SetChannel (chan);

115

  wifiPhy.SetChannel (chan);

116

  wifiPhy.Set ("TxGain", DoubleValue (1.0)); //this configuration should go away in future revision to the test

116

117

  wifiPhy.Set ("RxGain", DoubleValue (1.0)); //this configuration should go away in future revision to the test

118

  // 2. setup mesh

117

  // 2. setup mesh

119

  MeshHelper mesh = MeshHelper::Default ();

118

  MeshHelper mesh = MeshHelper::Default ();

120

  mesh.SetStackInstaller ("ns3::Dot11sStack", "Root", Mac48AddressValue (Mac48Address ("00:00:00:00:00:0d")));

119

  mesh.SetStackInstaller ("ns3::Dot11sStack", "Root", Mac48AddressValue (Mac48Address ("00:00:00:00:00:0d")));

(-)a/src/mesh/test/dot11s/hwmp-reactive-regression.cc (-2 lines)

Lines 114-121 HwmpReactiveRegressionTest::CreateDevices ()	Link Here

114

  YansWifiChannelHelper wifiChannel = YansWifiChannelHelper::Default ();

114

  YansWifiChannelHelper wifiChannel = YansWifiChannelHelper::Default ();

115

  Ptr<YansWifiChannel> chan = wifiChannel.Create ();

115

  Ptr<YansWifiChannel> chan = wifiChannel.Create ();

116

  wifiPhy.SetChannel (chan);

116

  wifiPhy.SetChannel (chan);

117

  wifiPhy.Set ("TxGain", DoubleValue (1.0)); //this configuration should go away in future revision to the test

118

  wifiPhy.Set ("RxGain", DoubleValue (1.0)); //this configuration should go away in future revision to the test

119

117

120

  // 2. setup mesh

118

  // 2. setup mesh

121

  MeshHelper mesh = MeshHelper::Default ();

119

  MeshHelper mesh = MeshHelper::Default ();

(-)a/src/mesh/test/dot11s/hwmp-simplest-regression.cc (-2 / +1 lines)

Lines 122-129 HwmpSimplestRegressionTest::CreateDevices ()	Link Here

122

  YansWifiChannelHelper wifiChannel = YansWifiChannelHelper::Default ();

122

  YansWifiChannelHelper wifiChannel = YansWifiChannelHelper::Default ();

123

  Ptr<YansWifiChannel> chan = wifiChannel.Create ();

123

  Ptr<YansWifiChannel> chan = wifiChannel.Create ();

124

  wifiPhy.SetChannel (chan);

124

  wifiPhy.SetChannel (chan);

125

  wifiPhy.Set ("TxGain", DoubleValue (1.0)); //this configuration should go away in future revision to the test

125

126

  wifiPhy.Set ("RxGain", DoubleValue (1.0)); //this configuration should go away in future revision to the test

127

  // 2. setup mesh

126

  // 2. setup mesh

128

  MeshHelper mesh = MeshHelper::Default ();

127

  MeshHelper mesh = MeshHelper::Default ();

129

  mesh.SetStackInstaller ("ns3::Dot11sStack");

128

  mesh.SetStackInstaller ("ns3::Dot11sStack");

(-)a/src/mesh/test/dot11s/hwmp-target-flags-regression.cc (-2 / +1 lines)

Lines 140-147 HwmpDoRfRegressionTest::CreateDevices ()	Link Here

140

  YansWifiChannelHelper wifiChannel = YansWifiChannelHelper::Default ();

140

  YansWifiChannelHelper wifiChannel = YansWifiChannelHelper::Default ();

141

  Ptr<YansWifiChannel> chan = wifiChannel.Create ();

141

  Ptr<YansWifiChannel> chan = wifiChannel.Create ();

142

  wifiPhy.SetChannel (chan);

142

  wifiPhy.SetChannel (chan);

143

  wifiPhy.Set ("TxGain", DoubleValue (1.0)); //this configuration should go away in future revision to the test

143

144

  wifiPhy.Set ("RxGain", DoubleValue (1.0)); //this configuration should go away in future revision to the test

145

  // 2. setup mesh

144

  // 2. setup mesh

146

  MeshHelper mesh = MeshHelper::Default ();

145

  MeshHelper mesh = MeshHelper::Default ();

147

  mesh.SetStackInstaller ("ns3::Dot11sStack");

146

  mesh.SetStackInstaller ("ns3::Dot11sStack");

(-)a/src/mesh/test/flame/flame-regression.cc (-2 / +1 lines)

Lines 99-106 FlameRegressionTest::CreateDevices ()	Link Here

  YansWifiChannelHelper wifiChannel = YansWifiChannelHelper::Default ();

  YansWifiChannelHelper wifiChannel = YansWifiChannelHelper::Default ();

100

  Ptr<YansWifiChannel> chan = wifiChannel.Create ();

100

  Ptr<YansWifiChannel> chan = wifiChannel.Create ();

101

  wifiPhy.SetChannel (chan);

101

  wifiPhy.SetChannel (chan);

102

  wifiPhy.Set ("TxGain", DoubleValue (1.0)); //this configuration should go away in future revision to the test

102

103

  wifiPhy.Set ("RxGain", DoubleValue (1.0)); //this configuration should go away in future revision to the test

104

  // 2. setup mesh

103

  // 2. setup mesh

105

  MeshHelper mesh = MeshHelper::Default ();

104

  MeshHelper mesh = MeshHelper::Default ();

106

  mesh.SetStackInstaller ("ns3::FlameStack");

105

  mesh.SetStackInstaller ("ns3::FlameStack");




  wifi.SetStandard (wifiStandard);

  YansWifiPhyHelper wifiPhy =  YansWifiPhyHelper::Default ();
  // This is one parameter that matters when using FixedRssLossModel
  // set it to zero; otherwise, gain will be added
  wifiPhy.Set ("RxGain", DoubleValue (0) ); 
  wifiPhy.Set ("CcaMode1Threshold", DoubleValue (0.0) );

  // ns-3 supports RadioTap and Prism tracing extensions for 802.11b
  wifiPhy.SetPcapDataLinkType (WifiPhyHelper::DLT_IEEE802_11_RADIO); 


  // This will disable these sending devices from detecting a signal 
  // so that they do not backoff
  wifiPhy.Set ("EnergyDetectionThreshold", DoubleValue (0.0) );
  wifiPhy.Set ("TxGain", DoubleValue (offset + Prss) ); 
  devices.Add (wifi.Install (wifiPhy, wifiMac, c.Get (1)));
  wifiPhy.Set ("TxGain", DoubleValue (offset + Irss) ); 




#. SLEEP: the PHY is in a power save mode and cannot send nor receive frames.

Packet reception works as follows.  The ``YansWifiPhy`` attribute 
CcaEdThreshold corresponds to what the standard calls the "ED threshold" for CCA Mode 1.
corresponds to what the standard calls the "ED threshold" for CCA Mode 1.  
In section 16.4.8.5:  "CCA Mode 1: Energy above threshold. CCA shall report 
a busy medium upon detection of any energy above the ED threshold."  


signals in the YansWifi model-- everything is a Wi-Fi signal.

In the standard, there is also what is called the "minimum modulation
and coding rate sensitivity" in section 18.3.10.6 CCA requirements. 
This is analogous to the RxSensitivity attribute in ``YansWifiPhy``.
CCA busy state is not raised in this model when this threshold is exceeded
but instead RX state is immediately reached, since it is assumed that PLCP
sync always succeeds in this model. Even if the PLCP header reception fails, the 
succeeds in this model.  Even if the PLCP header reception fails, the 
channel state is still held in RX until YansWifiPhy::EndReceive().

In ns-3, the values of these attributes are -101 dBm for RxSensitivity
and -62 dBm for CcaEdThreshold.  
So, if a signal comes in at > -101 dBm and the state is IDLE or CCA BUSY, 
this model will lock onto it for the signal duration and raise RX state.
If it comes in at <= -96 dBm but >= -99 dBm, it will definitely raise 
CCA BUSY but not RX state.  If it comes in < -99 dBm, it gets added to 
the interference tracker and, by itself, it will not raise CCA BUSY, but 
maybe a later signal will contribute more power so that the threshold 
of -99 dBm is reached at a later time.

The energy of the signal intended to be received is 
calculated from the transmission power and adjusted based on the Tx gain

unintended Wi-Fi signals (perhaps from a different SSID or arriving
late from a hidden node) are added to the noise.

Unlike YansWifiPhy, where there are no foreign signals, CCA BUSY state
will be raised for foreign signals that are higher than CcaEdThreshold
(see section 16.4.8.5 in the 802.11-2012 standard for definition of CCA Mode 1).  
will be raised for foreign signals that are higher than this 'energy
detection' threshold (see section 16.4.8.5 in the 802.11-2012 standard
for definition of CCA Mode 1).  

To support the Spectrum channel, the ``YansWifiPhy`` transmit and receive methods
were adapted to use the Spectrum channel API.  This required developing

(-)a/src/wifi/examples/wifi-manager-example.cc (-3 lines)

Lines 336-344 int main (int argc, char *argv[])	Link Here

336

  WifiHelper wifi;

336

  WifiHelper wifi;

337

  wifi.SetStandard (serverSelectedStandard.m_standard);

337

  wifi.SetStandard (serverSelectedStandard.m_standard);

338

  YansWifiPhyHelper wifiPhy = YansWifiPhyHelper::Default ();

338

  YansWifiPhyHelper wifiPhy = YansWifiPhyHelper::Default ();

339

  wifiPhy.Set ("RxNoiseFigure", DoubleValue (0.0));

340

  wifiPhy.Set ("EnergyDetectionThreshold", DoubleValue (-110.0));

341

  wifiPhy.Set ("CcaMode1Threshold", DoubleValue (-110.0));

342

339

343

  Ptr<YansWifiChannel> wifiChannel = CreateObject<YansWifiChannel> ();

340

  Ptr<YansWifiChannel> wifiChannel = CreateObject<YansWifiChannel> ();

344

  Ptr<ConstantSpeedPropagationDelayModel> delayModel = CreateObject<ConstantSpeedPropagationDelayModel> ();

341

  Ptr<ConstantSpeedPropagationDelayModel> delayModel = CreateObject<ConstantSpeedPropagationDelayModel> ();

(-)a/src/wifi/model/spectrum-wifi-phy.cc (+8 lines)

Lines 242-247 SpectrumWifiPhy::StartRx (Ptr<SpectrumSignalParameters> rxParams)	Link Here

242

243

  // Log the signal arrival to the trace source

243

  // Log the signal arrival to the trace source

244

  m_signalCb (wifiRxParams ? true : false, senderNodeId, WToDbm (rxPowerW), rxDuration);

244

  m_signalCb (wifiRxParams ? true : false, senderNodeId, WToDbm (rxPowerW), rxDuration);

245

246

  // Do no further processing if signal is too weak

247

  // Current implementation assumes constant rx power over the packet duration

248

  if (WToDbm (rxPowerW) < GetRxSensitivity ())

249

250

      NS_LOG_INFO ("Received signal too weak to process: " << WToDbm (rxPowerW) << " dBm");

251

      return;

252

245

  if (wifiRxParams == 0)

253

  if (wifiRxParams == 0)

246

254

247

      NS_LOG_INFO ("Received non Wi-Fi signal");

255

      NS_LOG_INFO ("Received non Wi-Fi signal");

(-)a/src/wifi/model/wifi-phy-state-helper.cc (+1 lines)

Lines 517-522 WifiPhyStateHelper::SwitchMaybeToCcaBusy (Time duration)	Link Here

517

518

      m_startCcaBusy = now;

518

      m_startCcaBusy = now;

519

520

  m_stateLogger (now, duration, WifiPhyState::CCA_BUSY);

520

  m_endCcaBusy = std::max (m_endCcaBusy, now + duration);

521

  m_endCcaBusy = std::max (m_endCcaBusy, now + duration);

521

522

523




                   "The energy of a received signal should be higher than "
                   "this threshold (dbm) to allow the PHY layer to detect the signal.",
                   DoubleValue (-96.0),
                   MakeDoubleAccessor (&WifiPhy::m_edThreshold),
                   MakeDoubleChecker<double> (),
                   TypeId::DEPRECATED, "Replaced by RxSensitivity, this attribute has no effect.")
    .AddAttribute ("RxSensitivity",
                   "The energy of a received signal should be higher than "
                   "this threshold (dBm) for the PHY to detect the signal.",
                   DoubleValue (-101.0),
                   MakeDoubleAccessor (&WifiPhy::SetRxSensitivity,
                                       &WifiPhy::GetRxSensitivity),
                   MakeDoubleChecker<double> ())
    .AddAttribute ("CcaEdThreshold",
                   "The energy of a non Wi-Fi received signal should be higher than "
                   "this threshold (dbm) to allow the PHY layer to declare CCA BUSY state. "
                   "This check is performed on the 20 MHz primary channel only.",
                   DoubleValue (-62.0),
                   MakeDoubleAccessor (&WifiPhy::SetCcaEdThreshold,
                                       &WifiPhy::GetCcaEdThreshold),
                   MakeDoubleChecker<double> ())
    .AddAttribute ("TxGain",
                   "Transmission gain (dB).",

  InitializeFrequencyChannelNumber ();
}

Ptr<WifiPhyStateHelper>
WifiPhy::GetState (void) const
{
  return m_state;
}

void
WifiPhy::SetReceiveOkCallback (RxOkCallback callback)
{

}

void
WifiPhy::SetRxSensitivity (double threshold)
{
  NS_LOG_FUNCTION (this << threshold);
  m_rxSensitivityW = DbmToW (threshold);
}

double
WifiPhy::GetRxSensitivity (void) const
{
  return WToDbm (m_rxSensitivityW);
}

void
WifiPhy::SetCcaEdThreshold (double threshold)
{
  NS_LOG_FUNCTION (this << threshold);
  m_ccaEdThresholdW = DbmToW (threshold);
}

double
WifiPhy::GetCcaEdThreshold (void) const
{
  return WToDbm (m_ccaEdThresholdW);
}

void

    case WifiPhyState::SLEEP:
      {
        NS_LOG_DEBUG ("resuming from sleep mode");
        Time delayUntilCcaEnd = m_interference.GetEnergyDuration (m_ccaEdThresholdW);
        m_state->SwitchFromSleep (delayUntilCcaEnd);
        break;
      }

    case WifiPhyState::OFF:
      {
        NS_LOG_DEBUG ("resuming from off mode");
        Time delayUntilCcaEnd = m_interference.GetEnergyDuration (DbmToW (GetCcaEdThreshold ()));
        m_state->SwitchFromOff (delayUntilCcaEnd);
        break;
      }

  //In this model, CCA becomes busy when the aggregation of all signals as
  //tracked by the InterferenceHelper class is higher than the CcaBusyThreshold

  Time delayUntilCcaEnd = m_interference.GetEnergyDuration (DbmToW (GetCcaEdThreshold ()));
  if (!delayUntilCcaEnd.IsZero ())
    {
      m_state->SwitchMaybeToCcaBusy (delayUntilCcaEnd);

  //In this model, CCA becomes busy when the aggregation of all signals as
  //tracked by the InterferenceHelper class is higher than the CcaBusyThreshold

  Time delayUntilCcaEnd = m_interference.GetEnergyDuration (DbmToW (GetCcaEdThreshold ()));
  if (!delayUntilCcaEnd.IsZero ())
    {
      NS_LOG_DEBUG ("Calling SwitchMaybeToCcaBusy for " << delayUntilCcaEnd.As (Time::S));

WifiPhy::StartRx (Ptr<Packet> packet, WifiTxVector txVector, MpduType mpdutype, double rxPowerW, Time rxDuration, Ptr<Event> event)
{
  NS_LOG_FUNCTION (this << packet << txVector << +mpdutype << rxPowerW << rxDuration);

  AmpduTag ampduTag;
  WifiPreamble preamble = txVector.GetPreambleType ();
  if (preamble == WIFI_PREAMBLE_NONE && (m_mpdusNum == 0 || m_plcpSuccess == false))
    {
      m_plcpSuccess = false;
      m_mpdusNum = 0;
      NS_LOG_DEBUG ("drop packet because no PLCP preamble/header has been received");
      NotifyRxDrop (packet);
      MaybeCcaBusyDuration ();
      return;
    }
  else if (preamble != WIFI_PREAMBLE_NONE && packet->PeekPacketTag (ampduTag) && m_mpdusNum == 0)
    {
      //received the first MPDU in an MPDU
      m_mpdusNum = ampduTag.GetRemainingNbOfMpdus ();
      m_rxMpduReferenceNumber++;
    }
  else if (preamble == WIFI_PREAMBLE_NONE && packet->PeekPacketTag (ampduTag) && m_mpdusNum > 0)
    {
      //received the other MPDUs that are part of the A-MPDU
      if (ampduTag.GetRemainingNbOfMpdus () < (m_mpdusNum - 1))
      else if (preamble == WIFI_PREAMBLE_NONE && packet->PeekPacketTag (ampduTag) && m_mpdusNum > 0)
        {
          //received the other MPDUs that are part of the A-MPDU
          if (ampduTag.GetRemainingNbOfMpdus () < (m_mpdusNum - 1))
            {
              NS_LOG_DEBUG ("Missing MPDU from the A-MPDU " << m_mpdusNum - ampduTag.GetRemainingNbOfMpdus ());
              m_mpdusNum = ampduTag.GetRemainingNbOfMpdus ();
            }
          else
            {
              m_mpdusNum--;
            }
        }
      else if (preamble != WIFI_PREAMBLE_NONE && packet->PeekPacketTag (ampduTag) && m_mpdusNum > 0)
        {
          NS_LOG_DEBUG ("Missing MPDU from the A-MPDU " << m_mpdusNum - ampduTag.GetRemainingNbOfMpdus ());
          m_mpdusNum = ampduTag.GetRemainingNbOfMpdus ();
        }
      else
        {
          m_mpdusNum--;
          m_mpdusNum = 0;
        }
    }
  else if (preamble != WIFI_PREAMBLE_NONE && packet->PeekPacketTag (ampduTag) && m_mpdusNum > 0)
    {
      NS_LOG_DEBUG ("New A-MPDU started while " << m_mpdusNum << " MPDUs from previous are lost");
      m_mpdusNum = ampduTag.GetRemainingNbOfMpdus ();
    }
  else if (preamble != WIFI_PREAMBLE_NONE && m_mpdusNum > 0 )
    {
      NS_LOG_DEBUG ("Didn't receive the last MPDUs from an A-MPDU " << m_mpdusNum);
      m_mpdusNum = 0;
    }

  NS_LOG_DEBUG ("sync to signal (power=" << rxPowerW << "W)");
  m_currentEvent = event;
  m_state->SwitchToRx (rxDuration);
  NS_ASSERT (m_endPlcpRxEvent.IsExpired ());
  NotifyRxBegin (packet);
  m_interference.NotifyRxStart ();

      if (preamble != WIFI_PREAMBLE_NONE)
        {
          NS_ASSERT (m_endPlcpRxEvent.IsExpired ());
          Time preambleAndHeaderDuration = CalculatePlcpPreambleAndHeaderDuration (txVector);
          m_endPlcpRxEvent = Simulator::Schedule (preambleAndHeaderDuration, &WifiPhy::StartReceivePacket, this,
                                                  packet, txVector, mpdutype, event);
        }

  if (preamble != WIFI_PREAMBLE_NONE)
      m_endRxEvent = Simulator::Schedule (rxDuration, &WifiPhy::EndReceive, this,
                                          packet, preamble, mpdutype, event);
    }
  else
    {
      NS_ASSERT (m_endPlcpRxEvent.IsExpired ());
      Time preambleAndHeaderDuration = CalculatePlcpPreambleAndHeaderDuration (txVector);
      m_endPlcpRxEvent = Simulator::Schedule (preambleAndHeaderDuration, &WifiPhy::StartReceivePacket, this,
                                              packet, txVector, mpdutype, event);
      MaybeCcaBusyDuration ();
    }

  NS_ASSERT (m_endRxEvent.IsExpired ());
  m_endRxEvent = Simulator::Schedule (rxDuration, &WifiPhy::EndReceive, this,
                                      packet, preamble, mpdutype, event);
}

int64_t

(-)a/src/wifi/model/wifi-phy.h (-12 / +21 lines)

Lines 23-28	Link Here

#define WIFI_PHY_H

#define WIFI_PHY_H

#include "ns3/event-id.h"

#include "ns3/event-id.h"

#include "ns3/deprecated.h"

#include "wifi-mpdu-type.h"

#include "wifi-mpdu-type.h"

#include "wifi-phy-standard.h"

#include "wifi-phy-standard.h"

#include "interference-helper.h"

#include "interference-helper.h"

Lines 72-77 public:	Link Here

  WifiPhy ();

  WifiPhy ();

  virtual ~WifiPhy ();

  virtual ~WifiPhy ();

/**

   * Return the WifiPhyStateHelper of this PHY

   * \return the WifiPhyStateHelper of this PHY

*/

  Ptr<WifiPhyStateHelper> GetState (void) const;

/**

/**

   * \param callback the callback to invoke

   * \param callback the callback to invoke

Lines 1184-1202 public:	Link Here

1184

  virtual int64_t AssignStreams (int64_t stream);

1192

  virtual int64_t AssignStreams (int64_t stream);

1185

1193

1186

/**

1194

/**

1187

   * Sets the energy detection threshold (dBm).

1195

   * Sets the receive sensitivity threshold (dBm).

1188

   * The energy of a received signal should be higher than

1196

   * The energy of a received signal should be higher than

1189

   * this threshold (dbm) to allow the PHY layer to detect the signal.

1197

   * this threshold to allow the PHY layer to detect the signal.

1190

1198

1191

   * \param threshold the energy detection threshold in dBm

1199

   * \param threshold the receive sensitivity threshold in dBm

1192

*/

1200

*/

1193

  void SetEdThreshold (double threshold);

1201

  void SetRxSensitivity (double threshold);

1194

/**

1202

/**

1195

   * Return the energy detection threshold (dBm).

1203

   * Return the receive sensitivity threshold (dBm).

1196

1204

1197

   * \return the energy detection threshold in dBm

1205

   * \return the receive sensitivity threshold in dBm

1198

*/

1206

*/

1199

  double GetEdThreshold (void) const;

1207

  double GetRxSensitivity (void) const;

1200

/**

1208

/**

1201

   * Sets the CCA threshold (dBm). The energy of a received signal

1209

   * Sets the CCA threshold (dBm). The energy of a received signal

1202

   * should be higher than this threshold to allow the PHY

1210

   * should be higher than this threshold to allow the PHY

Lines 1204-1216 public:	Link Here

1204

1212

1205

   * \param threshold the CCA threshold in dBm

1213

   * \param threshold the CCA threshold in dBm

1206

*/

1214

*/

1207

  void SetCcaMode1Threshold (double threshold);

1215

  void SetCcaEdThreshold (double threshold);

1208

/**

1216

/**

1209

   * Return the CCA threshold (dBm).

1217

   * Return the CCA threshold (dBm).

1210

1218

1211

   * \return the CCA threshold in dBm

1219

   * \return the CCA threshold in dBm

1212

*/

1220

*/

1213

  double GetCcaMode1Threshold (void) const;

1221

  double GetCcaEdThreshold (void) const;

1214

/**

1222

/**

1215

   * Sets the RX loss (dB) in the Signal-to-Noise-Ratio due to non-idealities in the receiver.

1223

   * Sets the RX loss (dB) in the Signal-to-Noise-Ratio due to non-idealities in the receiver.

1216

1224

Lines 1480-1486 protected:	Link Here

1480

   * Check if Phy state should move to CCA busy state based on current

1488

   * Check if Phy state should move to CCA busy state based on current

1481

   * state of interference tracker.  In this model, CCA becomes busy when

1489

   * state of interference tracker.  In this model, CCA becomes busy when

1482

   * the aggregation of all signals as tracked by the InterferenceHelper

1490

   * the aggregation of all signals as tracked by the InterferenceHelper

1483

   * class is higher than the CcaMode1Threshold

1491

   * class is higher than the CcaEdThreshold

1484

*/

1492

*/

1485

  void SwitchMaybeToCcaBusy (void);

1493

  void SwitchMaybeToCcaBusy (void);

1486

1494

Lines 1742-1749 private:	Link Here

1742

  bool m_frequencyChannelNumberInitialized; //!< Store initialization state

1750

  bool m_frequencyChannelNumberInitialized; //!< Store initialization state

1743

  uint16_t m_channelWidth;                  //!< Channel width

1751

  uint16_t m_channelWidth;                  //!< Channel width

1744

1752

1745

  double   m_edThresholdW;        //!< Energy detection threshold in watts

1753

  double   m_edThreshold;         //!< CCA threshold in dB (DEPRECATED)

1746

  double   m_ccaMode1ThresholdW;  //!< Clear channel assessment (CCA) threshold in watts

1754

  double   m_rxSensitivityW;      //!< Receive sensitivity threshold in watts

1755

  double   m_ccaEdThresholdW;     //!< Clear channel assessment (CCA) threshold in watts

1747

  double   m_txGainDb;            //!< Transmission gain (dB)

1756

  double   m_txGainDb;            //!< Transmission gain (dB)

1748

  double   m_rxGainDb;            //!< Reception gain (dB)

1757

  double   m_rxGainDb;            //!< Reception gain (dB)

1749

  double   m_txPowerBaseDbm;      //!< Minimum transmission power (dBm)

1758

  double   m_txPowerBaseDbm;      //!< Minimum transmission power (dBm)

(-)a/src/wifi/model/yans-wifi-channel.cc (+7 lines)

Lines 125-130 void	Link Here

125

YansWifiChannel::Receive (Ptr<YansWifiPhy> phy, Ptr<Packet> packet, double rxPowerDbm, Time duration)

125

YansWifiChannel::Receive (Ptr<YansWifiPhy> phy, Ptr<Packet> packet, double rxPowerDbm, Time duration)

126

127

  NS_LOG_FUNCTION (phy << packet << rxPowerDbm << duration.GetSeconds ());

127

  NS_LOG_FUNCTION (phy << packet << rxPowerDbm << duration.GetSeconds ());

128

  // Do no further processing if signal is too weak

129

  // Current implementation assumes constant rx power over the packet duration

130

  if ((rxPowerDbm + phy->GetRxGain ()) < phy->GetRxSensitivity ())

131

132

      NS_LOG_INFO ("Received signal too weak to process: " << rxPowerDbm << " dBm");

133

      return;

134

128

  phy->StartReceivePreambleAndHeader (packet, DbmToW (rxPowerDbm + phy->GetRxGain ()), duration);

135

  phy->StartReceivePreambleAndHeader (packet, DbmToW (rxPowerDbm + phy->GetRxGain ()), duration);

129

136

130

137

(-)a/src/wifi/test/spectrum-wifi-phy-test.cc (-2 lines)

Lines 167-174 SpectrumWifiPhyBasicTest::DoSetup (void)	Link Here

167

  m_phy->SetFrequency (FREQUENCY);

167

  m_phy->SetFrequency (FREQUENCY);

168

  m_phy->SetReceiveOkCallback (MakeCallback (&SpectrumWifiPhyBasicTest::SpectrumWifiPhyRxSuccess, this));

168

  m_phy->SetReceiveOkCallback (MakeCallback (&SpectrumWifiPhyBasicTest::SpectrumWifiPhyRxSuccess, this));

169

  m_phy->SetReceiveErrorCallback (MakeCallback (&SpectrumWifiPhyBasicTest::SpectrumWifiPhyRxFailure, this));

169

  m_phy->SetReceiveErrorCallback (MakeCallback (&SpectrumWifiPhyBasicTest::SpectrumWifiPhyRxFailure, this));

170

  //Bug 2460: CcaMode1Threshold default should be set to -62 dBm when using Spectrum

171

  m_phy->SetCcaMode1Threshold (-62.0);

172

170

173

171

174

// Test that the expected number of packet receptions occur.

172

// Test that the expected number of packet receptions occur.




/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2018
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Author: Sébastien Deronne <sebastien.deronne@gmail.com>
 */

#include "ns3/log.h"
#include "ns3/test.h"
#include "ns3/spectrum-wifi-helper.h"
#include "ns3/wifi-spectrum-value-helper.h"
#include "ns3/spectrum-wifi-phy.h"
#include "ns3/nist-error-rate-model.h"
#include "ns3/wifi-mac-header.h"
#include "ns3/wifi-mac-trailer.h"
#include "ns3/wifi-phy-tag.h"
#include "ns3/wifi-spectrum-signal-parameters.h"
#include "ns3/wifi-utils.h"

using namespace ns3;

NS_LOG_COMPONENT_DEFINE ("WifiPhyThresholdsTest");

static const uint8_t CHANNEL_NUMBER = 36;
static const uint32_t FREQUENCY = 5180; //MHz
static const uint16_t CHANNEL_WIDTH = 20; //MHz

/**
 * \ingroup wifi-test
 * \ingroup tests
 *
 * \brief Wifi Phy Threshold Test base class
 */
class WifiPhyThresholdsTest : public TestCase
{
public:
  WifiPhyThresholdsTest (std::string test_name);
  virtual ~WifiPhyThresholdsTest ();

protected:
  /**
   * Make wifi signal function
   * \param txPowerWatts the transmit power in watts
   * \returns Ptr<SpectrumSignalParameters>
   */
  virtual Ptr<SpectrumSignalParameters> MakeWifiSignal (double txPowerWatts);
  /**
   * Make foreign signal function
   * \param txPowerWatts the transmit power in watts
   * \returns Ptr<SpectrumSignalParameters>
   */
  virtual Ptr<SpectrumSignalParameters> MakeForeignSignal (double txPowerWatts);
  /**
   * Send signal function
   * \param txPowerWatts the transmit power in watts
   * \param wifiSignal whether the signal is a wifi signal or not
   */
  virtual void SendSignal (double txPowerWatts, bool wifiSignal);
  /**
   * PHY receive success callback function
   * \param p the packet
   * \param snr the SNR
   * \param txVector the transmit vector
   */
  virtual void RxSuccess (Ptr<Packet> p, double snr, WifiTxVector txVector);
  /**
   * PHY receive failure callback function
   */
  virtual void RxFailure (void);
  /**
   * PHY dropped packet callback function
   * \param p the packet
   */
  virtual void RxDropped (Ptr<const Packet> p);
  /**
   * PHY state changed callback function
   * \param start the start time of the new state
   * \param duration the duration of the new state
   * \param newState the new state
   */
  virtual void PhyStateChanged (Time start, Time duration, WifiPhyState newState);

  Ptr<SpectrumWifiPhy> m_phy; ///< PHY object
  uint32_t m_rxSuccess;       ///< count number of successfully received packets
  uint32_t m_rxFailure;       ///< count number of unsuccessfully received packets
  uint32_t m_rxDropped;       ///< count number of dropped packets
  uint32_t m_stateChanged;    ///< count number of PHY state change
  uint32_t m_rxStateCount;    ///< count number of PHY state change to RX state
  uint32_t m_idleStateCount;    ///< count number of PHY state change to IDLE state
  uint32_t m_ccabusyStateCount; ///< count number of PHY state change to CCA_BUSY state

private:
  virtual void DoSetup (void);
};

WifiPhyThresholdsTest::WifiPhyThresholdsTest (std::string test_name)
  : TestCase (test_name),
    m_rxSuccess (0),
    m_rxFailure (0),
    m_rxDropped (0),
    m_stateChanged (0),
    m_rxStateCount (0),
    m_idleStateCount (0),
    m_ccabusyStateCount (0)
{
}

WifiPhyThresholdsTest::~WifiPhyThresholdsTest ()
{
}

Ptr<SpectrumSignalParameters>
WifiPhyThresholdsTest::MakeWifiSignal (double txPowerWatts)
{
  WifiTxVector txVector = WifiTxVector (WifiPhy::GetOfdmRate6Mbps (), 0, WIFI_PREAMBLE_LONG, false, 1, 1, 0, 20, false, false);
  MpduType mpdutype = NORMAL_MPDU;

  Ptr<Packet> pkt = Create<Packet> (1000);
  WifiMacHeader hdr;
  WifiMacTrailer trailer;

  hdr.SetType (WIFI_MAC_QOSDATA);
  hdr.SetQosTid (0);
  uint32_t size = pkt->GetSize () + hdr.GetSize () + trailer.GetSerializedSize ();
  Time txDuration = m_phy->CalculateTxDuration (size, txVector, m_phy->GetFrequency (), mpdutype, 0);
  hdr.SetDuration (txDuration);

  pkt->AddHeader (hdr);
  pkt->AddTrailer (trailer);
  WifiPhyTag tag (txVector, mpdutype, 1);
  pkt->AddPacketTag (tag);
  Ptr<SpectrumValue> txPowerSpectrum = WifiSpectrumValueHelper::CreateHeOfdmTxPowerSpectralDensity (FREQUENCY, CHANNEL_WIDTH, txPowerWatts, CHANNEL_WIDTH);
  Ptr<WifiSpectrumSignalParameters> txParams = Create<WifiSpectrumSignalParameters> ();
  txParams->psd = txPowerSpectrum;
  txParams->txPhy = 0;
  txParams->duration = txDuration;
  txParams->packet = pkt;
  return txParams;
}

Ptr<SpectrumSignalParameters>
WifiPhyThresholdsTest::MakeForeignSignal (double txPowerWatts)
{
  Ptr<SpectrumValue> txPowerSpectrum = WifiSpectrumValueHelper::CreateHeOfdmTxPowerSpectralDensity (FREQUENCY, CHANNEL_WIDTH, txPowerWatts, CHANNEL_WIDTH);
  Ptr<SpectrumSignalParameters> txParams = Create<SpectrumSignalParameters> ();
  txParams->psd = txPowerSpectrum;
  txParams->txPhy = 0;
  txParams->duration = Seconds (0.5);
  return txParams;
}

void
WifiPhyThresholdsTest::SendSignal (double txPowerWatts, bool wifiSignal)
{
  if (wifiSignal)
    {
      m_phy->StartRx (MakeWifiSignal (txPowerWatts));
    }
  else
    {
      m_phy->StartRx (MakeForeignSignal (txPowerWatts));
    }
}

void
WifiPhyThresholdsTest::RxSuccess (Ptr<Packet> p, double snr, WifiTxVector txVector)
{
  NS_LOG_FUNCTION (this << p << snr << txVector);
  m_rxSuccess++;
}

void
WifiPhyThresholdsTest::RxFailure (void)
{
  NS_LOG_FUNCTION (this);
  m_rxFailure++;
}

void
WifiPhyThresholdsTest::RxDropped (Ptr<const Packet> p)
{
  NS_LOG_FUNCTION (this << p);
  m_rxDropped++;
}

void
WifiPhyThresholdsTest::PhyStateChanged (Time start, Time duration, WifiPhyState newState)
{
  NS_LOG_FUNCTION (this << start << duration << newState);
  m_stateChanged++;
  if (newState == WifiPhyState::IDLE)
    {
      m_idleStateCount++;
    }
  else if (newState == WifiPhyState::RX)
    {
      m_rxStateCount++;
    }
  else if (newState == WifiPhyState::CCA_BUSY)
    {
      m_ccabusyStateCount++;
    }
}

void
WifiPhyThresholdsTest::DoSetup (void)
{
  m_phy = CreateObject<SpectrumWifiPhy> ();
  m_phy->ConfigureStandard (WIFI_PHY_STANDARD_80211ax_5GHZ);
  Ptr<ErrorRateModel> error = CreateObject<NistErrorRateModel> ();
  m_phy->SetErrorRateModel (error);
  m_phy->SetChannelNumber (CHANNEL_NUMBER);
  m_phy->SetFrequency (FREQUENCY);
  m_phy->SetReceiveOkCallback (MakeCallback (&WifiPhyThresholdsTest::RxSuccess, this));
  m_phy->SetReceiveErrorCallback (MakeCallback (&WifiPhyThresholdsTest::RxFailure, this));
  m_phy->TraceConnectWithoutContext ("PhyRxDrop", MakeCallback (&WifiPhyThresholdsTest::RxDropped, this));
  m_phy->GetState ()->TraceConnectWithoutContext ("State", MakeCallback (&WifiPhyThresholdsTest::PhyStateChanged, this));
}

/**
 * \ingroup wifi-test
 * \ingroup tests
 *
 * \brief Wifi Phy Threshold Weak Wifi Signal Test
 *
 * This test makes sure PHY ignores a Wi-Fi signal
 * if its received power lower than RxSensitivity.
 */
class WifiPhyThresholdsWeakWifiSignalTest : public WifiPhyThresholdsTest
{
public:
  WifiPhyThresholdsWeakWifiSignalTest ();
  virtual ~WifiPhyThresholdsWeakWifiSignalTest ();
  virtual void DoRun (void);
};

WifiPhyThresholdsWeakWifiSignalTest::WifiPhyThresholdsWeakWifiSignalTest ()
  : WifiPhyThresholdsTest ("WifiPhy reception thresholds: test weak wifi signal reception")
{
}

WifiPhyThresholdsWeakWifiSignalTest::~WifiPhyThresholdsWeakWifiSignalTest ()
{
}

void
WifiPhyThresholdsWeakWifiSignalTest::DoRun (void)
{
  WifiHelper::EnableLogComponents ();

  double txPowerWatts = DbmToW (-110);

  Simulator::Schedule (Seconds (1), &WifiPhyThresholdsWeakWifiSignalTest::SendSignal, this, txPowerWatts, true);

  Simulator::Run ();
  Simulator::Destroy ();

  NS_TEST_ASSERT_MSG_EQ (m_rxDropped + m_rxSuccess + m_rxFailure, 0, "Reception should not have been triggered if packet is weaker than RxSensitivity threshold");
  NS_TEST_ASSERT_MSG_EQ (m_stateChanged, 0, "State should stay idle if reception involves a signal weaker than RxSensitivity threshold");
}

/**
 * \ingroup wifi-test
 * \ingroup tests
 *
 * \brief Wifi Phy Threshold Weak Foreign Signal Test
 *
 * This test makes sure PHY keeps the state as IDLE if reception involves
 * a foreign signal with a received power lower than CcaEdThreshold.
 */
class WifiPhyThresholdsWeakForeignSignalTest : public WifiPhyThresholdsTest
{
public:
  WifiPhyThresholdsWeakForeignSignalTest ();
  virtual ~WifiPhyThresholdsWeakForeignSignalTest ();
  virtual void DoRun (void);
};

WifiPhyThresholdsWeakForeignSignalTest::WifiPhyThresholdsWeakForeignSignalTest ()
  : WifiPhyThresholdsTest ("WifiPhy reception thresholds: test weak foreign signal reception")
{
}

WifiPhyThresholdsWeakForeignSignalTest::~WifiPhyThresholdsWeakForeignSignalTest ()
{
}

void
WifiPhyThresholdsWeakForeignSignalTest::DoRun (void)
{
  WifiHelper::EnableLogComponents ();

  double txPowerWatts = DbmToW (-90);

  Simulator::Schedule (Seconds (1), &WifiPhyThresholdsWeakForeignSignalTest::SendSignal, this, txPowerWatts, false);

  Simulator::Run ();
  Simulator::Destroy ();

  NS_TEST_ASSERT_MSG_EQ (m_rxDropped + m_rxSuccess + m_rxFailure, 0, "Reception of non-wifi packet should not be triggered");
  NS_TEST_ASSERT_MSG_EQ (m_stateChanged, 0, "State should stay idle if reception involves a signal weaker than RxSensitivity threshold");
}

/**
 * \ingroup wifi-test
 * \ingroup tests
 *
 * \brief Wifi Phy Threshold Strong Wifi Signal Test
 *
 * This test makes sure PHY processes a Wi-Fi signal
 * with a received power higher than RxSensitivity.
 */
class WifiPhyThresholdsStrongWifiSignalTest : public WifiPhyThresholdsTest
{
public:
  WifiPhyThresholdsStrongWifiSignalTest ();
  virtual ~WifiPhyThresholdsStrongWifiSignalTest ();
  virtual void DoRun (void);
};

WifiPhyThresholdsStrongWifiSignalTest::WifiPhyThresholdsStrongWifiSignalTest ()
  : WifiPhyThresholdsTest ("WifiPhy reception thresholds: test strong wifi signal reception")
{
}

WifiPhyThresholdsStrongWifiSignalTest::~WifiPhyThresholdsStrongWifiSignalTest ()
{
}

void
WifiPhyThresholdsStrongWifiSignalTest::DoRun (void)
{
  WifiHelper::EnableLogComponents ();

  double txPowerWatts = DbmToW (-60);

  Simulator::Schedule (Seconds (1), &WifiPhyThresholdsStrongWifiSignalTest::SendSignal, this, txPowerWatts, true);

  Simulator::Run ();
  Simulator::Destroy ();

  NS_TEST_ASSERT_MSG_EQ (m_rxDropped + m_rxFailure, 0, "Packet reception should have been successfull");
  NS_TEST_ASSERT_MSG_EQ (m_rxSuccess, 1, "Packet should have been successfully received");
  NS_TEST_ASSERT_MSG_EQ (m_stateChanged, 2, "State should have moved to RX then back to IDLE");
  NS_TEST_ASSERT_MSG_EQ (m_rxStateCount, 1, "State should have moved to RX once");
  NS_TEST_ASSERT_MSG_EQ (m_idleStateCount, 1, "State should have moved to IDLE once");
}

/**
 * \ingroup wifi-test
 * \ingroup tests
 *
 * \brief Wifi Phy Threshold Strong Foreign Signal Test
 *
 * This test makes sure PHY declare the state as CCA_BUSY if reception involves
 * a foreign signal with a received power higher than CcaEdThreshold.
 */
class WifiPhyThresholdsStrongForeignSignalTest : public WifiPhyThresholdsTest
{
public:
  WifiPhyThresholdsStrongForeignSignalTest ();
  virtual ~WifiPhyThresholdsStrongForeignSignalTest ();
  virtual void DoRun (void);
};

WifiPhyThresholdsStrongForeignSignalTest::WifiPhyThresholdsStrongForeignSignalTest ()
  : WifiPhyThresholdsTest ("WifiPhy reception thresholds: test weak foreign signal reception")
{
}

WifiPhyThresholdsStrongForeignSignalTest::~WifiPhyThresholdsStrongForeignSignalTest ()
{
}

void
WifiPhyThresholdsStrongForeignSignalTest::DoRun (void)
{
  WifiHelper::EnableLogComponents ();

  double txPowerWatts = DbmToW (-60);

  Simulator::Schedule (Seconds (1), &WifiPhyThresholdsStrongForeignSignalTest::SendSignal, this, txPowerWatts, false);

  Simulator::Run ();
  Simulator::Destroy ();

  NS_TEST_ASSERT_MSG_EQ (m_rxDropped + m_rxSuccess + m_rxFailure, 0, "Reception of non-wifi packet should not be triggered");
  NS_TEST_ASSERT_MSG_EQ (m_ccabusyStateCount, 1, "State should have moved to CCA-BUSY");
}

/**
 * \ingroup wifi-test
 * \ingroup tests
 *
 * \brief Wifi Phy Thresholds Test Suite
 */
class WifiPhyThresholdsTestSuite : public TestSuite
{
public:
  WifiPhyThresholdsTestSuite ();
};

WifiPhyThresholdsTestSuite::WifiPhyThresholdsTestSuite ()
  : TestSuite ("wifi-phy-thresholds", UNIT)
{
  AddTestCase (new WifiPhyThresholdsWeakWifiSignalTest, TestCase::QUICK);
  AddTestCase (new WifiPhyThresholdsWeakForeignSignalTest, TestCase::QUICK);
  AddTestCase (new WifiPhyThresholdsStrongWifiSignalTest, TestCase::QUICK);
  AddTestCase (new WifiPhyThresholdsStrongForeignSignalTest, TestCase::QUICK);
}

static WifiPhyThresholdsTestSuite wifiPhyThresholdsTestSuite; ///< the test suite

(-)a/src/wifi/test/wifi-test.cc (-1 lines)

Lines 1269-1275 void	Link Here

1269

Bug2483TestCase::DoRun (void)

1269

Bug2483TestCase::DoRun (void)

1270

1271

  Config::SetDefault ("ns3::WifiRemoteStationManager::RtsCtsThreshold", StringValue ("500")); // so as to force RTS/CTS for data frames

1271

  Config::SetDefault ("ns3::WifiRemoteStationManager::RtsCtsThreshold", StringValue ("500")); // so as to force RTS/CTS for data frames

1272

  Config::SetDefault ("ns3::WifiPhy::CcaMode1Threshold", DoubleValue (-62.0));

1273

1272

1274

  uint16_t channelWidth = 40; // at least 40 MHz expected here

1273

  uint16_t channelWidth = 40; // at least 40 MHz expected here

1275

1274

(-)a/src/wifi/wscript (+1 lines)

Lines 109-114 def build(bld):	Link Here

109

        'test/wifi-aggregation-test.cc',

109

        'test/wifi-aggregation-test.cc',

110

        'test/wifi-error-rate-models-test.cc',

110

        'test/wifi-error-rate-models-test.cc',

111

        'test/wifi-transmit-mask-test.cc',

111

        'test/wifi-transmit-mask-test.cc',

112

        'test/wifi-phy-thresholds-test.cc',

112

113

114

    headers = bld(features='ns3header')

115

    headers = bld(features='ns3header')

Return to bug 2460