Attachment #2761 for bug #2368

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




/* -*-  Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) Crash Avoidance Metrics Partnership (CAMP) VSC3
 *
 * 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: Bin Cheng <cb3974@winlab.rutgers.edu>
 */

//

#include "ns3/core-module.h"
#include "ns3/frame-capture-model.h"
#include "ns3/gnuplot.h"

using namespace ns3;

int main (int argc, char *argv[])
{
  std::ofstream preambleCaptureFile ("preamble-capture-success-rate.plt");
  std::ofstream payloadCaptureFile ("payload-capture-success-rate.plt");

  Gnuplot preambleCapturePlot = Gnuplot ("preamble-capture-success-rate.eps");
  Gnuplot payloadCapturePlot = Gnuplot ("payload-capture-success-rate.eps");

  Ptr<FrameCaptureModel> captureModel = CreateObject<FrameCaptureModel> ();
  Gnuplot2dDataset preambleCaptureData ("Preamble-Capture");
  Gnuplot2dDataset payloadCaptureData ("Payload-Capture");

  for (double sinr = 0.0; sinr <= 15.0; sinr += 0.1)
    {
      double preambleRate = captureModel->CalculatePreambleCaptureProbability (std::pow (10.0, sinr / 10.0));
      preambleCaptureData.Add (sinr, preambleRate);
      double payloadRate = captureModel->CalculatePayloadCaptureProbability (std::pow (10.0, sinr / 10.0));
      payloadCaptureData.Add (sinr, payloadRate);
    }

  preambleCapturePlot.AddDataset (preambleCaptureData);
  payloadCapturePlot.AddDataset (payloadCaptureData);

  preambleCapturePlot.SetTerminal ("postscript eps color enh \"Times-BoldItalic\"");
  preambleCapturePlot.SetLegend ("SINR(dB)", "Preamble Capture Success Rate");
  preambleCapturePlot.SetExtra  ("set xrange [0:15]\n\
set yrange [0:1.1]\n\
set style line 1 linewidth 8"                                                                                                                                                                                                                                                                                                                                   );
  preambleCapturePlot.GenerateOutput (preambleCaptureFile);
  preambleCaptureFile.close ();

  payloadCapturePlot.SetTerminal ("postscript eps color enh \"Times-BoldItalic\"");
  payloadCapturePlot.SetLegend ("SNR(dB)", "Payload Capture Success Rate");
  payloadCapturePlot.SetExtra  ("set xrange [0:15]\n\
set yrange [0:1.1]\n\
set style line 1 linewidth 8"                                                                                                                                                                                                                                                                                                                                   );

  payloadCapturePlot.GenerateOutput (payloadCaptureFile);
  payloadCaptureFile.close ();
}

(-)a/src/wifi/examples/test-interference-helper.cc (-9 / +110 lines)

Lines 54-59	Link Here

#include "ns3/propagation-loss-model.h"

#include "ns3/propagation-loss-model.h"

#include "ns3/propagation-delay-model.h"

#include "ns3/propagation-delay-model.h"

#include "ns3/yans-error-rate-model.h"

#include "ns3/yans-error-rate-model.h"

#include "ns3/nist-error-rate-model.h"

#include "ns3/constant-position-mobility-model.h"

#include "ns3/constant-position-mobility-model.h"

using namespace ns3;

using namespace ns3;

Lines 71-80	Link Here

    std::string txModeB;

    std::string txModeB;

    uint32_t txPowerLevelA;

    uint32_t txPowerLevelA;

    uint32_t txPowerLevelB;

    uint32_t txPowerLevelB;

    double txPowerA;

    double txPowerB;

    uint32_t packetSizeA;

    uint32_t packetSizeA;

    uint32_t packetSizeB;

    uint32_t packetSizeB;

    WifiPhyStandard standard;

    WifiPhyStandard standard;

    WifiPreamble preamble;

    WifiPreamble preamble;

    bool enableFrameCapture;

    int numSentPackets;

};

};

  InterferenceExperiment ();

  InterferenceExperiment ();

Lines 96-101	Link Here

  txVector.SetTxPowerLevel (m_input.txPowerLevelA);

101

  txVector.SetTxPowerLevel (m_input.txPowerLevelA);

  txVector.SetMode (WifiMode (m_input.txModeA));

102

  txVector.SetMode (WifiMode (m_input.txModeA));

  txVector.SetPreambleType (m_input.preamble);

103

  txVector.SetPreambleType (m_input.preamble);

104

  m_txA->SetTxPowerStart (m_input.txPowerA);

105

  m_txA->SetTxPowerEnd (m_input.txPowerA);

  m_txA->SendPacket (p, txVector);

106

  m_txA->SendPacket (p, txVector);

100

107

101

108

Lines 107-112	Link Here

107

  txVector.SetTxPowerLevel (m_input.txPowerLevelB);

114

  txVector.SetTxPowerLevel (m_input.txPowerLevelB);

108

  txVector.SetMode (WifiMode (m_input.txModeB));

115

  txVector.SetMode (WifiMode (m_input.txModeB));

109

  txVector.SetPreambleType (m_input.preamble);

116

  txVector.SetPreambleType (m_input.preamble);

117

  m_txB->SetTxPowerStart (m_input.txPowerB);

118

  m_txB->SetTxPowerEnd (m_input.txPowerB);

110

  m_txB->SendPacket (p, txVector);

119

  m_txB->SendPacket (p, txVector);

111

