Attachment #2829 for bug #2368

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

(-)a/src/wifi/examples/test-interference-helper.cc (-6 / +67 lines)

Lines 55-63	Link Here

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

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

#include "ns3/nist-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"

#include "ns3/simple-frame-capture-model.h"

#include "ns3/log.h"

using namespace ns3;

using namespace ns3;

NS_LOG_COMPONENT_DEFINE ("test-interference-helper");

bool checkResults = false;

bool expectRxASuccessfull = false;

bool expectRxBSuccessfull = false;

/// InterferenceExperiment

/// InterferenceExperiment

class InterferenceExperiment

class InterferenceExperiment

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 87-92	Link Here

  void Run (struct InterferenceExperiment::Input input);

  void Run (struct InterferenceExperiment::Input input);

private:

private:

100

  /// Function triggered when a packet is dropped

101

  void PacketDropped(Ptr<const Packet> packet);

  /// Send A function

102

  /// Send A function

  void SendA (void) const;

103

  void SendA (void) const;

  /// Send B function

104

  /// Send B function

Lines 94-99	Link Here

  Ptr<YansWifiPhy> m_txA; ///< transmit A function

106

  Ptr<YansWifiPhy> m_txA; ///< transmit A function

  Ptr<YansWifiPhy> m_txB; ///< transmit B function

107

  Ptr<YansWifiPhy> m_txB; ///< transmit B function

  struct Input m_input; ///< input

108

  struct Input m_input; ///< input

109

  bool m_droppedA; ///< flag to indicate whether packet A has been dropped

110

  bool m_droppedB; ///< flag to indicate whether packet B has been dropped

};

111

};

112

void

113

void

Lines 118-138	Link Here

118

  m_txB->SendPacket (p, txVector);

132

  m_txB->SendPacket (p, txVector);

119

133

120

134

135

void

136

InterferenceExperiment::PacketDropped(Ptr<const Packet> packet)

137

138

    if (packet->GetUid () == 0)

139

140

      m_droppedA = true;

141

142

    else if (packet->GetUid () == 1)

143

144

      m_droppedB = true;

145

146

    else

147

148

      NS_LOG_ERROR ("Unknown packet!");

149

      exit (1);

150

151

152

121

InterferenceExperiment::InterferenceExperiment ()

153

InterferenceExperiment::InterferenceExperiment ()

154

  : m_droppedA (false),

155

    m_droppedB (false)

122

156

123

157

158

124

InterferenceExperiment::Input::Input ()

159

InterferenceExperiment::Input::Input ()

125

  : interval (MicroSeconds (0)),

160

  : interval (MicroSeconds (0)),

126

    xA (-5),

161

    xA (-5),

127

    xB (5),

162

    xB (5),

128

    txModeA ("OfdmRate54Mbps"),

163

    txModeA ("OfdmRate54Mbps"),

129

    txModeB ("OfdmRate54Mbps"),

164

    txModeB ("OfdmRate54Mbps"),

130

    txPowerLevelA (0),

165

    txPowerLevelA (16.0206),

131

    txPowerLevelB (0),

166

    txPowerLevelB (16.0206),

132

    packetSizeA (1500),

167

    packetSizeA (1500),

133

    packetSizeB (1500),

168

    packetSizeB (1500),

134

    standard (WIFI_PHY_STANDARD_80211a),

169

    standard (WIFI_PHY_STANDARD_80211a),

135

    preamble (WIFI_PREAMBLE_LONG)

170

    preamble (WIFI_PREAMBLE_LONG),

171

    captureEnabled (false),

172

    captureMargin (0)

136

173

137

174

138

175

Lines 157-163	Link Here

157

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

194

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

158

195

159

  m_txA = CreateObject<YansWifiPhy> ();

196

  m_txA = CreateObject<YansWifiPhy> ();

197

  m_txA->SetTxPowerStart (input.txPowerLevelA);

198

  m_txA->SetTxPowerEnd (input.txPowerLevelA);

160

  m_txB = CreateObject<YansWifiPhy> ();

199

  m_txB = CreateObject<YansWifiPhy> ();

200

  m_txB->SetTxPowerStart (input.txPowerLevelB);

201

  m_txB->SetTxPowerEnd (input.txPowerLevelB);

161

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

202

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

162

203

163

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

204

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

Lines 170-188	Link Here

170

  m_txA->SetMobility (posTxA);

211

  m_txA->SetMobility (posTxA);

171

  m_txB->SetMobility (posTxB);

212

  m_txB->SetMobility (posTxB);

172

  rx->SetMobility (posRx);

213

  rx->SetMobility (posRx);

214

  if (input.captureEnabled)

215

216

      Ptr<SimpleFrameCaptureModel> frameCaptureModel = CreateObject<SimpleFrameCaptureModel> ();

217

      frameCaptureModel->SetMargin (input.captureMargin);

