Attachment #2789 for bug #2368

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

(-)a/src/wifi/examples/test-interference-helper.cc (-5 / +18 lines)

Lines 71-82	Link Here

    double xB; ///< x B

    double xB; ///< x B

    std::string txModeA; ///< transmit mode A

    std::string txModeA; ///< transmit mode A

    std::string txModeB; ///< transmit mode B

    std::string txModeB; ///< transmit mode B

    uint32_t txPowerLevelA; ///< transmit power level A

    double txPowerLevelA; ///< transmit power level A

    uint32_t txPowerLevelB; ///< transmit power level B

    double txPowerLevelB; ///< transmit power level B

    uint32_t packetSizeA; ///< packet size A

    uint32_t packetSizeA; ///< packet size A

    uint32_t packetSizeB; ///< packet size B

    uint32_t packetSizeB; ///< packet size B

    WifiPhyStandard standard; ///< standard

    WifiPhyStandard standard; ///< standard

    WifiPreamble preamble; ///< preamble

    WifiPreamble preamble; ///< preamble

    bool captureEnabled; ///< whether physical layer capture is enabled

    double captureMargin; ///< margin used for physical layer capture

};

};

  InterferenceExperiment ();

  InterferenceExperiment ();

Lines 127-138	Link Here

127

    xB (5),

129

    xB (5),

128

    txModeA ("OfdmRate54Mbps"),

130

    txModeA ("OfdmRate54Mbps"),

129

    txModeB ("OfdmRate54Mbps"),

131

    txModeB ("OfdmRate54Mbps"),

130

    txPowerLevelA (0),

132

    txPowerLevelA (16.0206),

131

    txPowerLevelB (0),

133

    txPowerLevelB (16.0206),

132

    packetSizeA (1500),

134

    packetSizeA (1500),

133

    packetSizeB (1500),

135

    packetSizeB (1500),

134

    standard (WIFI_PHY_STANDARD_80211a),

136

    standard (WIFI_PHY_STANDARD_80211a),

135

    preamble (WIFI_PREAMBLE_LONG)

137

    preamble (WIFI_PREAMBLE_LONG),

138

    captureEnabled (false),

139

    captureMargin (0)

136

140

137

141

138

142

Lines 157-164	Link Here

157

  posRx->SetPosition (Vector (0.0, 0.0, 0.0));

161

  posRx->SetPosition (Vector (0.0, 0.0, 0.0));

158

162

159

  m_txA = CreateObject<YansWifiPhy> ();

163

  m_txA = CreateObject<YansWifiPhy> ();

164

  m_txA->SetTxPowerStart (input.txPowerLevelA);

165

  m_txA->SetTxPowerEnd (input.txPowerLevelA);

160

  m_txB = CreateObject<YansWifiPhy> ();

166

  m_txB = CreateObject<YansWifiPhy> ();

167

  m_txB->SetTxPowerStart (input.txPowerLevelB);

168

  m_txB->SetTxPowerEnd (input.txPowerLevelB);

161

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

169

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

170

  rx->SetPhysicalLayerCaptureEnabled (input.captureEnabled);

171

  rx->SetPhysicalLayerCaptureMargin (input.captureMargin);

162

172

163

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

173

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

164

  m_txA->SetErrorRateModel (error);

174

  m_txA->SetErrorRateModel (error);

Lines 202-209	Link Here

202

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

212

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

203

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

213

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

204

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

214

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

215

  cmd.AddValue ("enableCapture", "Enable/disable physical layer capture", input.captureEnabled);

216

  cmd.AddValue ("captureMargin", "Margin used for physical layer capture", input.captureMargin);

205

  cmd.Parse (argc, argv);

217

  cmd.Parse (argc, argv);

206

218

219

  LogComponentEnable ("WifiPhy", LOG_LEVEL_ALL);

207

  LogComponentEnable ("YansWifiPhy", LOG_LEVEL_ALL);