120

112

121

Lines 121-130	Link Here

121

    txModeB ("OfdmRate54Mbps"),

130

    txModeB ("OfdmRate54Mbps"),

122

    txPowerLevelA (0),

131

    txPowerLevelA (0),

123

    txPowerLevelB (0),

132

    txPowerLevelB (0),

133

    txPowerA (20),

134

    txPowerB (20),

124

    packetSizeA (1500),

135

    packetSizeA (1500),

125

    packetSizeB (1500),

136

    packetSizeB (1500),

126

    standard (WIFI_PHY_STANDARD_80211a),

137

    standard (WIFI_PHY_STANDARD_80211a),

127

    preamble (WIFI_PREAMBLE_LONG)

138

    preamble (WIFI_PREAMBLE_LONG),

139

    enableFrameCapture (false),

140

    numSentPackets (1)

128

141

129

142

130

143

Lines 152-158	Link Here

152

  m_txB = CreateObject<YansWifiPhy> ();

165

  m_txB = CreateObject<YansWifiPhy> ();

153

  Ptr<YansWifiPhy> rx = CreateObject<YansWifiPhy> ();

166

  Ptr<YansWifiPhy> rx = CreateObject<YansWifiPhy> ();

154

167

155

  Ptr<ErrorRateModel> error = CreateObject<YansErrorRateModel> ();

168

  Ptr<ErrorRateModel> error = CreateObject<NistErrorRateModel> ();

156

  m_txA->SetErrorRateModel (error);

169

  m_txA->SetErrorRateModel (error);

157

  m_txB->SetErrorRateModel (error);

170

  m_txB->SetErrorRateModel (error);

158

  rx->SetErrorRateModel (error);

171

  rx->SetErrorRateModel (error);

Lines 167-174	Link Here

167

  m_txB->ConfigureStandard (input.standard);

180

  m_txB->ConfigureStandard (input.standard);

168

  rx->ConfigureStandard (input.standard);

181

  rx->ConfigureStandard (input.standard);

169

182

170

  Simulator::Schedule (Seconds (0), &InterferenceExperiment::SendA, this);

183

  m_txA->SetAttribute ("PreambleCaptureEnabled", BooleanValue (input.enableFrameCapture));

171

  Simulator::Schedule (Seconds (0) + input.interval, &InterferenceExperiment::SendB, this);

184

  m_txB->SetAttribute ("PreambleCaptureEnabled", BooleanValue (input.enableFrameCapture));

185

  rx->SetAttribute ("PreambleCaptureEnabled", BooleanValue (input.enableFrameCapture));

186

  m_txA->SetAttribute ("PayloadCaptureEnabled", BooleanValue (input.enableFrameCapture));

187

  m_txB->SetAttribute ("PayloadCaptureEnabled", BooleanValue (input.enableFrameCapture));

188

  rx->SetAttribute ("PayloadCaptureEnabled", BooleanValue (input.enableFrameCapture));

189

190

  for (int n = 0; n < input.numSentPackets; ++n)

191

192

      double start = 0.1 * n;

193

      Simulator::Schedule (Seconds (start), &InterferenceExperiment::SendA, this);

194

      Simulator::Schedule (Seconds (start) + input.interval, &InterferenceExperiment::SendB, this);

195

172

196

173

  Simulator::Run ();

197

  Simulator::Run ();

174

  Simulator::Destroy ();

198

  Simulator::Destroy ();

Lines 181-186	Link Here

181

  std::string str_standard = "WIFI_PHY_STANDARD_80211a";

205

  std::string str_standard = "WIFI_PHY_STANDARD_80211a";

182

  std::string str_preamble = "WIFI_PREAMBLE_LONG";

206

  std::string str_preamble = "WIFI_PREAMBLE_LONG";

183

  double delay = 0; //microseconds

207

  double delay = 0; //microseconds

208

  bool enableMultipleFrameCaptureTests = false; // If this is true, run tests for different frame capture cases

184

209

185

  CommandLine cmd;

210

  CommandLine cmd;

186

  cmd.AddValue ("delay", "Delay in microseconds between frame transmission from sender A and frame transmission from sender B", delay);

211

  cmd.AddValue ("delay", "Delay in microseconds between frame transmission from sender A and frame transmission from sender B", delay);

Lines 188-202	Link Here

188

  cmd.AddValue ("xB", "The position of transmitter B (> 0)", input.xB);

213

  cmd.AddValue ("xB", "The position of transmitter B (> 0)", input.xB);

189

  cmd.AddValue ("packetSizeA", "Packet size in bytes of transmitter A", input.packetSizeA);

214

  cmd.AddValue ("packetSizeA", "Packet size in bytes of transmitter A", input.packetSizeA);

190

  cmd.AddValue ("packetSizeB", "Packet size in bytes of transmitter B", input.packetSizeB);

215

  cmd.AddValue ("packetSizeB", "Packet size in bytes of transmitter B", input.packetSizeB);

191

  cmd.AddValue ("txPowerA", "TX power level of transmitter A", input.txPowerLevelA);

216

  cmd.AddValue ("txPowerLevelA", "TX power level of transmitter A", input.txPowerLevelA);

192

  cmd.AddValue ("txPowerB", "TX power level of transmitter B", input.txPowerLevelB);

217

  cmd.AddValue ("txPowerLevelB", "TX power level of transmitter B", input.txPowerLevelB);

218

  cmd.AddValue ("txPowerA", "Tx power of transmitter A", input.txPowerA);

