Attachment #2765 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>
 */

// This script is to generate two figures showing the frame capture models,
// one for preamble capture, one for payload capture. The generated figures
// can be used to compare with Fig 6 in paper
// "Experience: accurate simulation of dense scenarios with hundreds of vehicular transmitters",
// in proceeding of the 22nd Annual International Conference on Mobile Computing
// and Networking (MobiCom '16).

// The simulation performance with and without frame capture effect is also
// shown in Fig. 9 of the same paper.


#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 (-8 / +167 lines)

Lines 56-61	Link Here

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

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

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

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

#define PREAMBLE_RECOVERY_TEST 1

#define PAYLOAD_RECOVERY_TEST 2

#define PREAMBLE_CAPTURE_TEST 3

#define PAYLOAD_CAPTURE_TEST 4

using namespace ns3;

using namespace ns3;

class InterferenceExperiment

class InterferenceExperiment

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

    bool enablePayloadCapture;

    int numSentPackets;

};

};

  InterferenceExperiment ();

  InterferenceExperiment ();

Lines 96-101	Link Here

  txVector.SetTxPowerLevel (m_input.txPowerLevelA);

106

  txVector.SetTxPowerLevel (m_input.txPowerLevelA);

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

107

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

  txVector.SetPreambleType (m_input.preamble);

108

  txVector.SetPreambleType (m_input.preamble);

109

  m_txA->SetTxPowerStart (m_input.txPowerA);

110

  m_txA->SetTxPowerEnd (m_input.txPowerA);

  m_txA->SendPacket (p, txVector);

111

  m_txA->SendPacket (p, txVector);

100

112

101

113

Lines 107-112	Link Here

107

  txVector.SetTxPowerLevel (m_input.txPowerLevelB);

119

  txVector.SetTxPowerLevel (m_input.txPowerLevelB);

108

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

120

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

109

  txVector.SetPreambleType (m_input.preamble);

121

  txVector.SetPreambleType (m_input.preamble);

122

  m_txB->SetTxPowerStart (m_input.txPowerB);

123

  m_txB->SetTxPowerEnd (m_input.txPowerB);

110

  m_txB->SendPacket (p, txVector);

124

  m_txB->SendPacket (p, txVector);

111

125

112

126

Lines 121-130	Link Here

121

    txModeB ("OfdmRate54Mbps"),

135

    txModeB ("OfdmRate54Mbps"),

122

    txPowerLevelA (0),

136

    txPowerLevelA (0),

123

    txPowerLevelB (0),

137

    txPowerLevelB (0),

138

    txPowerA (20),

139

    txPowerB (20),

124

    packetSizeA (1500),

140

    packetSizeA (1500),

125

    packetSizeB (1500),

141

    packetSizeB (1500),

126

    standard (WIFI_PHY_STANDARD_80211a),

142

    standard (WIFI_PHY_STANDARD_80211a),

127

    preamble (WIFI_PREAMBLE_LONG)

143

    preamble (WIFI_PREAMBLE_LONG),

144

    enablePreambleCapture (false),

145

    enablePayloadCapture (false),

146

    numSentPackets (1)

128

147

129

148

130

149

Lines 167-174	Link Here

167

  m_txB->ConfigureStandard (input.standard);

186

  m_txB->ConfigureStandard (input.standard);

168

  rx->ConfigureStandard (input.standard);

187

  rx->ConfigureStandard (input.standard);

169

188

170

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

189

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

171

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

190

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

191

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

192

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

193

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

194

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

195

196

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

197

198

      double start = 0.1 * n;

199

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

200

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

201

172

202

173

  Simulator::Run ();

203

  Simulator::Run ();

174

  Simulator::Destroy ();

204

  Simulator::Destroy ();

Lines 181-186	Link Here

181

  std::string str_standard = "WIFI_PHY_STANDARD_80211a";

211

  std::string str_standard = "WIFI_PHY_STANDARD_80211a";

182

  std::string str_preamble = "WIFI_PREAMBLE_LONG";

212

  std::string str_preamble = "WIFI_PREAMBLE_LONG";

183

  double delay = 0; //microseconds

213

  double delay = 0; //microseconds

214

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

184

215

185

  CommandLine cmd;