218

      rx->SetFrameCaptureModel (frameCaptureModel);

219

173

220

174

  m_txA->ConfigureStandard (input.standard);

221

  m_txA->ConfigureStandard (input.standard);

175

  m_txB->ConfigureStandard (input.standard);

222

  m_txB->ConfigureStandard (input.standard);

176

  rx->ConfigureStandard (input.standard);

223

  rx->ConfigureStandard (input.standard);

177

224

225

  rx->TraceConnectWithoutContext("PhyRxDrop", MakeCallback(&InterferenceExperiment::PacketDropped, this));

226

178

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

227

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

179

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

228

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

180

229

181

  Simulator::Run ();

230

  Simulator::Run ();

182

  Simulator::Destroy ();

231

  Simulator::Destroy ();

232

233

  if(checkResults && (m_droppedA == expectRxASuccessfull || m_droppedB == expectRxBSuccessfull))

234

235

    NS_LOG_ERROR ("Results are not expected!");

236

    exit (1);

237

183

238

184

239

185

186

int main (int argc, char *argv[])

240

int main (int argc, char *argv[])

187

241

188

  InterferenceExperiment::Input input;

242

  InterferenceExperiment::Input input;

Lines 202-211	Link Here

202

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

256

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

203

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

257

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

204

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

258

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

259

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

260

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

261

  cmd.AddValue ("checkResults", "Used to check results at the end of the test", checkResults);

262

  cmd.AddValue ("expectRxASuccessfull", "Indicate whether packet A is expected to be successfully received", expectRxASuccessfull);

263

  cmd.AddValue ("expectRxBSuccessfull", "Indicate whether packet B is expected to be successfully received", expectRxBSuccessfull);

205

  cmd.Parse (argc, argv);

264

  cmd.Parse (argc, argv);

206

265

266

  LogComponentEnable ("WifiPhy", LOG_LEVEL_ALL);

207

  LogComponentEnable ("YansWifiPhy", LOG_LEVEL_ALL);

267

  LogComponentEnable ("YansWifiPhy", LOG_LEVEL_ALL);

208

  LogComponentEnable ("InterferenceHelper", LOG_LEVEL_ALL);

268

  LogComponentEnable ("InterferenceHelper", LOG_LEVEL_ALL);

269

  LogComponentEnable ("SimpleFrameCaptureModel", LOG_LEVEL_ALL);

209

270

210

  input.interval = MicroSeconds (delay);

271

  input.interval = MicroSeconds (delay);

211

272




/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2017
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Author: Sébastien Deronne <sebastien.deronne@gmail.com>
 */

#include "frame-capture-model.h"

namespace ns3 {

NS_OBJECT_ENSURE_REGISTERED (FrameCaptureModel);

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

} //namespace ns3




/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2017
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Author: Sébastien Deronne <sebastien.deronne@gmail.com>
 */

#ifndef FRAME_CAPTURE_MODEL_H
#define FRAME_CAPTURE_MODEL_H

#include "ns3/object.h"
#include "interference-helper.h"

namespace ns3 {

/**
 * \ingroup wifi
 * \brief the interface for Wifi's frame capture models
 *
 */
class FrameCaptureModel : public Object
{
public:
  /**
   * \brief Get the type ID.
   * \return the object TypeId
   */
  static TypeId GetTypeId (void);

  /**
   * A pure virtual method that must be implemented in the subclass.
   * This method returns whether the reception should be switched to a
   * new incoming frame.
   *
   * \param currentEvent the event of the current frame
   * \param newEvent the event of the new incoming frame
   *
   * \return true if the reception should be switched to a new incoming frame,
   *         false otherwise
   */
  virtual bool CaptureNewFrame (Ptr<InterferenceHelper::Event> currentEvent, Ptr<InterferenceHelper::Event> newEvent) const = 0;
};

} //namespace ns3

#endif /* FRAME_CAPTURE_MODEL_H */





 *       Phy event class
 ****************************************************************/

InterferenceHelper::Event::Event (Ptr<const Packet> packet, WifiTxVector txVector, Time duration, double rxPower)
  : //m_packet (packet),
    m_txVector (txVector),
    m_startTime (Simulator::Now ()),
    m_endTime (m_startTime + duration),
    m_rxPowerW (rxPower)
{
  m_packet = packet;
}

InterferenceHelper::Event::~Event ()

  return m_rxPowerW;
}

Ptr<const Packet>
InterferenceHelper::Event::GetPacket (void) const
{
  return m_packet;
}

uint32_t
InterferenceHelper::Event::GetSize (void) const
{
  return m_packet->GetSize();
}

WifiTxVector

 *       short period of time.
 ****************************************************************/

InterferenceHelper::NiChange::NiChange (Time time, double delta, Ptr<InterferenceHelper::Event> event)
  : m_time (time),
    m_delta (delta),
    m_event (event)
{
}


  return m_delta;
}