220

  LogComponentEnable ("YansWifiPhy", LOG_LEVEL_ALL);

208

  LogComponentEnable ("InterferenceHelper", LOG_LEVEL_ALL);

221

  LogComponentEnable ("InterferenceHelper", LOG_LEVEL_ALL);

209

222

(-)a/src/wifi/model/interference-helper.cc (-11 / +42 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 846-852	Link Here

846

InterferenceHelper::NiChanges::iterator

877

InterferenceHelper::NiChanges::iterator

847

InterferenceHelper::GetPosition (Time moment)

878

InterferenceHelper::GetPosition (Time moment)

848

879

849

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

880

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

850

881

851

882

852

void

883

void

(-)a/src/wifi/model/interference-helper.h (-1 / +10 lines)

Lines 220-227	Link Here

220

221

     * \param time time of the event

221

     * \param time time of the event

222

     * \param delta the power

222

     * \param delta the power

223

     * \param event causes this NI change

223

*/

224

*/

224

    NiChange (Time time, double delta);

225

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

225

/**

226

/**

226

     * Return the event time.

227

     * Return the event time.

227

228

Lines 235-240	Link Here

235

*/

236

*/

236

    double GetDelta (void) const;

237

    double GetDelta (void) const;

237

/**

238

/**

239

     * Return the event causes the corresponding NI change

240

241

     * \return the event

242

*/

243

    Ptr<InterferenceHelper::Event> GetEvent (void) const;

244

/**

238

     * Compare the event time of two NiChange objects (a < o).

245

     * Compare the event time of two NiChange objects (a < o).

239

246

240

     * \param o

247

     * \param o

Lines 246-251	Link Here

246

private:

253

private:

247

    Time m_time; ///< time

254

    Time m_time; ///< time

248

    double m_delta; ///< delta

255

    double m_delta; ///< delta

256

    Ptr<InterferenceHelper::Event> m_event;

249

};

257

};

250

/**

258

/**

251

   * typedef for a vector of NiChanges

259

   * typedef for a vector of NiChanges

Lines 322-327	Link Here

322

  NiChanges m_niChanges;

330

  NiChanges m_niChanges;

323

  double m_firstPower; ///< first power

331

  double m_firstPower; ///< first power

324

  bool m_rxing; ///< flag whether it is in receiving state

332

  bool m_rxing; ///< flag whether it is in receiving state

333

325

  /// Returns an iterator to the first nichange, which is later than moment

334

  /// Returns an iterator to the first nichange, which is later than moment

326

  NiChanges::iterator GetPosition (Time moment);

335

  NiChanges::iterator GetPosition (Time moment);

327

/**

336

/**




void
WifiPhyStateHelper::NotifyTxStart (Time duration, double txPowerDbm)
{
  NS_LOG_FUNCTION (this);
  for (Listeners::const_iterator i = m_listeners.begin (); i != m_listeners.end (); i++)
    {
      (*i)->NotifyTxStart (duration, txPowerDbm);

void
WifiPhyStateHelper::NotifyRxStart (Time duration)
{
  NS_LOG_FUNCTION (this);
  for (Listeners::const_iterator i = m_listeners.begin (); i != m_listeners.end (); i++)
    {
      (*i)->NotifyRxStart (duration);

void
WifiPhyStateHelper::NotifyRxEndOk (void)
{
  NS_LOG_FUNCTION (this);
  for (Listeners::const_iterator i = m_listeners.begin (); i != m_listeners.end (); i++)
    {
      (*i)->NotifyRxEndOk ();

void
WifiPhyStateHelper::NotifyRxEndError (void)
{
  NS_LOG_FUNCTION (this);
  for (Listeners::const_iterator i = m_listeners.begin (); i != m_listeners.end (); i++)
    {
      (*i)->NotifyRxEndError ();

void
WifiPhyStateHelper::NotifyMaybeCcaBusyStart (Time duration)
{
  NS_LOG_FUNCTION (this);
  for (Listeners::const_iterator i = m_listeners.begin (); i != m_listeners.end (); i++)
    {
      (*i)->NotifyMaybeCcaBusyStart (duration);

void
WifiPhyStateHelper::NotifySwitchingStart (Time duration)
{
  NS_LOG_FUNCTION (this);
  for (Listeners::const_iterator i = m_listeners.begin (); i != m_listeners.end (); i++)
    {
      (*i)->NotifySwitchingStart (duration);

void
WifiPhyStateHelper::NotifySleep (void)
{
  NS_LOG_FUNCTION (this);
  for (Listeners::const_iterator i = m_listeners.begin (); i != m_listeners.end (); i++)
    {
      (*i)->NotifySleep ();

void
WifiPhyStateHelper::NotifyWakeup (void)
{
  NS_LOG_FUNCTION (this);
  for (Listeners::const_iterator i = m_listeners.begin (); i != m_listeners.end (); i++)
    {
      (*i)->NotifyWakeup ();

void
WifiPhyStateHelper::LogPreviousIdleAndCcaBusyStates (void)
{
  NS_LOG_FUNCTION (this);
  Time now = Simulator::Now ();
  Time idleStart = Max (m_endCcaBusy, m_endRx);
  idleStart = Max (idleStart, m_endTx);

WifiPhyStateHelper::SwitchToTx (Time txDuration, Ptr<const Packet> packet, double txPowerDbm,
                                WifiTxVector txVector)
{
  NS_LOG_FUNCTION (this << txDuration << packet << txPowerDbm << txVector);
  m_txTrace (packet, txVector.GetMode (), txVector.GetPreambleType (), txVector.GetTxPowerLevel ());
  Time now = Simulator::Now ();
  switch (GetState ())

void
WifiPhyStateHelper::SwitchToRx (Time rxDuration)
{
  NS_LOG_FUNCTION (this << rxDuration);
  NS_ASSERT (IsStateIdle () || IsStateCcaBusy ());
  NS_ASSERT (!m_rxing);
  Time now = Simulator::Now ();

void
WifiPhyStateHelper::SwitchToChannelSwitching (Time switchingDuration)
{
  NS_LOG_FUNCTION (this << switchingDuration);
  Time now = Simulator::Now ();
  switch (GetState ())
    {

void
WifiPhyStateHelper::SwitchFromRxEndOk (Ptr<Packet> packet, double snr, WifiTxVector txVector)
{
  NS_LOG_FUNCTION (this << packet << snr << txVector);
  m_rxOkTrace (packet, snr, txVector.GetMode (), txVector.GetPreambleType ());
  NotifyRxEndOk ();
  DoSwitchFromRx ();

void
WifiPhyStateHelper::SwitchFromRxEndError (Ptr<Packet> packet, double snr)
{
  NS_LOG_FUNCTION (this << packet << snr);
  m_rxErrorTrace (packet, snr);
  NotifyRxEndError ();
  DoSwitchFromRx ();

void
WifiPhyStateHelper::DoSwitchFromRx (void)
{
  NS_LOG_FUNCTION (this);
  NS_ASSERT (IsStateRx ());
  NS_ASSERT (m_rxing);


void
WifiPhyStateHelper::SwitchMaybeToCcaBusy (Time duration)
{
  NS_LOG_FUNCTION (this << duration);
  NotifyMaybeCcaBusyStart (duration);
  Time now = Simulator::Now ();
  switch (GetState ())

void
WifiPhyStateHelper::SwitchToSleep (void)
{
  NS_LOG_FUNCTION (this);
  Time now = Simulator::Now ();
  switch (GetState ())
    {

void
WifiPhyStateHelper::SwitchFromSleep (Time duration)
{
  NS_LOG_FUNCTION (this << duration);
  NS_ASSERT (IsStateSleep ());
  Time now = Simulator::Now ();
  m_stateLogger (m_startSleep, now - m_startSleep, WifiPhy::SLEEP);

    }
}

void
WifiPhyStateHelper::SwitchFromRxAbort (void)
{
  NS_LOG_FUNCTION (this);
  NS_ASSERT (IsStateRx ());
  NS_ASSERT (m_rxing);
  m_endRx = Simulator::Now ();
  DoSwitchFromRx ();
  NS_ASSERT (!IsStateRx ());
}

} //namespace ns3

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

Lines 185-190	Link Here

185

   * \param duration the duration of CCA busy state

185

   * \param duration the duration of CCA busy state

186

*/

186

*/

187

  void SwitchFromSleep (Time duration);

187

  void SwitchFromSleep (Time duration);

188

/**

189

   * Abort current reception

190

*/

191

  void SwitchFromRxAbort (void);

188

192

189

/**

193

/**

190

   * TracedCallback signature for state changes.

194

   * TracedCallback signature for state changes.




                   MakeBooleanAccessor (&WifiPhy::GetShortPlcpPreambleSupported,
                                        &WifiPhy::SetShortPlcpPreambleSupported),
                   MakeBooleanChecker ())
    .AddAttribute ("PhysicalLayerCaptureEnabled",
                   "Whether or not physical layer capture mode is enabled.",
                   BooleanValue (false),
                   MakeBooleanAccessor (&WifiPhy::GetPhysicalLayerCaptureEnabled,
                                        &WifiPhy::SetPhysicalLayerCaptureEnabled),
                   MakeBooleanChecker ())
    .AddAttribute ("PhysicalLayerCaptureMargin",
                   "If physical layer capture mode is enabled, reception is switched "
                   "if the newly arrived frame has a power higher than this value "
                   "above the frame currently being received (expressed in dB).",
                   DoubleValue (10),
                   MakeDoubleAccessor (&WifiPhy::GetPhysicalLayerCaptureMargin,
                                       &WifiPhy::SetPhysicalLayerCaptureMargin),
                   MakeDoubleChecker<double> ())
    .AddTraceSource ("PhyTxBegin",
                     "Trace source indicating a packet "
                     "has begun transmitting over the channel medium",

    m_channelNumber (0),
    m_initialChannelNumber (0),
    m_totalAmpduSize (0),
    m_totalAmpduNumSymbols (0),
    m_currentEvent (0)
{
  NS_LOG_FUNCTION (this);
  NS_UNUSED (m_numberOfTransmitters);

}

void
WifiPhy::SetPhysicalLayerCaptureEnabled (bool enable)
{
  NS_LOG_FUNCTION (this << enable);
  m_physicalLayerCaptureEnabled = enable;
}

bool
WifiPhy::GetPhysicalLayerCaptureEnabled (void) const
{
  return m_physicalLayerCaptureEnabled;
}

void
WifiPhy::SetPhysicalLayerCaptureMargin (double margin)
{
  NS_LOG_FUNCTION (this << margin);
  m_physicalLayerCaptureMargin = margin;
}

double
WifiPhy::GetPhysicalLayerCaptureMargin (void) const
{
  return m_physicalLayerCaptureMargin;
}

void
WifiPhy::SetLdpc (bool ldpc)
{
  NS_LOG_FUNCTION (this << ldpc);

  //This function should be later split to check separately whether plcp preamble and plcp header can be successfully received.
  //Note: plcp preamble reception is not yet modeled.
  NS_LOG_FUNCTION (this << packet << WToDbm (rxPowerW) << rxDuration);
  AmpduTag ampduTag;
  Time endRx = Simulator::Now () + rxDuration;

  WifiPhyTag tag;

      NS_FATAL_ERROR ("Reception ends in failure because of an unsupported number of spatial streams");
    }

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

  Ptr<InterferenceHelper::Event> event;
  event = m_interference.Add (packet->GetSize (),
                              txVector,
                              rxDuration,
                              rxPowerW);

  MpduType mpdutype = tag.GetMpduType ();
  switch (m_state->GetState ())
    {
    case WifiPhy::SWITCHING:

        {
          //that packet will be noise _after_ the completion of the
          //channel switching.
          MaybeCcaBusyDuration ();
          return;
        }
      break;
    case WifiPhy::RX:
      NS_ASSERT (m_currentEvent != 0);
      if (m_physicalLayerCaptureEnabled
          && txVector.GetPreambleType () != WIFI_PREAMBLE_NONE
          && WToDbm (m_currentEvent->GetRxPowerW ()) + m_physicalLayerCaptureMargin < WToDbm (rxPowerW)
          && m_currentEvent->GetStartTime () + GetPlcpPreambleDuration (m_currentEvent->GetTxVector ()) < Simulator::Now ())
        {
          AbortCurrentReception ();
          NS_LOG_DEBUG ("Switch to new packet");
          StartRx (packet, txVector, mpdutype, rxPowerW, rxDuration, event);
        }
      else
        {
          NS_LOG_DEBUG ("drop packet because already in Rx (power=" <<
                        rxPowerW << "W)");
          NotifyRxDrop (packet);
          if (endRx > Simulator::Now () + m_state->GetDelayUntilIdle ())
            {
              //that packet will be noise _after_ the reception of the
              //currently-received packet.
              MaybeCcaBusyDuration ();
              return;
            }
        }
      break;
    case WifiPhy::TX:

        {
          //that packet will be noise _after_ the transmission of the
          //currently-transmitted packet.
          MaybeCcaBusyDuration ();
          return;
        }
      break;
    case WifiPhy::CCA_BUSY:
    case WifiPhy::IDLE:
      StartRx (packet, txVector, mpdutype, rxPowerW, rxDuration, event);
        {
          if (preamble == WIFI_PREAMBLE_NONE && (m_mpdusNum == 0 || m_plcpSuccess == false))
            {
              m_plcpSuccess = false;
              m_mpdusNum = 0;
              NS_LOG_DEBUG ("drop packet because no PLCP preamble/header has been received");
              NotifyRxDrop (packet);
              goto maybeCcaBusy;
            }
          else if (preamble != WIFI_PREAMBLE_NONE && packet->PeekPacketTag (ampduTag) && m_mpdusNum == 0)
            {
              //received the first MPDU in an MPDU
              m_mpdusNum = ampduTag.GetRemainingNbOfMpdus ();
              m_rxMpduReferenceNumber++;
            }
          else if (preamble == WIFI_PREAMBLE_NONE && packet->PeekPacketTag (ampduTag) && m_mpdusNum > 0)
            {
              //received the other MPDUs that are part of the A-MPDU
              if (ampduTag.GetRemainingNbOfMpdus () < (m_mpdusNum - 1))
                {
                  NS_LOG_DEBUG ("Missing MPDU from the A-MPDU " << m_mpdusNum - ampduTag.GetRemainingNbOfMpdus ());
                  m_mpdusNum = ampduTag.GetRemainingNbOfMpdus ();
                }
              else
                {
                  m_mpdusNum--;
                }
            }
          else if (preamble != WIFI_PREAMBLE_NONE && packet->PeekPacketTag (ampduTag) && m_mpdusNum > 0)
            {
              NS_LOG_DEBUG ("New A-MPDU started while " << m_mpdusNum << " MPDUs from previous are lost");
              m_mpdusNum = ampduTag.GetRemainingNbOfMpdus ();
            }
          else if (preamble != WIFI_PREAMBLE_NONE && m_mpdusNum > 0 )
            {
              NS_LOG_DEBUG ("Didn't receive the last MPDUs from an A-MPDU " << m_mpdusNum);
              m_mpdusNum = 0;
            }

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

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

          NS_ASSERT (m_endRxEvent.IsExpired ());
          m_endRxEvent = Simulator::Schedule (rxDuration, &WifiPhy::EndReceive, this,
                                              packet, preamble, mpdutype, event);
        }
      else
        {
          NS_LOG_DEBUG ("drop packet because signal power too Small (" <<
                        rxPowerW << "<" << GetEdThresholdW () << ")");
          NotifyRxDrop (packet);
          m_plcpSuccess = false;
          goto maybeCcaBusy;
        }
      break;
    case WifiPhy::SLEEP:
      NS_LOG_DEBUG ("drop packet because in sleep mode");

      m_plcpSuccess = false;
      break;
    }
}

void
WifiPhy::MaybeCcaBusyDuration ()
{
  //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

  InterferenceHelper::SnrPer snrPer;
  snrPer = m_interference.CalculatePlcpPayloadSnrPer (event);
  m_interference.NotifyRxEnd ();
  m_currentEvent = 0;

  if (m_plcpSuccess == true)
    {

    }
}

void
WifiPhy::AbortCurrentReception ()
{
  NS_LOG_FUNCTION (this);
  if (m_endPlcpRxEvent.IsRunning ())
    {
      m_endPlcpRxEvent.Cancel ();
    }
  if (m_endRxEvent.IsRunning ())
    {
      m_endRxEvent.Cancel ();
    }
  m_interference.NotifyRxEnd ();
  m_state->SwitchFromRxAbort ();
  m_currentEvent = 0;
}

void
WifiPhy::StartRx (Ptr<Packet> packet, WifiTxVector txVector, MpduType mpdutype, double rxPowerW, Time rxDuration, Ptr<InterferenceHelper::Event> event)
{
  NS_LOG_FUNCTION (this << packet << txVector << (uint16_t)mpdutype << rxPowerW << rxDuration);
  if (rxPowerW > GetEdThresholdW ()) //checked here, no need to check in the payload reception (current implementation assumes constant rx power over the packet duration)
    {
      AmpduTag ampduTag;
      WifiPreamble preamble = txVector.GetPreambleType ();
      if (preamble == WIFI_PREAMBLE_NONE && (m_mpdusNum == 0 || m_plcpSuccess == false))
        {
          m_plcpSuccess = false;
          m_mpdusNum = 0;
          NS_LOG_DEBUG ("drop packet because no PLCP preamble/header has been received");
          NotifyRxDrop (packet);
          MaybeCcaBusyDuration ();
          return;
        }
      else if (preamble != WIFI_PREAMBLE_NONE && packet->PeekPacketTag (ampduTag) && m_mpdusNum == 0)
        {
          //received the first MPDU in an MPDU
          m_mpdusNum = ampduTag.GetRemainingNbOfMpdus ();
          m_rxMpduReferenceNumber++;
        }
      else if (preamble == WIFI_PREAMBLE_NONE && packet->PeekPacketTag (ampduTag) && m_mpdusNum > 0)
        {
          //received the other MPDUs that are part of the A-MPDU
          if (ampduTag.GetRemainingNbOfMpdus () < (m_mpdusNum - 1))
            {
              NS_LOG_DEBUG ("Missing MPDU from the A-MPDU " << m_mpdusNum - ampduTag.GetRemainingNbOfMpdus ());
              m_mpdusNum = ampduTag.GetRemainingNbOfMpdus ();
            }
          else
            {
              m_mpdusNum--;
            }
        }
      else if (preamble != WIFI_PREAMBLE_NONE && packet->PeekPacketTag (ampduTag) && m_mpdusNum > 0)
        {
          NS_LOG_DEBUG ("New A-MPDU started while " << m_mpdusNum << " MPDUs from previous are lost");
          m_mpdusNum = ampduTag.GetRemainingNbOfMpdus ();
        }
      else if (preamble != WIFI_PREAMBLE_NONE && m_mpdusNum > 0 )
        {
          NS_LOG_DEBUG ("Didn't receive the last MPDUs from an A-MPDU " << m_mpdusNum);
          m_mpdusNum = 0;
        }

      NS_LOG_DEBUG ("sync to signal (power=" << rxPowerW << "W)");
      m_currentEvent = event;
      m_state->SwitchToRx (rxDuration);
      NS_ASSERT (m_endPlcpRxEvent.IsExpired ());
      NotifyRxBegin (packet);
      m_interference.NotifyRxStart ();
    
      if (preamble != WIFI_PREAMBLE_NONE)
        {
          NS_ASSERT (m_endPlcpRxEvent.IsExpired ());
          Time preambleAndHeaderDuration = CalculatePlcpPreambleAndHeaderDuration (txVector);
          m_endPlcpRxEvent = Simulator::Schedule (preambleAndHeaderDuration, &WifiPhy::StartReceivePacket, this,
                                                  packet, txVector, mpdutype, event);
        }

      NS_ASSERT (m_endRxEvent.IsExpired ());
      m_endRxEvent = Simulator::Schedule (rxDuration, &WifiPhy::EndReceive, this,
                                          packet, preamble, mpdutype, event);
    }
  else
    {
      NS_LOG_DEBUG ("drop packet because signal power too Small (" <<
                    rxPowerW << "<" << GetEdThresholdW () << ")");
      NotifyRxDrop (packet);
      m_plcpSuccess = false;
      MaybeCcaBusyDuration ();
    }
}

int64_t
WifiPhy::AssignStreams (int64_t stream)
{




   * \return the reception gain in dB
   */
  double GetRxGain (void) const;

  /**
   * Sets whether physical layer capture is enabled.
   *
   * \param enable enable or disable physical layer capture
   */
  void SetPhysicalLayerCaptureEnabled (bool enable);
  /**
   * Return whether physical layer capture is enabled.
   *
   * \return true if physical layer capture is enabled,
   *         false otherwise
   */
  bool GetPhysicalLayerCaptureEnabled (void) const;
  /**
   * Sets the physical layer capture margin (dB).
   *
   * \param margin the physical layer capture margin in dB
   */
  void SetPhysicalLayerCaptureMargin (double margin);
  /**
   * Return the physical layer capture margin (dB).
   *
   * \return the physical layer capture margin in dB
   */
  double GetPhysicalLayerCaptureMargin (void) const;

  /**
   * Sets the device this PHY is associated with.
   *

   * \return the FrequencyWidthPair found
   */
  FrequencyWidthPair GetFrequencyWidthForChannelNumberStandard (uint8_t channelNumber, WifiPhyStandard standard) const;
  
  /**
   * Due to newly arrived signal, the current reception cannot be continued and has to be aborted
   *
   */
  void AbortCurrentReception (void);

  /**
   * Eventually switch to CCA busy
   */
  void MaybeCcaBusyDuration (void);
  
  /**
   * Starting receiving the packet after having detected the medium is idle or after a reception switch.
   *
   * \param packet the arriving packet
   * \param txVector the TXVECTOR of the arriving packet
   * \param mpdutype the type of the MPDU as defined in WifiPhy::MpduType.
   * \param rxPowerW the receive power in W
   * \param rxDuration the duration needed for the reception of the packet
   * \param event the corresponding event of the first time the packet arrives
   */
  void StartRx (Ptr<Packet> packet,
                WifiTxVector txVector,
                MpduType mpdutype,
                double rxPowerW,
                Time rxDuration,
                Ptr<InterferenceHelper::Event> event);

  /**
   * The trace source fired when a packet begins the transmission process on


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

  Ptr<InterferenceHelper::Event> m_currentEvent; //!< Hold the current event
  bool m_physicalLayerCaptureEnabled; //!< Flag whether Physical Layer Capture mode is enabled
  double m_physicalLayerCaptureMargin; //! Margin used for Physical Layer Capture mode
};

/**

Return to bug 2368