Attachment #2732 for bug #2368

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

(-)a/src/wifi/examples/test-interference-helper.cc (-8 / +29 lines)

Lines 53-59	Link Here

#include "ns3/yans-wifi-channel.h"

#include "ns3/yans-wifi-channel.h"

#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/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 public:	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;

};

};

  InterferenceExperiment ();

  InterferenceExperiment ();

Lines 96-101 InterferenceExperiment::SendA (void) const	Link Here

  txVector.SetTxPowerLevel (m_input.txPowerLevelA);

  txVector.SetTxPowerLevel (m_input.txPowerLevelA);

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

100

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

  txVector.SetPreambleType (m_input.preamble);

101

  txVector.SetPreambleType (m_input.preamble);

102

  m_txA->SetTxPowerStart (m_input.txPowerA);

103

  m_txA->SetTxPowerEnd (m_input.txPowerA);

  m_txA->SendPacket (p, txVector);

104

  m_txA->SendPacket (p, txVector);

100

105

101

106

Lines 107-112 InterferenceExperiment::SendB (void) const	Link Here

107

  txVector.SetTxPowerLevel (m_input.txPowerLevelB);

112

  txVector.SetTxPowerLevel (m_input.txPowerLevelB);

108

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

113

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

109

  txVector.SetPreambleType (m_input.preamble);

114

  txVector.SetPreambleType (m_input.preamble);

115

  m_txB->SetTxPowerStart (m_input.txPowerB);

116

  m_txB->SetTxPowerEnd (m_input.txPowerB);

110

  m_txB->SendPacket (p, txVector);

117

  m_txB->SendPacket (p, txVector);

111

118

112

119

Lines 117-130 InterferenceExperiment::Input::Input ()	Link Here

117

  : interval (MicroSeconds (0)),

124

  : interval (MicroSeconds (0)),

118

    xA (-5),

125

    xA (-5),

119

    xB (5),

126

    xB (5),

120

    txModeA ("OfdmRate54Mbps"),

127

    txModeA ("OfdmRate12Mbps"),

121

    txModeB ("OfdmRate54Mbps"),

128

    txModeB ("OfdmRate12Mbps"),

122

    txPowerLevelA (0),

129

    txPowerLevelA (0),

123

    txPowerLevelB (0),

130

    txPowerLevelB (0),

131

    txPowerA (20),

132

    txPowerB (20),

124

    packetSizeA (1500),

133

    packetSizeA (1500),

125

    packetSizeB (1500),

134

    packetSizeB (1500),

126

    standard (WIFI_PHY_STANDARD_80211a),

135

    standard (WIFI_PHY_STANDARD_80211a),

127

    preamble (WIFI_PREAMBLE_LONG)

136

    preamble (WIFI_PREAMBLE_LONG),

137

    enableFrameCapture (false)

128

138

129

139

130

140

Lines 152-158 InterferenceExperiment::Run (struct InterferenceExperiment::Input input)	Link Here

152

  m_txB = CreateObject<YansWifiPhy> ();

162

  m_txB = CreateObject<YansWifiPhy> ();

153

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

163

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

154

164

155

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

165

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

156

  m_txA->SetErrorRateModel (error);

166

  m_txA->SetErrorRateModel (error);

157

  m_txB->SetErrorRateModel (error);

167

  m_txB->SetErrorRateModel (error);

158

  rx->SetErrorRateModel (error);

168

  rx->SetErrorRateModel (error);

Lines 167-172 InterferenceExperiment::Run (struct InterferenceExperiment::Input input)	Link Here

167

  m_txB->ConfigureStandard (input.standard);

177

  m_txB->ConfigureStandard (input.standard);

168

  rx->ConfigureStandard (input.standard);

178

  rx->ConfigureStandard (input.standard);

169

179

180

  m_txA->SetPreambleCapture(input.enableFrameCapture);

181

  m_txB->SetPreambleCapture(input.enableFrameCapture);

182

  rx->SetPreambleCapture(input.enableFrameCapture);

183

  m_txA->SetPayloadCapture(input.enableFrameCapture);

184

  m_txB->SetPayloadCapture(input.enableFrameCapture);

185

  rx->SetPayloadCapture(input.enableFrameCapture);

186

187

170

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

188

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

171

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

189

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

172

190

Lines 188-202 int main (int argc, char *argv[])	Link Here

188

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

206

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

189

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

207

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

208

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

191

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

209

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

192

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

210

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

211

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

212

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

213

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

214

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

195

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

215

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

196

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

216

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

217

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

197

  cmd.Parse (argc, argv);

218

  cmd.Parse (argc, argv);

198

219

199

  LogComponentEnable ("YansWifiPhy", LOG_LEVEL_ALL);