Ptr<InterferenceHelper::Event>
InterferenceHelper::NiChange::GetEvent (void) const
{
  return m_event;
}

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

}

Ptr<InterferenceHelper::Event>
InterferenceHelper::Add (Ptr<const Packet> packet, WifiTxVector txVector, Time duration, double rxPowerW)
{
  Ptr<InterferenceHelper::Event> event;

  event = Create<InterferenceHelper::Event> (packet, txVector, duration, rxPowerW);
  AppendEvent (event);
  return event;
}

  // Parameters other than duration and rxPowerW are unused for this type
  // of signal, so we provide dummy versions
  WifiTxVector fakeTxVector;
  Ptr<const Packet> packet (0);
  Add (packet, fakeTxVector, duration, rxPowerW);
}

void

          m_firstPower += i->GetDelta ();
        }
      m_niChanges.erase (m_niChanges.begin (), nowIterator);
      m_niChanges.insert (m_niChanges.begin (), NiChange (event->GetStartTime (), event->GetRxPowerW (), event));
    }
  else
    {
      AddNiChangeEvent (NiChange (event->GetStartTime (), event->GetRxPowerW (), event));
    }
  AddNiChangeEvent (NiChange (event->GetEndTime (), -event->GetRxPowerW (), event));

}


InterferenceHelper::CalculateNoiseInterferenceW (Ptr<InterferenceHelper::Event> event, NiChanges *ni) const
{
  double noiseInterference = m_firstPower;
  NiChanges::const_iterator eventIterator = m_niChanges.begin ();
  while (eventIterator != m_niChanges.end ())
    {
      // Iterate the NI change list from the beginning to the end
      // until find the position of the event in the NI change list
      // The reason of using the event that causes the NI change to identify
      // different NI changes is because in some special cases
      // different NI changes happen at the same time with the same delta
      // value. Therefore, it may be impossible to identify a NI change that belongs
      // to which event based on just the NI time and NI delta value
      if (eventIterator->GetEvent () != event)
        {
          // The NI changes which happen before the event should be considered
          // as the interference. This considers the case that the receiving event
          // arrives while another receiving event is going on. The SINR of
          // the newly arrived event is calculated for checking the possibility of frame capture
          noiseInterference += eventIterator->GetDelta ();
        }
      else
        {
          break;
        }
      ++eventIterator;
    }

  for (NiChanges::const_iterator i = eventIterator + 1; i != m_niChanges.end (); ++i)
    {
      if (event->GetEndTime () == i->GetTime () && event == i->GetEvent ())
        {
          break;
        }
      ni->push_back (*i);
    }
  ni->insert (ni->begin (), NiChange (event->GetStartTime (), noiseInterference, event));
  ni->push_back (NiChange (event->GetEndTime (), 0, event));
  return noiseInterference;
}


InterferenceHelper::NiChanges::iterator
InterferenceHelper::GetPosition (Time moment)
{
  return std::upper_bound (m_niChanges.begin (), m_niChanges.end (), NiChange (moment, 0, NULL));
}

void




#define INTERFERENCE_HELPER_H

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


    /**
     * Create an Event with the given parameters.
     *
     * \param packet the packet
     * \param txVector TXVECTOR of the packet
     * \param duration duration of the signal
     * \param rxPower the receive power (w)
     */
    Event (Ptr<const Packet> packet, WifiTxVector txVector, Time duration, double rxPower);
    ~Event ();

    /**

     */
    double GetRxPowerW (void) const;
    /**
     * Return the packet.
     *
     * \return the packet
     */
    Ptr<const Packet> GetPacket (void) const;
    /**
     * Return the size of the packet (bytes).
     *
     * \return the size of the packet (bytes)



private:
    Ptr<const Packet> m_packet; ///< packet
    WifiTxVector m_txVector; ///< TXVECTOR
    Time m_startTime; ///< start time
    Time m_endTime; ///< end time

  /**
   * Add the packet-related signal to interference helper.
   *
   * \param packet the packet
   * \param txVector TXVECTOR of the packet
   * \param duration the duration of the signal
   * \param rxPower receive power (W)
   *
   * \return InterferenceHelper::Event
   */
  Ptr<InterferenceHelper::Event> Add (Ptr<const Packet> packet, WifiTxVector txVector, Time duration, double rxPower);

  /**
   * Add a non-Wifi signal to interference helper.

     *
     * \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; ///< time
    double m_delta; ///< delta
    Ptr<InterferenceHelper::Event> m_event;
  };
  /**
   * typedef for a vector of NiChanges

  NiChanges m_niChanges;
  double m_firstPower; ///< first power
  bool m_rxing; ///< flag whether it is in receiving state

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




/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2017
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Author: Sébastien Deronne <sebastien.deronne@gmail.com>
 */

#include "simple-frame-capture-model.h"
#include "ns3/simulator.h"
#include "ns3/log.h"
#include "ns3/double.h"
#include "wifi-utils.h"
#include "wifi-phy.h"

