Attachment #3219 for bug #2460

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




  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) ); 

(-)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




                   MakeUintegerAccessor (&WifiPhy::SetChannelNumber,
                                         &WifiPhy::GetChannelNumber),
                   MakeUintegerChecker<uint8_t> (0, 196))
    .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 received signal should be higher than "
                   "this threshold (dbm) to allow the PHY layer to declare CCA BUSY state.",
                   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 / +20 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_rxSensitivityW;      //!< Receive sensitivity threshold in watts

1746

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

1754

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

1747

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

1755

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

1748

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

1756

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

1749

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

1757

  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