220

  LogComponentEnable ("WifiPhy", LOG_LEVEL_ALL);

200

  LogComponentEnable ("InterferenceHelper", LOG_LEVEL_ALL);

221

  LogComponentEnable ("InterferenceHelper", LOG_LEVEL_ALL);

201

222

202

  input.interval = MicroSeconds (delay);

223

  input.interval = MicroSeconds (delay);

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

Lines 11-17 def build(bld):	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'




/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
#include "frame-capture-model.h"
#include <algorithm>
#include <cmath>

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 = 10 * std::log10(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; -*- */

#ifndef FRAME_CAPTURE_MODEL_H
#define FRAME_CAPTURE_MODEL_H

#include "ns3/object.h"

namespace ns3 {

class FrameCaptureModel : public Object
{
public:
  static TypeId GetTypeId (void);
  FrameCaptureModel ();
  double CalculatePreambleCaptureProbability (double sinr);
  double CalculatePayloadCaptureProbability (double sinr);
private:
  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->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

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

Lines 24-29	Link Here

#include "ns3/nstime.h"

#include "ns3/nstime.h"

#include "wifi-tx-vector.h"

#include "wifi-tx-vector.h"

#include "error-rate-model.h"

#include "error-rate-model.h"

#include "frame-capture-model.h"

namespace ns3 {

namespace ns3 {

Lines 206-212 private:	Link Here

206

   * Erase all events.

207

   * Erase all events.

207

*/

208

*/

208

  void EraseEvents (void);

209

  void EraseEvents (void);

209

210

  // following methods used to support frame capture capability

211

/**

212

   * Calculate the successful probability for preamble capture

213

   * \param sinr the sinr value at the current time

214

*/

215

  double CalculatePreambleCaptureProbability (double sinr);

216

/**

217

   * Calculate the successful probability for payload capture

218

   * \param sinr the sinr value at the current time

219

*/

220

  double CalculatePayloadCaptureProbability (double sinr);

210

221

211

private:

222

private:

212

/**

223

/**

Lines 322-327 private:	Link Here

322

  NiChanges m_niChanges;

333

  NiChanges m_niChanges;

323

  double m_firstPower;

334

  double m_firstPower;

324

  bool m_rxing;

335

  bool m_rxing;

336

  // following variables used for frame capture capability

337

  Ptr<FrameCaptureModel> m_frameCaptureModel;

338

325

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

339

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

326

  NiChanges::iterator GetPosition (Time moment);

340

  NiChanges::iterator GetPosition (Time moment);

327

/**

341

/**




    }
}

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 public:	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




#include "ns3/pointer.h"
#include "wifi-phy-tag.h"
#include "ampdu-tag.h"
#include "wifi-phy-tag.h"
#include "wifi-utils.h"

namespace ns3 {

                   MakeDoubleChecker<double> ())
    .AddAttribute ("TxGain",
                   "Transmission gain (dB).",
                   DoubleValue (0.0),
                   MakeDoubleAccessor (&WifiPhy::SetTxGain,
                                       &WifiPhy::GetTxGain),
                   MakeDoubleChecker<double> ())
    .AddAttribute ("RxGain",
                   "Reception gain (dB).",
                   DoubleValue (0.0),
                   MakeDoubleAccessor (&WifiPhy::SetRxGain,
                                       &WifiPhy::GetRxGain),
                   MakeDoubleChecker<double> ())

                   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::GetPreambleCapture,
					&WifiPhy::SetPreambleCapture),
		   MakeBooleanChecker ())
    .AddAttribute ("PayloadCaptureEnabled",
		   "Whether or not to enable cautpure at the payload(data) portion of the packet",
		   BooleanValue (false),
		   MakeBooleanAccessor (&WifiPhy::GetPayloadCapture,
					&WifiPhy::SetPayloadCapture),
		   MakeBooleanChecker ())
    .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_doPreambleCapture (false),
    m_doPayloadCapture (false)
{
  NS_LOG_FUNCTION (this);
  NS_UNUSED (m_numberOfTransmitters);

  return m_channelSwitchDelay;
}

void
WifiPhy::SetPreambleCapture (bool enable)
{
  NS_LOG_FUNCTION (this << enable);
  m_doPreambleCapture = enable;
}

bool
WifiPhy::GetPreambleCapture (void) const
{
  return m_doPreambleCapture;
}

void
WifiPhy::SetPayloadCapture (bool enable)
{
  NS_LOG_FUNCTION (this << enable);
  m_doPayloadCapture = enable;
}

bool
WifiPhy::GetPayloadCapture (void) const
{
  return m_doPayloadCapture;
}

double
WifiPhy::CalculateSnr (WifiTxVector txVector, double ber) const
{

                              txVector,
                              rxDuration,
                              rxPowerW);
  Time currentRxStage = Seconds (0);

  switch (m_state->GetState ())
    {

        {
          //that packet will be noise _after_ the completion of the
          //channel switching.
	  CalculateCcaBusyDuration ();
        }
      break;
    case WifiPhy::RX:
      {
	NS_ASSERT (m_rxPacketEvent != NULL);
	if (preamble == WIFI_PREAMBLE_NONE)
	  {
	    NS_LOG_DEBUG ("New packet does not contains preamble/plcp header");
            NotifyRxDrop (packet);
            if (endRx > Simulator::Now () + m_state->GetDelayUntilIdle ())
              {
                CalculateCcaBusyDuration ();
              }
            break;
	  }

	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
	  {
	    NS_LOG_DEBUG ("old preamble type "<<m_rxPreambleType
			 <<", new preamble type "<<preamble
			 <<", rxStage "<<currentRxStage);
	    doReceptionSwitch = CheckPreambleCapture (packet, event);
	  }
	else
	  {
	    doReceptionSwitch = CheckPayloadCapture (packet, event);
	  }
	if (doReceptionSwitch)
	  {
	    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)
            {


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

                        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

    }
}

bool
WifiPhy::CheckPreambleCapture (Ptr<Packet> packet, Ptr<InterferenceHelper::Event> 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);
      if (m_doPreambleCapture) // if the frame capture capability at preamble is enabled, check whether can
			       // switch to the new packet
	{
	  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 ();
		}
	    }
	}
      else // if the frame capture is not enabled, drop the packet
	{
	  NS_LOG_INFO (Simulator::Now()<<" preamble capture check: drop packet because already receiving");
	  NotifyRxDrop (packet);
	  if (endRx > Simulator::Now() + m_state->GetDelayUntilIdle())
	    {
	      CalculateCcaBusyDuration ();
	    }
	}
    }
  return result;
}

bool
WifiPhy::CheckPayloadCapture (Ptr<Packet> packet, Ptr<InterferenceHelper::Event> 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);
      if (m_doPayloadCapture) // if the frame capture capability at preamble is enabled, check whether can
			       // switch to the new packet
	{
	  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 ();
		}
	    }
	}
      else // if the frame capture is not enabled, drop the packet
	{
	  NS_LOG_INFO (Simulator::Now()<<" payload capture check: drop packet because already receiving");
	  NotifyRxDrop (packet);
	  if (endRx > Simulator::Now() + m_state->GetDelayUntilIdle())
	    {
	      CalculateCcaBusyDuration ();
	    }
	}
    }
  return result;
}

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

void
WifiPhy::SwitchReception (Ptr<Packet> packet, Ptr<InterferenceHelper::Event> 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 ("drop packet because it was sent using an unsupported mode (" << txMode << ")");
          NotifyRxDrop (packet);
          m_plcpSuccess = false;
          AbortCurrentReception (packet, snrPer.snr);
          CalculateCcaBusyDuration ();
        }
    }
  else //plcp reception failed

      NS_LOG_DEBUG ("drop packet because plcp preamble/header reception failed");
      NotifyRxDrop (packet);
      m_plcpSuccess = false;
      AbortCurrentReception (packet, snrPer.snr);
      CalculateCcaBusyDuration ();
    }
}





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

// following method is used to support frame capture capability

  /**
   * \param enable boolean value to indicate whether preamble capture is enabled or not
   */
  void SetPreambleCapture (bool enable);
  /**
   * \return boolean value to indicate whether preamble capture is enable or not
   */
  bool GetPreambleCapture (void) const;
  /**
   * \param enable boolean value to indicate whether payload capture is enabled or not
   */
  void SetPayloadCapture (bool enable);
  /**
   * \return boolean value to indicate whether payload capture is enable or not
   */
  bool GetPayloadCapture (void) const;


protected:
  // Inherited

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

  // following methods used to support frame capture capability
  /**
   * Due to newly arrived signal, the old reception cannot be continued and has to be abort
   */
  void AbortCurrentReception (Ptr<Packet> packet, double snr);
  /**
   * 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
   * \param txVector
   * \param mpdutype
   */
  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
   * \param tag
   */
  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
   */
  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 81-86 def build(bld):	Link Here

        'model/ht-operations.cc',

        'model/ht-operations.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 186-191 def build(bld):	Link Here

186

        'model/ht-operations.h',

187

        'model/ht-operations.h',

187

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

188

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

188

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

189

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

190

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

189

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

191

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

190

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

192

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

191

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

193

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

Return to bug 2368