219

  cmd.AddValue ("txPowerB", "Tx power of transmitter B", input.txPowerB);

193

  cmd.AddValue ("txModeA", "Wifi mode used for payload transmission of sender A", input.txModeA);

220

  cmd.AddValue ("txModeA", "Wifi mode used for payload transmission of sender A", input.txModeA);

194

  cmd.AddValue ("txModeB", "Wifi mode used for payload transmission of sender B", input.txModeB);

221

  cmd.AddValue ("txModeB", "Wifi mode used for payload transmission of sender B", input.txModeB);

195

  cmd.AddValue ("standard", "IEEE 802.11 flavor", str_standard);

222

  cmd.AddValue ("standard", "IEEE 802.11 flavor", str_standard);

196

  cmd.AddValue ("preamble", "Type of preamble", str_preamble);

223

  cmd.AddValue ("preamble", "Type of preamble", str_preamble);

224

  cmd.AddValue ("enableFrameCapture", "Enable frame capture capability", input.enableFrameCapture);

225

  cmd.AddValue ("enableMultipleFrameCaptureTests", "Enable test frame capture in difference scenarios", enableMultipleFrameCaptureTests);

197

  cmd.Parse (argc, argv);

226

  cmd.Parse (argc, argv);

198

227

199

  LogComponentEnable ("YansWifiPhy", LOG_LEVEL_ALL);

228

  LogComponentEnable ("WifiPhy", LOG_LEVEL_ALL);

200

  LogComponentEnable ("InterferenceHelper", LOG_LEVEL_ALL);

229

  LogComponentEnable ("InterferenceHelper", LOG_LEVEL_ALL);

201

230

202

  input.interval = MicroSeconds (delay);

231

  input.interval = MicroSeconds (delay);

Lines 258-265	Link Here

258

      return 0;

287

      return 0;

259

288

260

289

261

  InterferenceExperiment experiment;

290

  input.enableFrameCapture = true;

262

  experiment.Run (input);

291

  enableMultipleFrameCaptureTests = true;

292

  if (input.enableFrameCapture && enableMultipleFrameCaptureTests)

293

294

      InterferenceExperiment experiment;

263

295

296

      // There are two categories, 4 cases in the frame capture scenario. Two categories are the recovery

297

      // and the capture. The recovery means that the earlier arrived packet trends to be received. With

298

      // newly arrived packet as interference, a recovery probability is calculated, which determines whether

299

      // the reception of the packet can be continued. The capture means the later arrived packet tends to be

300

      // received. A capture probability is calculated to determine whether the receiver can switch to the new packet

301

      // For each category, two packets may collides at the preamble portion or the payload portion.

302

303

      // Note that different txPower of packet A and B can generate different SINR situations at the receiver

304

      int testIndex = 1;

305

      if (testIndex == 1)

306

307

          // test 1: gradually increase the tx power of the first sent packet (packet A)

308

          // in order to check: with newly arrived interference, under what condition, the packet

309

          // can still be recovery at the receiver, collision at the preamble portion of the packet

310

          input.interval = MicroSeconds (10); // two packets collides at the preamble portion of the first packet

311

          input.numSentPackets = 1000;

312

          for (double powerGap = 0.0; powerGap <= 15.0; powerGap += 0.2)

313

314

              input.txPowerA = input.txPowerB + powerGap;

315

              experiment.Run (input);

316

317

318

319

      else if (testIndex == 2)

320

321

          // test 2: gradually increase the tx power of the first sent packet (packet A)

322

          // in order to check: with newly arrived interference, under what condition, the packet

323

          // can still be recovery at the receiver, collision at the payload portion of the packet

324

          input.interval = MicroSeconds (100); // two packets collides at the payload portion of the first packet

325

          input.numSentPackets = 1000;

326

          for (double powerGap = 0.0; powerGap <= 15.0; powerGap += 0.2)

327

328

              input.txPowerA = input.txPowerB + powerGap;

329

              experiment.Run (input);

330

331

332

      else if (testIndex == 3)

333

334

          // test 3: gradually increase the tx power of the late sent packet (packet B)

335

          // in order to check: under what condition, the receiver can switch to the new packet,

336

          // collision at preamble portion of the packet

337

          input.interval = MicroSeconds (10); // two packets collides at the preamble portion of the first packet

338

          input.numSentPackets = 1000;

339

          for (double powerGap = 0.0; powerGap <= 15.0; powerGap += 0.2)

340

341

              input.txPowerB = input.txPowerA + powerGap;

342

              experiment.Run (input);

343

344

345

      else if (testIndex == 4)

346

347

          // test 4 : gradually increase the tx power of the late sent packet (packet B)

348

          // in order to check: under what condition, the receiver can switch to the new packet

349

          // collision at payload portion of the packet

350

          input.interval = MicroSeconds (100); // two packets collides at the payload portion of the first packet

351

          input.numSentPackets = 1000;

352

          for (double powerGap = 0.0; powerGap <= 15.0; powerGap += 0.2)

353

354

              input.txPowerB = input.txPowerA + powerGap;

355

              experiment.Run (input);

356

357

358

359

360

  else

361

362

      InterferenceExperiment experiment;

363

      experiment.Run (input);

364

264

  return 0;

365

  return 0;

265

366

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