namespace ns3 {

NS_LOG_COMPONENT_DEFINE ("SimpleFrameCaptureModel");

NS_OBJECT_ENSURE_REGISTERED (SimpleFrameCaptureModel);

TypeId
SimpleFrameCaptureModel::GetTypeId (void)
{
  static TypeId tid = TypeId ("ns3::SimpleFrameCaptureModel")
    .SetParent<FrameCaptureModel> ()
    .SetGroupName ("Wifi")
    .AddConstructor<SimpleFrameCaptureModel> ()
    .AddAttribute ("Margin",
                   "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 (&SimpleFrameCaptureModel::GetMargin,
                                       &SimpleFrameCaptureModel::SetMargin),
                   MakeDoubleChecker<double> ())
  ;
  return tid;
}

SimpleFrameCaptureModel::SimpleFrameCaptureModel ()
{
  NS_LOG_FUNCTION (this);
}

SimpleFrameCaptureModel::~SimpleFrameCaptureModel ()
{
  NS_LOG_FUNCTION (this);
}

void
SimpleFrameCaptureModel::SetMargin (double margin)
{
  NS_LOG_FUNCTION (this << margin);
  m_margin = margin;
}

double
SimpleFrameCaptureModel::GetMargin (void) const
{
  return m_margin;
}

bool
SimpleFrameCaptureModel::CaptureNewFrame (Ptr<InterferenceHelper::Event> currentEvent, Ptr<InterferenceHelper::Event> newEvent) const
{
  NS_LOG_FUNCTION (this);
  if (newEvent->GetTxVector ().GetPreambleType () != WIFI_PREAMBLE_NONE
      && (WToDbm (currentEvent->GetRxPowerW ()) + m_margin) < WToDbm (newEvent->GetRxPowerW ())
      && ((currentEvent->GetStartTime () + WifiPhy::GetPlcpPreambleDuration (currentEvent->GetTxVector ())) > Simulator::Now ()))
    {
      return true;
    }
  return false;
}

} //namespace ns3




/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2017
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Author: Sébastien Deronne <sebastien.deronne@gmail.com>
 */

#ifndef SIMPLE_FRAME_CAPTURE_MODEL_H
#define SIMPLE_FRAME_CAPTURE_MODEL_H

#include "frame-capture-model.h"

namespace ns3 {
/**
 * \ingroup wifi
 *
 * A simple threshold-based model for frame capture effect.
 * If the new incoming frame arrives while the receiver is
 * receiving the preamble of another frame and the SIR of 
 * the new incoming frame is above a fixed margin, then 
 * the current frame is dropped and the receiver locks 
 * onto the new incoming frame.
 */
class SimpleFrameCaptureModel : public FrameCaptureModel
{
public:
  /**
   * \brief Get the type ID.
   * \return the object TypeId
   */
  static TypeId GetTypeId (void);

  SimpleFrameCaptureModel ();
  ~SimpleFrameCaptureModel ();

  /**
   * Sets the frame capture margin (dB).
   *
   * \param margin the frame capture margin in dB
   */
  void SetMargin (double margin);
  /**
   * Return the frame capture margin (dB).
   *
   * \return the frame capture margin in dB
   */
  double GetMargin (void) const;

  /**
   * This method returns whether the reception should be switched to a
   * new incoming frame.
   *
   * \param currentEvent the event of the current frame
   * \param newEvent the event of the new incoming frame
   *
   * \return true if the reception should be switched to a new incoming frame,
   *         false otherwise
   */
  bool CaptureNewFrame (Ptr<InterferenceHelper::Event> currentEvent, Ptr<InterferenceHelper::Event> newEvent) const;


private:
  double m_margin;
};

} //namespace ns3

#endif /* SIMPLE_FRAME_CAPTURE_MODEL_H */





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.

(-)a/src/wifi/model/wifi-phy.cc (-86 / +147 lines)

Lines 30-35	Link Here

#include "wifi-phy-tag.h"

#include "wifi-phy-tag.h"

#include "ampdu-tag.h"

#include "ampdu-tag.h"

#include "wifi-utils.h"

#include "wifi-utils.h"

#include "frame-capture-model.h"

namespace ns3 {

namespace ns3 {

Lines 314-319	Link Here

314

                   MakeBooleanAccessor (&WifiPhy::GetShortPlcpPreambleSupported,

315

                   MakeBooleanAccessor (&WifiPhy::GetShortPlcpPreambleSupported,

315

                                        &WifiPhy::SetShortPlcpPreambleSupported),

316

                                        &WifiPhy::SetShortPlcpPreambleSupported),

316

                   MakeBooleanChecker ())

317

                   MakeBooleanChecker ())