216

  CommandLine cmd;

186

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

217

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

219

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

189

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

220

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

221

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

191

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

222

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

192

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

223

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

224

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

225

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

226

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

227

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

195

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

228

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

196

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

229

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

230

  cmd.AddValue ("enablePreambleCapture", "Enable frame capture capability at preamble portion", input.enablePreambleCapture);

231

  cmd.AddValue ("enablePayloadCapture", "Enable frame capture capability at payload portion", input.enablePayloadCapture);

232

  cmd.AddValue ("testDifferentPacketCollisionScenarios", "Test frame reception/capture behaviors in different frame collision scenarios",

233

		testDifferentPacketCollisionScenarios);

197

  cmd.Parse (argc, argv);

234

  cmd.Parse (argc, argv);

198

235

199

  LogComponentEnable ("YansWifiPhy", LOG_LEVEL_ALL);

236

  LogComponentEnable ("WifiPhy", LOG_LEVEL_ALL);

200

  LogComponentEnable ("InterferenceHelper", LOG_LEVEL_ALL);

237

  LogComponentEnable ("InterferenceHelper", LOG_LEVEL_ALL);

201

238

202

  input.interval = MicroSeconds (delay);

239

  input.interval = MicroSeconds (delay);

Lines 258-265	Link Here

258

      return 0;

295

      return 0;

259

296

260

297

261

  InterferenceExperiment experiment;

298

  if (testDifferentPacketCollisionScenarios)

262

  experiment.Run (input);

299

300

      InterferenceExperiment experiment;

263

301

302

      // There are two categories, 4 different packet collision scenarios. Two categories are the recovery

303

      // and the capture.

304

      //   Packet A arrives first

305

      // |-------------------------|

306

      // 	      Packet B arrives later

307

      //           |-------------------------|

308

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

309

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

310

      // the reception of this packet can be continued.

311

312

      // The capture means the later arrived packet tends to be received. A capture probability is calculated

313

      // to determine whether the receiver can switch to this newly arrived packet.

314

315

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

316

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

317

318

      int testName = PREAMBLE_CAPTURE_TEST;  // define what test to run

319

320

      switch (testName)

321

322

323

        case PREAMBLE_RECOVERY_TEST:

324

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

325

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

326

          // can still be recovery at the receiver.

327

328

          // Two packets collide at the preamble portion of the packet

329

          // In this test, with and without frame capture capability will not generate differences.

330

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

331

          input.numSentPackets = 1000;

332

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

333

334

              input.txPowerA = input.txPowerB + powerGap;

335

              experiment.Run (input);

336

337

          break;

338

339

        case PAYLOAD_RECOVERY_TEST:

340

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

341

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

342

          // can still be recovery at the receiver.

343

344

          // Two packets collide at the payload portion of the packet

345

          // In this test, with and without frame capture capability will not generate differences.

346

347

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

348

          input.numSentPackets = 1000;

349

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

350

351

              input.txPowerA = input.txPowerB + powerGap;

352

              experiment.Run (input);

353

354

          break;

355

356

        case PREAMBLE_CAPTURE_TEST:

357

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

358

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

359

360

          // In this test, without frame capture capability, the reception of both packets fails.

361

          // However, with frame capture capability, packet B can be received with certain probability

362

          // Two packets collide at the preamble portion of the packet

363

364

          if (!input.enablePreambleCapture)

365

366

              std::cout << "Running PREAMBLE_CAPTURE_TEST. However, preamble capture is not enabled. "

367

                        << "Should expect no packets can be received successfully!"

368

                        << std::endl;

369

370

          else

371

372

              std::cout << "Running PREAMBLE_CAPTURE_TEST. The payload capture is enabled. "

373

                        << "Should expect packets from node B can be received successfully, "

374

                        << "once the tx power of B is large enough!"

375

                        << std::endl;

376

377

378

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

379

          input.numSentPackets = 1000;

380

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

381

382

              input.txPowerB = input.txPowerA + powerGap;

383

              experiment.Run (input);

384

385

          break;

386

387

        case PAYLOAD_CAPTURE_TEST:

388

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

389

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

390

391

          // In this test, without frame capture capability, the reception of both packets fails.