Lines 11-17	Link Here

    obj = bld.create_ns3_program('test-interference-helper',

    obj = bld.create_ns3_program('test-interference-helper',

        ['core', 'mobility', 'network', 'wifi'])

        ['core', 'mobility', 'network', 'wifi'])

    obj.source = 'test-interference-helper.cc'

    obj.source = 'test-interference-helper.cc'

    obj = bld.create_ns3_program('ideal-wifi-manager-example',

    obj = bld.create_ns3_program('ideal-wifi-manager-example',

        ['core', 'network', 'wifi', 'stats', 'mobility', 'propagation'])

        ['core', 'network', 'wifi', 'stats', 'mobility', 'propagation'])

    obj.source = 'ideal-wifi-manager-example.cc'

    obj.source = 'ideal-wifi-manager-example.cc'

Lines 23-25	Link Here

    obj = bld.create_ns3_program('wifi-phy-configuration',

    obj = bld.create_ns3_program('wifi-phy-configuration',

        ['core', 'network', 'config-store', 'wifi'])

        ['core', 'network', 'config-store', 'wifi'])

    obj.source = 'wifi-phy-configuration.cc'

    obj.source = 'wifi-phy-configuration.cc'

    obj = bld.create_ns3_program('frame-capture-model-validation',

        ['core', 'wifi'])

    obj.source = 'frame-capture-model-validation.cc'




/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) Crash Avoidance Metrics Partnership (CAMP) VSC3
 *
 * 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: Bin Cheng <cb3974@winlab.rutgers.edu>
 */


#include "frame-capture-model.h"
#include <algorithm>
#include <cmath>
#include "wifi-utils.h"

namespace ns3 {

NS_OBJECT_ENSURE_REGISTERED (FrameCaptureModel);

TypeId
FrameCaptureModel::GetTypeId (void)
{
  static TypeId tid = TypeId ("ns3::FrameCaptureModel")
    .SetParent<Object> ()
    .SetGroupName ("Wifi")
    .AddConstructor<FrameCaptureModel> ()
  ;
  return tid;
}

FrameCaptureModel::FrameCaptureModel ()
{
}

double
FrameCaptureModel::CalculatePreambleCaptureProbability (double sinr)
{
  double z = std::sqrt (sinr / 4.0);
  double p = 0.5 * erfc (z);
  if (p == 0.0)
    {
      return 1.0;
    }
  double pe = CalculatePe (p);
  pe = std::min (pe, 1.0);
  double prob = std::pow (1 - pe, 240);
  return prob;
}

double
FrameCaptureModel::CalculatePayloadCaptureProbability (double sinr)
{
  double sinrDb = RatioToDb (sinr);
  double prob = 0.4989 * erf ((sinrDb - 9.356) / 0.8722) + 0.4989;
  prob = std::max (prob, 0.0);
  prob = std::min (prob, 1.0);
  return prob;
}

double
FrameCaptureModel::CalculatePe (double p)
{
  double D = std::sqrt (4.0 * p * (1.0 - p));
  double pe = 1.0;
  pe = 0.5 * (36.0 * std::pow (D, 10)
              + 211.0 * std::pow (D, 12)
              + 1404.0 * std::pow (D, 14)
              + 11633.0 * std::pow (D, 16)
              + 77433.0 * std::pow (D, 18)
              + 502690.0 * std::pow (D, 20)
              + 3322763.0 * std::pow (D, 22)
              + 21292910.0 * std::pow (D, 24)
              + 134365911.0 * std::pow (D, 26));
  return pe;
}

} // //namespace ns3




/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) Crash Avoidance Metrics Partnership (CAMP) VSC3
 *
 * 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: Bin Cheng <cb3974@winlab.rutgers.edu>
 *
 */


#ifndef FRAME_CAPTURE_MODEL_H
#define FRAME_CAPTURE_MODEL_H

#include "ns3/object.h"

namespace ns3 {

/**
 * \ingroup wifi
 * \brief models for switching between two receptions
 */
class FrameCaptureModel : public Object
{
public:
  static TypeId GetTypeId (void);
  FrameCaptureModel ();

  /**
   * Given a sinr value, calculate the probability of a successful
   * reception switch at the preamble/header portion of a packet
   *
   * \param the current sinr value
   *
   * \return the successful probability of the reception switch
   */
  double CalculatePreambleCaptureProbability (double sinr);

  /**
   * Given a sinr value, calculate the probability of a successful
   * reception switch at the payload portion of a packet
   *
   * \param the current sinr value
   *
   * \return the successful probability of the reception switch
   */
  double CalculatePayloadCaptureProbability (double sinr);
private:
  /**
   * Calculate a coded bit error rate
   *
   * \param p
   *
   * \return BER
   */
  double CalculatePe (double p);
};

} //namespace ns3

#endif /* FRAME_CAPTURE_MODEL_H */




InterferenceHelper::CalculateNoiseInterferenceW (Ptr<InterferenceHelper::Event> event, NiChanges *ni) const
{
  double noiseInterference = m_firstPower;
  for (NiChanges::const_iterator i = m_niChanges.begin (); i != m_niChanges.end (); ++i)
  for (NiChanges::const_iterator i = m_niChanges.begin () + 1; i != m_niChanges.end (); i++)
    {
      if (i->GetTime () < event->GetStartTime ())
        {
          noiseInterference += i->GetDelta ();
        }
      else if (i->GetTime () > event->GetStartTime () && i->GetTime () < event->GetEndTime ())
        {
          ni->push_back (*i);
        }
      else if (event->GetEndTime () == i->GetTime () && event->GetRxPowerW () == -i->GetDelta ())
        {
          break;
        }
      ni->push_back (*i);
    }
  ni->insert (ni->begin (), NiChange (event->GetStartTime (), noiseInterference));
  ni->push_back (NiChange (event->GetEndTime (), 0));

  m_rxing = false;
}