318

    .AddAttribute ("FrameCaptureModel",

319

                   "Ptr to an object that implements the frame capture model",

320

                   PointerValue (0), //StringValue ("ns3::SimpleFrameCaptureModel"),

321

                   MakePointerAccessor (&WifiPhy::GetFrameCaptureModel,

322

                                        &WifiPhy::SetFrameCaptureModel),

323

                   MakePointerChecker <FrameCaptureModel>())

317

    .AddTraceSource ("PhyTxBegin",

324

    .AddTraceSource ("PhyTxBegin",

318

                     "Trace source indicating a packet "

325

                     "Trace source indicating a packet "

319

                     "has begun transmitting over the channel medium",

326

                     "has begun transmitting over the channel medium",

Lines 378-384	Link Here

378

    m_channelNumber (0),

385

    m_channelNumber (0),

379

    m_initialChannelNumber (0),

386

    m_initialChannelNumber (0),

380

    m_totalAmpduSize (0),

387

    m_totalAmpduSize (0),

381

    m_totalAmpduNumSymbols (0)

388

    m_totalAmpduNumSymbols (0),

389

    m_currentEvent (0)

382

390

383

  NS_LOG_FUNCTION (this);

391

  NS_LOG_FUNCTION (this);

384

  NS_UNUSED (m_numberOfTransmitters);

392

  NS_UNUSED (m_numberOfTransmitters);

Lines 702-707	Link Here

702

  return m_interference.GetErrorRateModel ();

710

  return m_interference.GetErrorRateModel ();

703

711

704

712

713

void

714

WifiPhy::SetFrameCaptureModel (Ptr<FrameCaptureModel> model)

715

716

  m_frameCaptureModel = model;

717

718

719

Ptr<FrameCaptureModel>

720

WifiPhy::GetFrameCaptureModel (void) const

721

722

  return m_frameCaptureModel;

723

724

705

double

725

double

706

WifiPhy::GetPowerDbm (uint8_t power) const

726

WifiPhy::GetPowerDbm (uint8_t power) const

707

727

Lines 2356-2362	Link Here

2356

  //This function should be later split to check separately whether plcp preamble and plcp header can be successfully received.

2376

  //This function should be later split to check separately whether plcp preamble and plcp header can be successfully received.

2357

  //Note: plcp preamble reception is not yet modeled.

2377

  //Note: plcp preamble reception is not yet modeled.

2358

  NS_LOG_FUNCTION (this << packet << WToDbm (rxPowerW) << rxDuration);

2378

  NS_LOG_FUNCTION (this << packet << WToDbm (rxPowerW) << rxDuration);

2359

  AmpduTag ampduTag;

2360

  Time endRx = Simulator::Now () + rxDuration;

2379

  Time endRx = Simulator::Now () + rxDuration;

2361

2380

2362

  WifiPhyTag tag;

2381

  WifiPhyTag tag;

Lines 2380-2395	Link Here

2380

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

2399

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

2381

2400

2382

2401

2383

  WifiPreamble preamble = txVector.GetPreambleType ();

2384

  MpduType mpdutype = tag.GetMpduType ();

2385

  Time preambleAndHeaderDuration = CalculatePlcpPreambleAndHeaderDuration (txVector);

2386

2387

  Ptr<InterferenceHelper::Event> event;

2402

  Ptr<InterferenceHelper::Event> event;

2388

  event = m_interference.Add (packet->GetSize (),

2403

  event = m_interference.Add (packet,

2389

                              txVector,

2404

                              txVector,

2390

                              rxDuration,

2405

                              rxDuration,

2391

                              rxPowerW);

2406

                              rxPowerW);

2392

2407

2408

  MpduType mpdutype = tag.GetMpduType ();

2393

  switch (m_state->GetState ())

2409

  switch (m_state->GetState ())

2394

2410

2395

    case WifiPhy::SWITCHING:

2411

    case WifiPhy::SWITCHING:

Lines 2408-2425	Link Here

2408

2424

2409

          //that packet will be noise _after_ the completion of the

2425

          //that packet will be noise _after_ the completion of the

2410

          //channel switching.

2426

          //channel switching.

2411

          goto maybeCcaBusy;

2427

          MaybeCcaBusyDuration ();

2428

          return;

2412

2429

2413

      break;

2430

      break;

2414

    case WifiPhy::RX:

2431

    case WifiPhy::RX:

2415

      NS_LOG_DEBUG ("drop packet because already in Rx (power=" <<

2432

      NS_ASSERT (m_currentEvent != 0);

2416

                    rxPowerW << "W)");

2433

      if (m_frameCaptureModel != 0 &&

2417

      NotifyRxDrop (packet);

2434

          m_frameCaptureModel->CaptureNewFrame(m_currentEvent, event))

2418

      if (endRx > Simulator::Now () + m_state->GetDelayUntilIdle ())

2419

2435

2420

          //that packet will be noise _after_ the reception of the

2436

          AbortCurrentReception ();

2421

          //currently-received packet.

2437

          NS_LOG_DEBUG ("Switch to new packet");

2422

          goto maybeCcaBusy;

2438

          StartRx (packet, txVector, mpdutype, rxPowerW, rxDuration, event);

2439

2440

      else

2441

2442

          NS_LOG_DEBUG ("drop packet because already in Rx (power=" <<

2443

                        rxPowerW << "W)");

2444

          NotifyRxDrop (packet);

2445

          if (endRx > Simulator::Now () + m_state->GetDelayUntilIdle ())

2446

2447

              //that packet will be noise _after_ the reception of the

2448

              //currently-received packet.

2449

              MaybeCcaBusyDuration ();

2450

              return;

2451

2423

2452

2424

      break;

2453

      break;

2425

    case WifiPhy::TX:

2454

    case WifiPhy::TX:

Lines 2430-2506	Link Here

2430

2459

2431

          //that packet will be noise _after_ the transmission of the

2460

          //that packet will be noise _after_ the transmission of the

2432

          //currently-transmitted packet.

2461

          //currently-transmitted packet.

2433

          goto maybeCcaBusy;

2462

          MaybeCcaBusyDuration ();

2463

          return;

2434

2464

2435

      break;

2465

      break;

2436

    case WifiPhy::CCA_BUSY:

2466

    case WifiPhy::CCA_BUSY:

2437

    case WifiPhy::IDLE:

2467

    case WifiPhy::IDLE:

2438

      if (rxPowerW > GetEdThresholdW ()) //checked here, no need to check in the payload reception (current implementation assumes constant rx power over the packet duration)

2468

      StartRx (packet, txVector, mpdutype, rxPowerW, rxDuration, event);

2439

2440

          if (preamble == WIFI_PREAMBLE_NONE && (m_mpdusNum == 0 || m_plcpSuccess == false))

2441

2442

              m_plcpSuccess = false;

2443

              m_mpdusNum = 0;

2444

              NS_LOG_DEBUG ("drop packet because no PLCP preamble/header has been received");

2445

              NotifyRxDrop (packet);

2446

              goto maybeCcaBusy;

2447

2448

          else if (preamble != WIFI_PREAMBLE_NONE && packet->PeekPacketTag (ampduTag) && m_mpdusNum == 0)

2449

2450

              //received the first MPDU in an MPDU

2451

              m_mpdusNum = ampduTag.GetRemainingNbOfMpdus ();

2452

              m_rxMpduReferenceNumber++;

2453

2454

          else if (preamble == WIFI_PREAMBLE_NONE && packet->PeekPacketTag (ampduTag) && m_mpdusNum > 0)

2455

2456

              //received the other MPDUs that are part of the A-MPDU

2457

              if (ampduTag.GetRemainingNbOfMpdus () < (m_mpdusNum - 1))

2458

2459

                  NS_LOG_DEBUG ("Missing MPDU from the A-MPDU " << m_mpdusNum - ampduTag.GetRemainingNbOfMpdus ());

2460

                  m_mpdusNum = ampduTag.GetRemainingNbOfMpdus ();

2461

2462

              else

2463

2464

                  m_mpdusNum--;

2465

2466

2467

          else if (preamble != WIFI_PREAMBLE_NONE && packet->PeekPacketTag (ampduTag) && m_mpdusNum > 0)

2468

2469

              NS_LOG_DEBUG ("New A-MPDU started while " << m_mpdusNum << " MPDUs from previous are lost");

2470

              m_mpdusNum = ampduTag.GetRemainingNbOfMpdus ();

2471

2472

          else if (preamble != WIFI_PREAMBLE_NONE && m_mpdusNum > 0 )

2473

2474

              NS_LOG_DEBUG ("Didn't receive the last MPDUs from an A-MPDU " << m_mpdusNum);

2475

              m_mpdusNum = 0;

2476

2477

2478

          NS_LOG_DEBUG ("sync to signal (power=" << rxPowerW << "W)");

2479

          //sync to signal

2480

          m_state->SwitchToRx (rxDuration);

2481

          NS_ASSERT (m_endPlcpRxEvent.IsExpired ());

2482

          NotifyRxBegin (packet);

2483

          m_interference.NotifyRxStart ();

2484

2485

          if (preamble != WIFI_PREAMBLE_NONE)

2486

2487

              NS_ASSERT (m_endPlcpRxEvent.IsExpired ());

2488

              m_endPlcpRxEvent = Simulator::Schedule (preambleAndHeaderDuration, &WifiPhy::StartReceivePacket, this,

2489

                                                      packet, txVector, mpdutype, event);

2490

2491

2492

          NS_ASSERT (m_endRxEvent.IsExpired ());

2493

          m_endRxEvent = Simulator::Schedule (rxDuration, &WifiPhy::EndReceive, this,

2494

                                              packet, preamble, mpdutype, event);

2495

2496

      else

2497

2498

          NS_LOG_DEBUG ("drop packet because signal power too Small (" <<

2499

                        rxPowerW << "<" << GetEdThresholdW () << ")");

2500

          NotifyRxDrop (packet);

2501

          m_plcpSuccess = false;

2502

          goto maybeCcaBusy;

2503

2504

      break;

2469

      break;

2505

    case WifiPhy::SLEEP:

2470

    case WifiPhy::SLEEP:

2506

      NS_LOG_DEBUG ("drop packet because in sleep mode");

2471

      NS_LOG_DEBUG ("drop packet because in sleep mode");

Lines 2508-2517	Link Here

2508

      m_plcpSuccess = false;

2473

      m_plcpSuccess = false;

2509

      break;

2474

      break;

2510

2475

2511

2476

2512

  return;

2477

2513

2478

void

2514

maybeCcaBusy:

2479

WifiPhy::MaybeCcaBusyDuration ()

2480

2515

  //We are here because we have received the first bit of a packet and we are

2481

  //We are here because we have received the first bit of a packet and we are

2516

  //not going to be able to synchronize on it

2482

  //not going to be able to synchronize on it

2517

  //In this model, CCA becomes busy when the aggregation of all signals as

2483

  //In this model, CCA becomes busy when the aggregation of all signals as

Lines 2572-2577	Link Here

2572

  InterferenceHelper::SnrPer snrPer;

2538

  InterferenceHelper::SnrPer snrPer;

2573

  snrPer = m_interference.CalculatePlcpPayloadSnrPer (event);

2539

  snrPer = m_interference.CalculatePlcpPayloadSnrPer (event);

2574

  m_interference.NotifyRxEnd ();

2540

  m_interference.NotifyRxEnd ();

2541

  m_currentEvent = 0;

2575

2542

2576

  if (m_plcpSuccess == true)

2543

  if (m_plcpSuccess == true)

2577

2544

Lines 3662-3667	Link Here

3662

3629

3663

3630

3664

3631

3632

void

3633

WifiPhy::AbortCurrentReception ()

3634

3635

  NS_LOG_FUNCTION (this);

3636

  if (m_endPlcpRxEvent.IsRunning ())

3637

3638

      m_endPlcpRxEvent.Cancel ();

3639

3640

  if (m_endRxEvent.IsRunning ())

3641

3642

      m_endRxEvent.Cancel ();

3643

3644

  NotifyRxDrop (m_currentEvent->GetPacket ());

3645

  m_interference.NotifyRxEnd ();

3646

  m_state->SwitchFromRxAbort ();

3647

  m_currentEvent = 0;

3648

3649

3650

void

3651

WifiPhy::StartRx (Ptr<Packet> packet, WifiTxVector txVector, MpduType mpdutype, double rxPowerW, Time rxDuration, Ptr<InterferenceHelper::Event> event)

3652

3653

  NS_LOG_FUNCTION (this << packet << txVector << (uint16_t)mpdutype << rxPowerW << rxDuration);

3654

  if (rxPowerW > GetEdThresholdW ()) //checked here, no need to check in the payload reception (current implementation assumes constant rx power over the packet duration)

3655

3656

      AmpduTag ampduTag;

3657

      WifiPreamble preamble = txVector.GetPreambleType ();

3658

      if (preamble == WIFI_PREAMBLE_NONE && (m_mpdusNum == 0 || m_plcpSuccess == false))

3659

3660

          m_plcpSuccess = false;

3661

          m_mpdusNum = 0;

3662

          NS_LOG_DEBUG ("drop packet because no PLCP preamble/header has been received");

3663

          NotifyRxDrop (packet);

3664

          MaybeCcaBusyDuration ();

3665

          return;

3666

3667

      else if (preamble != WIFI_PREAMBLE_NONE && packet->PeekPacketTag (ampduTag) && m_mpdusNum == 0)

3668

3669

          //received the first MPDU in an MPDU

3670

          m_mpdusNum = ampduTag.GetRemainingNbOfMpdus ();

3671

          m_rxMpduReferenceNumber++;

3672

3673

      else if (preamble == WIFI_PREAMBLE_NONE && packet->PeekPacketTag (ampduTag) && m_mpdusNum > 0)

3674

3675

          //received the other MPDUs that are part of the A-MPDU

3676

          if (ampduTag.GetRemainingNbOfMpdus () < (m_mpdusNum - 1))

3677

3678

              NS_LOG_DEBUG ("Missing MPDU from the A-MPDU " << m_mpdusNum - ampduTag.GetRemainingNbOfMpdus ());

3679

              m_mpdusNum = ampduTag.GetRemainingNbOfMpdus ();

3680

3681

          else

3682

3683

              m_mpdusNum--;

3684

3685

3686

      else if (preamble != WIFI_PREAMBLE_NONE && packet->PeekPacketTag (ampduTag) && m_mpdusNum > 0)

3687

3688

          NS_LOG_DEBUG ("New A-MPDU started while " << m_mpdusNum << " MPDUs from previous are lost");

3689

          m_mpdusNum = ampduTag.GetRemainingNbOfMpdus ();

3690

3691

      else if (preamble != WIFI_PREAMBLE_NONE && m_mpdusNum > 0 )

3692

3693

          NS_LOG_DEBUG ("Didn't receive the last MPDUs from an A-MPDU " << m_mpdusNum);

3694

          m_mpdusNum = 0;

3695

3696

3697

      NS_LOG_DEBUG ("sync to signal (power=" << rxPowerW << "W)");

3698

      m_currentEvent = event;

3699

      m_state->SwitchToRx (rxDuration);

3700

      NS_ASSERT (m_endPlcpRxEvent.IsExpired ());

3701

      NotifyRxBegin (packet);

3702

      m_interference.NotifyRxStart ();

3703

3704

      if (preamble != WIFI_PREAMBLE_NONE)

3705

3706

          NS_ASSERT (m_endPlcpRxEvent.IsExpired ());

3707

          Time preambleAndHeaderDuration = CalculatePlcpPreambleAndHeaderDuration (txVector);

3708

          m_endPlcpRxEvent = Simulator::Schedule (preambleAndHeaderDuration, &WifiPhy::StartReceivePacket, this,

3709

                                                  packet, txVector, mpdutype, event);

3710

3711

3712

      NS_ASSERT (m_endRxEvent.IsExpired ());

3713

      m_endRxEvent = Simulator::Schedule (rxDuration, &WifiPhy::EndReceive, this,

3714

                                          packet, preamble, mpdutype, event);

3715

3716

  else

3717

3718

      NS_LOG_DEBUG ("drop packet because signal power too Small (" <<

3719

                    rxPowerW << "<" << GetEdThresholdW () << ")");

3720

      NotifyRxDrop (packet);

3721

      m_plcpSuccess = false;

3722

      MaybeCcaBusyDuration ();

3723

3724

3725

3665

int64_t

3726

int64_t

3666

WifiPhy::AssignStreams (int64_t stream)

3727

WifiPhy::AssignStreams (int64_t stream)

3667

3728




#include <map>
#include "ns3/callback.h"
#include "ns3/event-id.h"
#include "ns3/packet.h"
#include "ns3/mobility-model.h"
#include "ns3/random-variable-stream.h"
#include "ns3/channel.h"
#include "wifi-phy-standard.h"
#include "interference-helper.h"
#include "ns3/node.h"
#include "ns3/string.h"

namespace ns3 {


class WifiPhyStateHelper;

/**
 * FrameCaptureModel class
 */
class FrameCaptureModel;

/**
 * This enumeration defines the type of an MPDU.
 */
/// MpduType enumeration

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

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

  Ptr<ErrorRateModel> GetErrorRateModel (void) const;

  /**
   * Sets the frame capture model.
   *
   * \param rate the frame capture model
   */
  void SetFrameCaptureModel (Ptr<FrameCaptureModel> rate);
  /**
   * Return the frame capture model this PHY is using.
   *
   * \return the frame capture model this PHY is using
   */
  Ptr<FrameCaptureModel> GetFrameCaptureModel (void) const;

  /**
   * \return the channel width
   */
  uint8_t GetChannelWidth (void) const;

   * \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
  Ptr<FrameCaptureModel> m_frameCaptureModel; //!< Frame capture model
};

/**

(-)a/src/wifi/test/examples-to-run.py (+3 lines)

Lines 247-252	Link Here

247

    ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"),

247

    ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"),

248

    ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"),

248

    ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"),

249

    ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=4 --clientNss=4 --stepTime=0.1", "True", "True"),

249

    ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=4 --clientNss=4 --stepTime=0.1", "True", "True"),

250

    ("test-interference-helper --enableCapture=0 --txPowerA=5 --txPowerB=15 --delay=10 --txModeA=OfdmRate6Mbps --txModeB=OfdmRate6Mbps --checkResults=1 --expectRxASuccessfull=0 --expectRxBSuccessfull=0", "True", "True"),

251

    ("test-interference-helper --enableCapture=1 --txPowerA=5 --txPowerB=15 --delay=10 --txModeA=OfdmRate6Mbps --txModeB=OfdmRate6Mbps --checkResults=1 --expectRxASuccessfull=0 --expectRxBSuccessfull=1", "True", "True"),

252

250

253

251

254

252

# A list of Python examples to run in order to ensure that they remain

255

# A list of Python examples to run in order to ensure that they remain

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

Lines 83-88	Link Here

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

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

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

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

        'model/he-capabilities.cc',

        'model/he-capabilities.cc',

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

        'model/simple-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 190-195	Link Here

190

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

192

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

191

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

193

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

192

        'model/he-capabilities.h',

194

        'model/he-capabilities.h',

195

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

196

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

193

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

197

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

194

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

198

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

195

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

199

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

Return to bug 2368