392

          // However, with frame capture capability, packet B can be received with certain probability

393

          // Two packets collide at the payload portion of the packet

394

395

          if (!input.enablePayloadCapture)

396

397

              std::cout << "Run PAYLOAD_CAPTURE_TEST. However, the payload capture is not enabled. "

398

                        << "Should expect no packets can be received successfully!"

399

                        << std::endl;

400

401

          else

402

403

              std::cout << "Run PAYLOAD_CAPTURE_TEST. The payload capture is enabled. "

404

                        << "Should expect packets from node B can be received successfully, "

405

                        << "once the tx power of B is large enough!"

406

                        << std::endl;

407

408

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

409

          input.numSentPackets = 1000;

410

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

411

412

              input.txPowerB = input.txPowerA + powerGap;

413

              experiment.Run (input);

414

415

          break;

416

417

418

  else

419

420

      InterferenceExperiment experiment;

421

      experiment.Run (input);

422

264

  return 0;

423

  return 0;

265

424

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

// This file contains two models for implementing the frame capture effect in the ns-3
// simulator, i.e., the preamble capture model and the payload capture model.

// The payload capture model was calibrated based on the results of a set of hardware tests
// conducted by the CAMP research team for IEEE 802.11p OFDM signals with 6 Mbps
// bandwidth on 10 MHz channel.
// The lab test results show a relationship between the probability of successfully
// capturing a strong signal and required SINR values.

// The preamble capture model was calibrated by shifting an theoretical error model (based the default
// ns-3 NIST model to decode a OFDM 6 Mbps signal with 40 us transmission duration).
// The obtained model was able to generate the best match between the simulation results and the
// the field test results.

// For more details of the model choices, please refer to paper:
// "Experience: accurate simulation of dense scenarios with hundreds of vehicular transmitters",
// in proceeding of the 22nd Annual International Conference on Mobile Computing
// and Networking (MobiCom '16).

#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 */

(-)a/src/wifi/model/interference-helper.cc (-11 / +54 lines)

Lines 94-102	Link Here

 *       short period of time.

 *       short period of time.

 ****************************************************************/

 ****************************************************************/

InterferenceHelper::NiChange::NiChange (Time time, double delta)

InterferenceHelper::NiChange::NiChange (Time time, double delta, Ptr<InterferenceHelper::Event> event)

  : m_time (time),

  : m_time (time),

    m_delta (delta)

    m_delta (delta),

100

    m_event (event)

100

101

102

103

Lines 112-117	Link Here

112

  return m_delta;

113

  return m_delta;

113

114

115

116

Ptr<InterferenceHelper::Event>

117

InterferenceHelper::NiChange::GetEvent (void) const

118

119

  return m_event;

120

121

115

bool

122

bool

116

InterferenceHelper::NiChange::operator < (const InterferenceHelper::NiChange& o) const

123

InterferenceHelper::NiChange::operator < (const InterferenceHelper::NiChange& o) const

117

124

Lines 221-233	Link Here

221

          m_firstPower += i->GetDelta ();

228

          m_firstPower += i->GetDelta ();

222

229

223

      m_niChanges.erase (m_niChanges.begin (), nowIterator);

230

      m_niChanges.erase (m_niChanges.begin (), nowIterator);

224

      m_niChanges.insert (m_niChanges.begin (), NiChange (event->GetStartTime (), event->GetRxPowerW ()));

231

      m_niChanges.insert (m_niChanges.begin (), NiChange (event->GetStartTime (), event->GetRxPowerW (), event));

225

232

226

  else

233

  else

227

234

228

      AddNiChangeEvent (NiChange (event->GetStartTime (), event->GetRxPowerW ()));

235

      AddNiChangeEvent (NiChange (event->GetStartTime (), event->GetRxPowerW (), event));

229

236

230

  AddNiChangeEvent (NiChange (event->GetEndTime (), -event->GetRxPowerW ()));

237

  AddNiChangeEvent (NiChange (event->GetEndTime (), -event->GetRxPowerW (), event));

231

238

232

239

233

240

Lines 251-267	Link Here

251

InterferenceHelper::CalculateNoiseInterferenceW (Ptr<InterferenceHelper::Event> event, NiChanges *ni) const