double
InterferenceHelper::CalculatePreambleCaptureProbability (double sinr)
{
  return m_frameCaptureModel->CalculatePreambleCaptureProbability (sinr);
}

double
InterferenceHelper::CalculatePayloadCaptureProbability (double sinr)
{
  return m_frameCaptureModel->CalculatePayloadCaptureProbability (sinr);
}

} //namespace ns3




#include "ns3/nstime.h"
#include "wifi-tx-vector.h"
#include "error-rate-model.h"
#include "frame-capture-model.h"

namespace ns3 {


   * Erase all events.
   */
  void EraseEvents (void);
  // following methods used to support frame capture capability
  /**
   * Calculate the successful probability for preamble capture
   * \param sinr the sinr value at the current time
   *
   * \return the probability of the successful preamble capture with the given sinr
   */
  double CalculatePreambleCaptureProbability (double sinr);
  /**
   * Calculate the successful probability for payload capture
   * \param sinr the sinr value at the current time
   *
   * \return the probability of the successful payload capture with the given sinr
   */
  double CalculatePayloadCaptureProbability (double sinr);

private:
  /**

  NiChanges m_niChanges;
  double m_firstPower;
  bool m_rxing;
  // following variables used for frame capture capability
  Ptr<FrameCaptureModel> m_frameCaptureModel;

  /// Returns an iterator to the first nichange, which is later than moment
  NiChanges::iterator GetPosition (Time moment);
  /**




    }
}

void
WifiPhyStateHelper::SwitchFromRxAbort (Ptr<Packet> packet, double snr)
{
  NS_ASSERT (IsStateRx ());
  NS_ASSERT (m_rxing);
  m_rxErrorTrace (packet, snr);
  NotifyRxEndError ();
  m_endRx = Simulator::Now ();
  DoSwitchFromRx ();
  NS_ASSERT (!IsStateRx ());
  if (!m_rxErrorCallback.IsNull ())
    {
      m_rxErrorCallback (packet, snr);
    }
}
} //namespace ns3

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

Lines 181-187	Link Here

181

   * \param duration the duration of CCA busy state

181

   * \param duration the duration of CCA busy state

182

*/

182

*/

183

  void SwitchFromSleep (Time duration);

183

  void SwitchFromSleep (Time duration);

184

/**

185

   * Abort current reception

186

*/

187

  void SwitchFromRxAbort (Ptr<Packet> packet, double snr);

185

  /** \todo Why is this public? */

188

  /** \todo Why is this public? */

186

  TracedCallback<Time, Time, WifiPhy::State> m_stateLogger;

189

  TracedCallback<Time, Time, WifiPhy::State> m_stateLogger;

187

190




                   MakeBooleanAccessor (&WifiPhy::GetShortPlcpPreambleSupported,
                                        &WifiPhy::SetShortPlcpPreambleSupported),
                   MakeBooleanChecker ())
    .AddAttribute ("PreambleCaptureEnabled",
                   "Whether or not to enable capture at the preamble portion of the packet.",
                   BooleanValue (false),
                   MakeBooleanAccessor (&WifiPhy::m_doPreambleCapture),
                   MakeBooleanChecker ())
    .AddAttribute ("PayloadCaptureEnabled",
                   "Whether or not to enable capture at the payload portion of the packet",
                   BooleanValue (false),
                   MakeBooleanAccessor (&WifiPhy::m_doPayloadCapture),
                   MakeBooleanChecker ())
    .AddTraceSource ("PhyTxBegin",
                     "Trace source indicating a packet "
                     "has begun transmitting over the channel medium",

    {
      // erase all HtMcs modes from deviceMcsSet
      size_t index = m_deviceMcsSet.size () - 1;
      for (std::vector<WifiMode>::reverse_iterator rit = m_deviceMcsSet.rbegin (); rit != m_deviceMcsSet.rend (); ++rit, --index)
        {
          if (m_deviceMcsSet[index].GetModulationClass () == WIFI_MOD_CLASS_HT)
            {
              m_deviceMcsSet.erase (m_deviceMcsSet.begin () + index);
            }

    {
      if (it->second == f)
        {
          found = true;
          break;
        }
      ++it;
    }

        //check tables 20-35 and 20-36 in the .11n standard to get cases when nes = 2
        double Nes = 1;
        if (payloadMode.GetUniqueName () == "HtMcs21"
            || payloadMode.GetUniqueName () == "HtMcs22"
            || payloadMode.GetUniqueName () == "HtMcs23"
            || payloadMode.GetUniqueName () == "HtMcs28"
            || payloadMode.GetUniqueName () == "HtMcs29"
            || payloadMode.GetUniqueName () == "HtMcs30"
            || payloadMode.GetUniqueName () == "HtMcs31")
          {
            Nes = 2;
          }

Time
WifiPhy::CalculatePlcpPreambleAndHeaderDuration (WifiTxVector txVector)
{
  WifiPreamble preamble = txVector.GetPreambleType ();
  Time duration = GetPlcpPreambleDuration (txVector)
    + GetPlcpHeaderDuration (txVector)
    + GetPlcpHtSigHeaderDuration (preamble)

   *  - we are idle
   */
  NS_ASSERT (!m_state->IsStateTx () && !m_state->IsStateSwitching ());

  if (txVector.GetNss () > GetMaxSupportedTxSpatialStreams ())
    {
      NS_FATAL_ERROR ("Unsupported number of spatial streams!");

  newPacket->RemovePacketTag (oldtag);
  WifiPhyTag tag (txVector, mpdutype);
  newPacket->AddPacketTag (tag);

  StartTx (newPacket, txVector, txDuration);
}


  NS_LOG_FUNCTION (this << packet << WToDbm (rxPowerW) << rxDuration);
  AmpduTag ampduTag;
  Time endRx = Simulator::Now () + rxDuration;

  WifiPhyTag tag;
  bool found = packet->RemovePacketTag (tag);
  if (!found)

    }

  WifiTxVector txVector = tag.GetWifiTxVector ();

  if (txVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_HT
      && (txVector.GetNss () != (1 + (txVector.GetMode ().GetMcsValue () / 8))))
    {
      NS_FATAL_ERROR ("MCS value does not match NSS value: MCS = " << (uint16_t)txVector.GetMode ().GetMcsValue () << ", NSS = " << (uint16_t)txVector.GetNss ());
    }

  if (txVector.GetNss () > GetMaxSupportedRxSpatialStreams ())
    {
      NS_FATAL_ERROR ("Reception ends in failure because of an unsupported number of spatial streams");
    }

  WifiPreamble preamble = txVector.GetPreambleType ();
  MpduType mpdutype = tag.GetMpduType ();

        {
          //that packet will be noise _after_ the completion of the
          //channel switching.
          CalculateCcaBusyDuration ();
        }
      break;
    case WifiPhy::RX:
      {
        NS_ASSERT (m_rxPacketEvent != NULL);
        if (m_doPreambleCapture == false
            || m_doPayloadCapture == false
            || preamble == WIFI_PREAMBLE_NONE)
          {
            NS_LOG_DEBUG ("cannot perform frame capture capture");
            NotifyRxDrop (packet);
            if (endRx > Simulator::Now () + m_state->GetDelayUntilIdle ())
              {
                CalculateCcaBusyDuration ();
              }
            break;
          }

        Time currentRxStage = Simulator::Now () - m_rxPacketEvent->GetStartTime ();
        bool doReceptionSwitch = false;
        if (m_rxPreambleType != WIFI_PREAMBLE_NONE
            && currentRxStage < preambleAndHeaderDuration) // still receiving the preamble and plcp header portion of the old packet
          {
            doReceptionSwitch = CheckPreambleCapture (packet, event);
          }
        else
          {
            doReceptionSwitch = CheckPayloadCapture (packet, event);
          }
        if (doReceptionSwitch)
          {
            NS_LOG_INFO ("The receiver switches to the new packet (rxPowerDbm " << WToDbm (event->GetRxPowerW ()) << ")");
            m_endPlcpRxEvent = Simulator::Schedule (preambleAndHeaderDuration, &WifiPhy::StartReceivePacket, this,
                                                    packet, txVector, mpdutype, event);
            m_endRxEvent = Simulator::Schedule (rxDuration, &WifiPhy::EndReceive, this,
                                                packet, preamble, mpdutype, event);
            m_rxPreambleType = preamble;
          }
        break;
      }
    case WifiPhy::TX:
      NS_LOG_DEBUG ("drop packet because already in Tx (power=" <<
                    rxPowerW << "W)");

        {
          //that packet will be noise _after_ the transmission of the
          //currently-transmitted packet.
          CalculateCcaBusyDuration ();
        }
      break;
    case WifiPhy::CCA_BUSY:

              m_mpdusNum = 0;
              NS_LOG_DEBUG ("drop packet because no PLCP preamble/header has been received");
              NotifyRxDrop (packet);
              CalculateCcaBusyDuration ();
            }
          else if (preamble != WIFI_PREAMBLE_NONE && packet->PeekPacketTag (ampduTag) && m_mpdusNum == 0)
            {

          NS_ASSERT (m_endPlcpRxEvent.IsExpired ());
          NotifyRxBegin (packet);
          m_interference.NotifyRxStart ();
          m_rxPacket = packet;
          m_rxPacketEvent = event;
          m_rxPreambleType = preamble;

          if (preamble != WIFI_PREAMBLE_NONE)
            {

                        rxPowerW << "<" << GetEdThresholdW () << ")");
          NotifyRxDrop (packet);
          m_plcpSuccess = false;
          CalculateCcaBusyDuration ();
        }
      break;
    case WifiPhy::SLEEP:

    }

  return;
}

void
WifiPhy::CalculateCcaBusyDuration ()
{
//  maybeCcaBusy:
//We are here because we have received the first bit of a packet and we are
//not going to be able to synchronize on it
//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 (GetCcaMode1Threshold ()));
  if (!delayUntilCcaEnd.IsZero ())

    }
}