258

InterferenceHelper::CalculateNoiseInterferenceW (Ptr<InterferenceHelper::Event> event, NiChanges *ni) const

252

259

253

  double noiseInterference = m_firstPower;

260

  double noiseInterference = m_firstPower;

254

  NS_ASSERT (m_rxing);

261

  NiChanges::const_iterator eventIterator = m_niChanges.begin ();

255

  for (NiChanges::const_iterator i = m_niChanges.begin () + 1; i != m_niChanges.end (); i++)

262

  while (eventIterator != m_niChanges.end ())

256

263

257

      if ((event->GetEndTime () == i->GetTime ()) && event->GetRxPowerW () == -i->GetDelta ())

264

      // Iterate the NI change list from the beginning to the end

265

      // until find the position of the event in the NI change list

266

      // The reason of using the event that causes the NI change to identify

267

      // different NI changes is because in some special cases

268

      // different NI changes happen at the same time with the same delta

269

      // value. Therefore, it may be impossible to identify a NI change that belongs

270

      // to which event based on just the NI time and NI delta value

271

      if (eventIterator->GetEvent () != event)

272

273

          // The NI changes which happen before the event should be considered

274

          // as the interference. This considers the case that the receiving event

275

          // arrives while another receiving event is going on. The SINR of

276

          // the newly arrived event is calculated for checking the possibility of frame capture

277

          noiseInterference += eventIterator->GetDelta ();

278

279

      else

280

281

          break;

282

283

      ++eventIterator;

284

285

286

  for (NiChanges::const_iterator i = eventIterator + 1; i != m_niChanges.end (); ++i)

287

288

      if (event->GetEndTime () == i->GetTime () && event == i->GetEvent ())

258

289

259

          break;

290

          break;

260

291

261

      ni->push_back (*i);

292

      ni->push_back (*i);

262

293

263

  ni->insert (ni->begin (), NiChange (event->GetStartTime (), noiseInterference));

294

  ni->insert (ni->begin (), NiChange (event->GetStartTime (), noiseInterference, event));

264

  ni->push_back (NiChange (event->GetEndTime (), 0));

295

  ni->push_back (NiChange (event->GetEndTime (), 0, event));

265

  return noiseInterference;

296

  return noiseInterference;

266

297

267

298

Lines 842-848	Link Here

842

InterferenceHelper::NiChanges::iterator

873

InterferenceHelper::NiChanges::iterator

843

InterferenceHelper::GetPosition (Time moment)

874

InterferenceHelper::GetPosition (Time moment)

844

875

845

  return std::upper_bound (m_niChanges.begin (), m_niChanges.end (), NiChange (moment, 0));

876

  return std::upper_bound (m_niChanges.begin (), m_niChanges.end (), NiChange (moment, 0, NULL));

846

877

847

878

848

void

879

void

Lines 865-868	Link Here

865

  m_rxing = false;

896

  m_rxing = false;

866

897

867

898

899

double

900

InterferenceHelper::CalculatePreambleCaptureProbability (double sinr)

901

902

  return m_frameCaptureModel->CalculatePreambleCaptureProbability (sinr);

903

904

905

double

906

InterferenceHelper::CalculatePayloadCaptureProbability (double sinr)

907

908

  return m_frameCaptureModel->CalculatePayloadCaptureProbability (sinr);

909

910

868

} //namespace ns3

911

} //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);
  /**
   * 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:
  /**

     *
     * \param time time of the event
     * \param delta the power
     * \param event causes this NI change
     */
    NiChange (Time time, double delta, Ptr<InterferenceHelper::Event> event);
    /**
     * Return the event time.
     *

     */
    double GetDelta (void) const;
    /**
     * Return the event causes the corresponding NI change
     *
     * \return the event
     */
    Ptr<InterferenceHelper::Event> GetEvent (void) const;
    /**
     * Compare the event time of two NiChange objects (a < o).
     *
     * \param o

private:
    Time m_time;
    double m_delta;
    Ptr<InterferenceHelper::Event> m_event;
  };
  /**
   * typedef for a vector of NiChanges

  NiChanges m_niChanges;
  double m_firstPower;
  bool m_rxing;

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

  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