bool
WifiPhy::CheckPreambleCapture (Ptr<Packet> packet, Ptr<InterferenceHelper::Event> event)
{
  NS_LOG_FUNCTION (this << packet << event);
  NS_LOG_DEBUG (Simulator::Now () << ", preamble capture check: old reception event start at "
                                  << m_rxPacketEvent->GetStartTime ()
                                  << ", old preamble type " << m_rxPreambleType
                                  << ", end at " << m_rxPacketEvent->GetEndTime ()
                                  << ", old rxPower " << m_rxPacketEvent->GetRxPowerW ());
  bool result = false;
  Time endRx = event->GetEndTime ();
  InterferenceHelper::SnrPer snrPer;
  snrPer = m_interference.CalculatePlcpHeaderSnrPer (m_rxPacketEvent); // check whether the plcp header can still decoded
  NS_LOG_DEBUG ("snr(dB)=" << RatioToDb (snrPer.snr) << ", per=" << snrPer.per);
  if (m_random->GetValue () > snrPer.per)  // the reception of the old packet can be continued
    {
      NS_ASSERT (m_endPlcpRxEvent.IsRunning ());
      NS_LOG_INFO (Simulator::Now () << " preamble capture check: dropping newly arrived packet"
                                     << ", because already sync to a stronger enough signal");
      NotifyRxDrop (packet);
      if (endRx > Simulator::Now () + m_state->GetDelayUntilIdle ())
        {
          CalculateCcaBusyDuration ();
        }
    }
  else // the reception of the old packet cannot be continued
    {
      NS_LOG_INFO (Simulator::Now () << " preamble capture check: dropping currently received packet");
      AbortCurrentReception (m_rxPacket, snrPer.snr);

      NS_ASSERT (m_endPlcpRxEvent.IsExpired () && m_endRxEvent.IsExpired ());
      NS_LOG_INFO (Simulator::Now () << " preamble capture check: switch to new packet");

      InterferenceHelper::SnrPer snrPerForNewPkt;
      snrPerForNewPkt = m_interference.CalculatePlcpHeaderSnrPer (event);
      double prob = m_interference.CalculatePreambleCaptureProbability (snrPerForNewPkt.snr);
      if (m_random->GetValue () < prob)
        {
          SwitchReception (packet, event);
          result = true;
        }
      else
        {
          NS_LOG_INFO (Simulator::Now () << " preamble capture: signal is too low for capture");
          NotifyRxDrop (packet);
          if (endRx > Simulator::Now () + m_state->GetDelayUntilIdle ())
            {
              CalculateCcaBusyDuration ();
            }
        }
    }
  return result;
}

bool
WifiPhy::CheckPayloadCapture (Ptr<Packet> packet, Ptr<InterferenceHelper::Event> event)
{
  NS_LOG_FUNCTION (this << packet << event);
  NS_LOG_DEBUG (Simulator::Now () << ", payload capture check: old reception event start at "
                                  << m_rxPacketEvent->GetStartTime ()
                                  << ", end at " << m_rxPacketEvent->GetEndTime ()
                                  << ", old rxPower " << m_rxPacketEvent->GetRxPowerW ());
  bool result = false;
  Time endRx = event->GetEndTime ();
  InterferenceHelper::SnrPer snrPer;
  snrPer = m_interference.CalculatePlcpPayloadSnrPer (m_rxPacketEvent); // check whether the plcp header can still decoded
  NS_LOG_DEBUG ("snr(dB)=" << RatioToDb (snrPer.snr) << ", per=" << snrPer.per);
  if (m_random->GetValue () > snrPer.per)  // the reception of the old packet can be continued
    {
      NS_ASSERT (m_endRxEvent.IsRunning ());
      NS_LOG_INFO (Simulator::Now () << " payload capture check: dropping newly arrived packet"
                                     << ", because already sync to a stronger enough signal");
      NotifyRxDrop (packet);
      if (endRx > Simulator::Now () + m_state->GetDelayUntilIdle ())
        {
          CalculateCcaBusyDuration ();
        }
    }
  else // the reception of the old packet cannot be continued
    {
      NS_LOG_INFO (Simulator::Now () << " preamble capture check: dropping currently received packet");
      AbortCurrentReception (m_rxPacket, snrPer.snr);

      NS_ASSERT (m_endPlcpRxEvent.IsExpired () && m_endRxEvent.IsExpired ());
      NS_LOG_INFO (Simulator::Now () << " payload capture check: switch to new packet");

      InterferenceHelper::SnrPer snrPerForNewPkt;
      snrPerForNewPkt = m_interference.CalculatePlcpPayloadSnrPer (event);
      double prob = m_interference.CalculatePayloadCaptureProbability (snrPerForNewPkt.snr);
      if (m_random->GetValue () < prob)
        {
          SwitchReception (packet, event);
          result = true;
        }
      else
        {
          NS_LOG_INFO (Simulator::Now () << " payload capture: signal is too low for capture");
          NotifyRxDrop (packet);
          if (endRx > Simulator::Now () + m_state->GetDelayUntilIdle ())
            {
              CalculateCcaBusyDuration ();
            }
        }
    }
  return result;
}

void
WifiPhy::AbortCurrentReception (Ptr<Packet> packet, double sinr)
{
  NS_LOG_FUNCTION (this << packet << sinr);
  if (m_endPlcpRxEvent.IsRunning ())
    {
      m_endPlcpRxEvent.Cancel ();
    }
  if (m_endRxEvent.IsRunning ())
    {
      m_endRxEvent.Cancel ();
    }
  m_interference.NotifyRxEnd ();
  m_state->SwitchFromRxAbort (packet, sinr);
  m_rxPacket = NULL;
  m_rxPacketEvent = NULL;
  m_rxPreambleType = WIFI_PREAMBLE_NONE;
}

void
WifiPhy::SwitchReception (Ptr<Packet> packet, Ptr<InterferenceHelper::Event> event)
{
  NS_LOG_FUNCTION (this << packet << event);
  m_rxPacket = packet;
  m_rxPacketEvent = event;
  m_state->SwitchToRx (event->GetDuration ());
  NotifyRxBegin (packet);
  m_interference.NotifyRxStart ();
}

void
WifiPhy::StartReceivePacket (Ptr<Packet> packet,
                             WifiTxVector txVector,

        {
          NS_LOG_DEBUG ("receiving plcp payload"); //endReceive is already scheduled
          m_plcpSuccess = true;
          NS_LOG_INFO ("decode plcp successfully (rxPowerDbm " << WToDbm (event->GetRxPowerW ()) << ")");
        }
      else //mode is not allowed
        {

          aMpdu.mpduRefNumber = m_rxMpduReferenceNumber;
          NotifyMonitorSniffRx (packet, GetFrequency (), event->GetTxVector (), aMpdu, signalNoise);
          m_state->SwitchFromRxEndOk (packet, snrPer.snr, event->GetTxVector ());
          NS_LOG_INFO ("decode payload successfully (rxPowerDbm " << WToDbm (event->GetRxPowerW ()) << ")");
        }
      else
        {

WifiPhy::IsValidTxVector (WifiTxVector txVector)
{
  uint8_t chWidth = txVector.GetChannelWidth ();
  uint8_t nss = txVector.GetNss ();
  std::string modeName = txVector.GetMode ().GetUniqueName ();

  if (chWidth == 20)




   */
  virtual std::vector<uint8_t> GetSupportedChannelWidthSet (void) const;


protected:
  // Inherited
  virtual void DoInitialize (void);

   * of its size.
   */
  TracedCallback<Ptr<const Packet>, uint16_t, WifiTxVector, MpduInfo> m_phyMonitorSniffTxTrace;

  /**
   * Due to newly arrived signal, the old reception cannot be continued and has to be abort
   *
   * \param packet, the packet which has to be aborted
   * \param sinr, the sinr of the aborted packet
   */
  void AbortCurrentReception (Ptr<Packet> packet, double sinr);

  /**
   * Calculate the duration of CCA busy
   */
  void CalculateCcaBusyDuration (void);

  /**
   * Check whether preamble capture can be triggered
   *
   * \param packet the newly arrived packet which needs to be check for capture
   * \param event the receiving event associated with the receiving packet
   *
   * \return whether the capture, i.e., reception switching, has been successful
   */
  bool CheckPreambleCapture (Ptr<Packet> packet, Ptr<InterferenceHelper::Event> event);

  /**
   * Check whether payload capture can be triggered
   *
   * \param packet the newly arrived packet which needs to be check for capture
   * \param event the receiving event associated with the receiving packet
   *
   * \return whether the capture, i.e., reception switching, has been successful
   */
  bool CheckPayloadCapture (Ptr<Packet> packet, Ptr<InterferenceHelper::Event> event);

  /**
   * The new packet passes the check and the receiver is going to switch to the new packet
   *
   * \param packet the packet will be switched to
   * \param event receiving event associated with the packet
   */
  void SwitchReception (Ptr<Packet> packet, Ptr<InterferenceHelper::Event> event);

  /**
   * This vector holds the set of transmission modes that this
   * WifiPhy(-derived class) can support. In conversation we call this

  
  Ptr<NetDevice>     m_device;   //!< Pointer to the device
  Ptr<MobilityModel> m_mobility; //!< Pointer to the mobility model

  // following variables used to support frame capture capability
  Ptr<Packet> m_rxPacket;                         // The packet that is currently being received by the receiver
  Ptr<InterferenceHelper::Event> m_rxPacketEvent; // The event that indicates the current receiving event
  bool m_doPreambleCapture;                       // The flag indicates whether the capture at the preamble portion of the packet is enabled or not
  bool m_doPayloadCapture;                        // The flag indicates whether the capture at the payload(data) portion of the packet is enabled or not
  WifiPreamble m_rxPreambleType;                  // The preamble type of the currently receiving frame
};

/**

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

Lines 82-87	Link Here

        'model/vht-operation.cc',

        'model/vht-operation.cc',

        'model/dsss-parameter-set.cc',

        'model/dsss-parameter-set.cc',

        'model/edca-parameter-set.cc',

        'model/edca-parameter-set.cc',

        'model/frame-capture-model.cc',

        'helper/wifi-radio-energy-model-helper.cc',

        'helper/wifi-radio-energy-model-helper.cc',

        'helper/vht-wifi-mac-helper.cc',

        'helper/vht-wifi-mac-helper.cc',

        'helper/ht-wifi-mac-helper.cc',

        'helper/ht-wifi-mac-helper.cc',

Lines 188-193	Link Here

188

        'model/vht-operation.h',

189

        'model/vht-operation.h',

189

        'model/dsss-parameter-set.h',

190

        'model/dsss-parameter-set.h',

190

        'model/edca-parameter-set.h',

191

        'model/edca-parameter-set.h',

192

        'model/frame-capture-model.h',

191

        'helper/wifi-radio-energy-model-helper.h',

193

        'helper/wifi-radio-energy-model-helper.h',

192

        'helper/vht-wifi-mac-helper.h',

194

        'helper/vht-wifi-mac-helper.h',

193

        'helper/ht-wifi-mac-helper.h',

195

        'helper/ht-wifi-mac-helper.h',

Return to bug 2368