Attachment #3238 for bug #3020

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




#include "interference-helper.h"
#include "wifi-phy.h"
#include "error-rate-model.h"
#include "wifi-utils.h"

namespace ns3 {


  double noiseFloor = m_noiseFigure * Nt;
  double noise = noiseFloor + noiseInterference;
  double snr = signal / noise; //linear scale
  NS_LOG_DEBUG ("bandwidth(MHz)=" << channelWidth << ", signal(W)= " << signal << ", noise(W)=" << noiseFloor << ", interference(W)=" << noiseInterference << ", snr=" << RatioToDb(snr) << "dB");
  return snr;
}

double
InterferenceHelper::CalculateNoiseInterferenceW (Ptr<Event> event, NiChanges *ni) const
{
  double noiseInterferenceW = m_firstPower;
  auto it = m_niChanges.find (event->GetStartTime ());
  for (; it != m_niChanges.end (); ++it)
    {
      if (it->second.GetEvent () == event)
        {
          continue;
        }
      if (it->first > Simulator::Now ())
        {
          break;
        }
      noiseInterferenceW = it->second.GetPower () - event->GetRxPowerW ();
    }
  it = m_niChanges.find (event->GetStartTime ());
  for (; it != m_niChanges.end () && it->second.GetEvent () != event; ++it);
  ni->emplace (event->GetStartTime (), NiChange (0, event));
  while (++it != m_niChanges.end () && it->second.GetEvent () != event)
    {
      ni->insert (*it);
    }
  ni->emplace (event->GetEndTime (), NiChange (0, event));
  return noiseInterferenceW;
}

double




/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2018 University of Washington
 *
 * 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 "preamble-detection-model.h"

namespace ns3 {

NS_OBJECT_ENSURE_REGISTERED (PreambleDetectionModel);

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

} //namespace ns3




/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2018 University of Washington
 *
 * 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 PREAMBLE_DETECTION_MODEL_H
#define PREAMBLE_DETECTION_MODEL_H

#include "ns3/object.h"

namespace ns3 {

/**
 * \ingroup wifi
 * \brief the interface for Wifi's preamble detection models
 *
 */
class PreambleDetectionModel : 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 preamble detection was successful.
   *
   * \param snr the SNR of the received signal.
   * \param channelWidth the channel width of the received signal in MHz.
   *
   * \return true if the preamble has been detected,
   *         false otherwise
   */
  virtual bool IsPreambleDetected (double snr, double channelWidth) const = 0;
};

} //namespace ns3

#endif /* PREAMBLE_DETECTION_MODEL_H */


(-)a/src/wifi/model/spectrum-wifi-phy.cc (-1 / +1 lines)

Lines 259-265 SpectrumWifiPhy::StartRx (Ptr<SpectrumSignalParameters> rxParams)	Link Here

259

260

  NS_LOG_INFO ("Received Wi-Fi signal");

260

  NS_LOG_INFO ("Received Wi-Fi signal");

261

  Ptr<Packet> packet = wifiRxParams->packet->Copy ();

261

  Ptr<Packet> packet = wifiRxParams->packet->Copy ();

262

  StartReceivePreambleAndHeader (packet, rxPowerW, rxDuration);

262

  StartReceivePreamble (packet, rxPowerW, rxDuration);

263

264

265

Ptr<AntennaModel>

265

Ptr<AntennaModel>




/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2018 University of Washington
 *
 * 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 "ns3/log.h"
#include "ns3/double.h"
#include "threshold-preamble-detection-model.h"
#include "wifi-utils.h"

namespace ns3 {

NS_LOG_COMPONENT_DEFINE ("ThresholdPreambleDetectionModel");

NS_OBJECT_ENSURE_REGISTERED (ThresholdPreambleDetectionModel);

TypeId
ThresholdPreambleDetectionModel::GetTypeId (void)
{
  static TypeId tid = TypeId ("ns3::ThresholdPreambleDetectionModel")
    .SetParent<PreambleDetectionModel> ()
    .SetGroupName ("Wifi")
    .AddConstructor<ThresholdPreambleDetectionModel> ()
    .AddAttribute ("Threshold",
                   "Preamble is successfully detection if the SNR is at or above this value (expressed in dB).",
                   DoubleValue (2),
                   MakeDoubleAccessor (&ThresholdPreambleDetectionModel::m_threshold),
                   MakeDoubleChecker<double> ())
  ;
  return tid;
}

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

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

bool
ThresholdPreambleDetectionModel::IsPreambleDetected (double snr, double channelWidth) const
{
  NS_LOG_FUNCTION (this);
  return (RatioToDb (snr) >= m_threshold);
}

} //namespace ns3




/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2018 University of Washington
 *
 * 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 THRESHOLD_PREAMBLE_DETECTION_MODEL_H
#define THRESHOLD_PREAMBLE_DETECTION_MODEL_H

#include "preamble-detection-model.h"

namespace ns3 {
/**
 * \ingroup wifi
 *
 * A threshold-based model for detecting PHY preamble.
 * This model assumes that a preamble is successfully detected if SNR is at or above a given threshold. By default, this threshold is set to 2 dB.
 */
class ThresholdPreambleDetectionModel : public PreambleDetectionModel
{
public:
  /**
   * \brief Get the type ID.
   * \return the object TypeId
   */
  static TypeId GetTypeId (void);

  ThresholdPreambleDetectionModel ();
  ~ThresholdPreambleDetectionModel ();

  /**
   * This method returns whether the preamble detection was successful.
   *
   * \param snr the SNR ratio (not dB) of the received signal.
   * \param channelWidth the channel width of the received signal in MHz.
   *
   * \return true if the preamble has been detected,
   *         false otherwise
   */
  bool IsPreambleDetected (double snr, double channelWidth) const;


private:
  double m_threshold; ///< SNR threshold in dB used to decide whether a preamble is successfully received
};

} //namespace ns3

#endif /* THRESHOLD_PREAMBLE_DETECTION_MODEL_H */

(-)a/src/wifi/model/wifi-phy.cc (-38 / +113 lines)

Lines 30-35	Link Here

#include "ampdu-tag.h"

#include "ampdu-tag.h"

#include "wifi-utils.h"

#include "wifi-utils.h"

#include "frame-capture-model.h"

#include "frame-capture-model.h"

#include "preamble-detection-model.h"

#include "wifi-radio-energy-model.h"

#include "wifi-radio-energy-model.h"

#include "error-rate-model.h"

#include "error-rate-model.h"

#include "wifi-net-device.h"

#include "wifi-net-device.h"

Lines 299-304 WifiPhy::GetTypeId (void)	Link Here

299

                   PointerValue (),

300

                   PointerValue (),

300

                   MakePointerAccessor (&WifiPhy::m_frameCaptureModel),

301

                   MakePointerAccessor (&WifiPhy::m_frameCaptureModel),

301

                   MakePointerChecker <FrameCaptureModel> ())

302

                   MakePointerChecker <FrameCaptureModel> ())

303

    .AddAttribute ("PreambleDetectionModel",

304

                   "Ptr to an object that implements the preamble detection model",

305

                   PointerValue (),

306

                   MakePointerAccessor (&WifiPhy::m_preambleDetectionModel),

307

                   MakePointerChecker <PreambleDetectionModel> ())

302

    .AddAttribute ("PostReceptionErrorModel",

308

    .AddAttribute ("PostReceptionErrorModel",

303

                   "An optional packet error model can be added to the receive "

309

                   "An optional packet error model can be added to the receive "

304

                   "packet process after any propagation-based (SNR-based) error "

310

                   "packet process after any propagation-based (SNR-based) error "

Lines 363-368 WifiPhy::WifiPhy ()	Link Here

363

    m_rxMpduReferenceNumber (0xffffffff),

369

    m_rxMpduReferenceNumber (0xffffffff),

364

    m_endRxEvent (),

370

    m_endRxEvent (),

365

    m_endPlcpRxEvent (),

371

    m_endPlcpRxEvent (),

372

    m_endPreambleDetectionEvent (),

366

    m_standard (WIFI_PHY_STANDARD_UNSPECIFIED),

373

    m_standard (WIFI_PHY_STANDARD_UNSPECIFIED),

367

    m_isConstructed (false),

374

    m_isConstructed (false),

368

    m_channelCenterFrequency (0),

375

    m_channelCenterFrequency (0),

Lines 392-397 void	Link Here

392

WifiPhy::DoDispose (void)

399

WifiPhy::DoDispose (void)

393

400

394

  NS_LOG_FUNCTION (this);

401

  NS_LOG_FUNCTION (this);

402

  m_endRxEvent.Cancel ();

403

  m_endPlcpRxEvent.Cancel ();

404

  m_endPreambleDetectionEvent.Cancel ();

395

  m_device = 0;

405

  m_device = 0;

396

  m_mobility = 0;

406

  m_mobility = 0;

397

  m_state = 0;

407

  m_state = 0;

Lines 742-747 WifiPhy::SetFrameCaptureModel (const Ptr<FrameCaptureModel> model)	Link Here

742

752

743

753

744

void

754

void

755

WifiPhy::SetPreambleDetectionModel (const Ptr<PreambleDetectionModel> model)

756

757

  m_preambleDetectionModel = model;

758

759

760

void

745

WifiPhy::SetWifiRadioEnergyModel (const Ptr<WifiRadioEnergyModel> wifiRadioEnergyModel)

761

WifiPhy::SetWifiRadioEnergyModel (const Ptr<WifiRadioEnergyModel> wifiRadioEnergyModel)

746

762

747

  m_wifiRadioEnergyModel = wifiRadioEnergyModel;

763

  m_wifiRadioEnergyModel = wifiRadioEnergyModel;

Lines 1485-1490 WifiPhy::DoChannelSwitch (uint8_t nch)	Link Here

1485

      NS_LOG_DEBUG ("drop packet because of channel switching while reception");

1501

      NS_LOG_DEBUG ("drop packet because of channel switching while reception");

1486

      m_endPlcpRxEvent.Cancel ();

1502

      m_endPlcpRxEvent.Cancel ();

1487

      m_endRxEvent.Cancel ();

1503

      m_endRxEvent.Cancel ();

1504

      m_endPreambleDetectionEvent.Cancel ();

1488

      goto switchChannel;

1505

      goto switchChannel;

1489

      break;

1506

      break;

1490

    case WifiPhyState::TX:

1507

    case WifiPhyState::TX:

Lines 1493-1498 WifiPhy::DoChannelSwitch (uint8_t nch)	Link Here

1493

      break;

1510

      break;

1494

    case WifiPhyState::CCA_BUSY:

1511

    case WifiPhyState::CCA_BUSY:

1495

    case WifiPhyState::IDLE:

1512

    case WifiPhyState::IDLE:

1513

      if (m_endPreambleDetectionEvent.IsRunning ())

1514

1515

        m_endPreambleDetectionEvent.Cancel ();

1516

        m_endRxEvent.Cancel ();

1517

1496

      goto switchChannel;

1518

      goto switchChannel;

1497

      break;

1519

      break;

1498

    case WifiPhyState::SLEEP:

1520

    case WifiPhyState::SLEEP:

Lines 1537-1542 WifiPhy::DoFrequencySwitch (uint16_t frequency)	Link Here

1537

      NS_LOG_DEBUG ("drop packet because of channel/frequency switching while reception");

1559

      NS_LOG_DEBUG ("drop packet because of channel/frequency switching while reception");

1538

      m_endPlcpRxEvent.Cancel ();

1560

      m_endPlcpRxEvent.Cancel ();

1539

      m_endRxEvent.Cancel ();

1561

      m_endRxEvent.Cancel ();

1562

      m_endPreambleDetectionEvent.Cancel ();

1540

      goto switchFrequency;

1563

      goto switchFrequency;

1541

      break;

1564

      break;

1542

    case WifiPhyState::TX:

1565

    case WifiPhyState::TX:

Lines 1545-1550 WifiPhy::DoFrequencySwitch (uint16_t frequency)	Link Here

1545

      break;

1568

      break;

1546

    case WifiPhyState::CCA_BUSY:

1569

    case WifiPhyState::CCA_BUSY:

1547

    case WifiPhyState::IDLE:

1570

    case WifiPhyState::IDLE:

1571

      if (m_endPreambleDetectionEvent.IsRunning ())

1572

1573

        m_endPreambleDetectionEvent.Cancel ();

1574

        m_endRxEvent.Cancel ();

1575

1548

      goto switchFrequency;

1576

      goto switchFrequency;

1549

      break;

1577

      break;

1550

    case WifiPhyState::SLEEP:

1578

    case WifiPhyState::SLEEP:

Lines 1608-1629 void	Link Here

1608

WifiPhy::SetOffMode (void)

1636

WifiPhy::SetOffMode (void)

1609

1637

1610

  NS_LOG_FUNCTION (this);

1638

  NS_LOG_FUNCTION (this);

1611

  switch (m_state->GetState ())

1639

  m_endPlcpRxEvent.Cancel ();

1612

1640

  m_endRxEvent.Cancel ();

1613

    case WifiPhyState::RX:

1641

  m_endPreambleDetectionEvent.Cancel ();

1614

      m_endPlcpRxEvent.Cancel ();

1642

  m_state->SwitchToOff ();

1615

      m_endRxEvent.Cancel ();

1616

    case WifiPhyState::TX:

1617

    case WifiPhyState::SWITCHING:

1618

    case WifiPhyState::CCA_BUSY:

1619

    case WifiPhyState::IDLE:

1620

    case WifiPhyState::SLEEP:

1621

      m_state->SwitchToOff ();

1622

      break;

1623

    default:

1624

      NS_ASSERT (false);

1625

      break;

1626

1627

1643

1628

1644

1629

void

1645

void

Lines 1706-1711 WifiPhy::GetHePlcpHeaderMode ()	Link Here

1706

1722

1707

1723

1708

Time

1724

Time

1725

WifiPhy::GetPreambleDetectionDuration (void)

1726

1727

  return MicroSeconds (4);

1728

1729

1730

Time

1709

WifiPhy::GetPlcpTrainingSymbolDuration (WifiTxVector txVector)

1731

WifiPhy::GetPlcpTrainingSymbolDuration (WifiTxVector txVector)

1710

1732

1711

  uint8_t Ndltf, Neltf;

1733

  uint8_t Ndltf, Neltf;

Lines 2368-2379 WifiPhy::SendPacket (Ptr<const Packet> packet, WifiTxVector txVector, MpduType m	Link Here

2368

  Time txDuration = CalculateTxDuration (packet->GetSize (), txVector, GetFrequency (), mpdutype, 1);

2390

  Time txDuration = CalculateTxDuration (packet->GetSize (), txVector, GetFrequency (), mpdutype, 1);

2369

  NS_ASSERT (txDuration.IsStrictlyPositive ());

2391

  NS_ASSERT (txDuration.IsStrictlyPositive ());

2370

2392

2371

  if (m_state->IsStateRx ())

2393

  if (m_endPreambleDetectionEvent.IsRunning ())

2394

2395

      m_endPreambleDetectionEvent.Cancel ();

2396

2397

  if (m_endPlcpRxEvent.IsRunning ())

2372

2398

2373

      m_endPlcpRxEvent.Cancel ();

2399

      m_endPlcpRxEvent.Cancel ();

2400

2401

  if (m_endRxEvent.IsRunning ())

2402

2374

      m_endRxEvent.Cancel ();

2403

      m_endRxEvent.Cancel ();

2404

2405

  if (m_state->IsStateRx ())

2406

2375

      m_interference.NotifyRxEnd ();

2407

      m_interference.NotifyRxEnd ();

2376

2408

2409

2377

  NotifyTxBegin (packet);

2410

  NotifyTxBegin (packet);

2378

  if ((mpdutype == MPDU_IN_AGGREGATE) && (txVector.GetPreambleType () != WIFI_PREAMBLE_NONE))

2411

  if ((mpdutype == MPDU_IN_AGGREGATE) && (txVector.GetPreambleType () != WIFI_PREAMBLE_NONE))

2379

2412

Lines 2406-2412 WifiPhy::SendPacket (Ptr<const Packet> packet, WifiTxVector txVector, MpduType m	Link Here

2406

2439

2407

2440

2408

void

2441

void

2409

WifiPhy::StartReceivePreambleAndHeader (Ptr<Packet> packet, double rxPowerW, Time rxDuration)

2442

WifiPhy::StartReceiveHeader (Ptr<Packet> packet, WifiTxVector txVector, MpduType mpdutype, Ptr<Event> event, Time rxDuration)

2443

2444

  NS_LOG_FUNCTION (this << packet << txVector.GetMode () << txVector.GetPreambleType () << +mpdutype);

2445

  NS_ASSERT (!IsStateRx ());

2446

  NS_ASSERT (m_endPlcpRxEvent.IsExpired ());

2447

2448

  InterferenceHelper::SnrPer snrPer = m_interference.CalculatePlcpHeaderSnrPer (event);

2449

  double snr = snrPer.snr;

2450

  NS_LOG_DEBUG ("snr(dB)=" << RatioToDb (snrPer.snr) << ", per=" << snrPer.per);

2451

2452

  if (!m_preambleDetectionModel || (m_preambleDetectionModel->IsPreambleDetected (snr, m_channelWidth)))

2453

2454

    m_state->SwitchToRx (rxDuration);

2455

    NotifyRxBegin (packet);

2456

2457

    Time remainingPreambleHeaderDuration = CalculatePlcpPreambleAndHeaderDuration (txVector) - GetPreambleDetectionDuration ();

2458

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

2459

                                            packet, txVector, mpdutype, event);

2460

2461

    NS_ASSERT (m_endRxEvent.IsExpired ());

2462

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

2463

                                        packet, txVector.GetPreambleType (), mpdutype, event);

2464

2465

  else

2466

2467

    NS_LOG_DEBUG ("Packet reception could not be started because PHY preamble detection failed");

2468

    m_plcpSuccess = false;

2469

    m_interference.NotifyRxEnd ();

2470

2471

2472

2473

void

2474

WifiPhy::StartReceivePreamble (Ptr<Packet> packet, double rxPowerW, Time rxDuration)

2410

2475

2411

  WifiPhyTag tag;

2476

  WifiPhyTag tag;

2412

  bool found = packet->RemovePacketTag (tag);

2477

  bool found = packet->RemovePacketTag (tag);

Lines 2435-2442 WifiPhy::StartReceivePreambleAndHeader (Ptr<Packet> packet, double rxPowerW, Tim	Link Here

2435

2500

2436

  if (tag.GetFrameComplete () == 0)

2501

  if (tag.GetFrameComplete () == 0)

2437

2502

2438

      NS_LOG_DEBUG ("drop packet because of incomplete frame");

2503

      NS_LOG_DEBUG ("Packet reception stopped because transmitter has been switched off");

2439

      NotifyRxDrop (packet);

2440

      m_plcpSuccess = false;

2504

      m_plcpSuccess = false;

2441

      return;

2505

      return;

2442

2506

Lines 2450-2457 WifiPhy::StartReceivePreambleAndHeader (Ptr<Packet> packet, double rxPowerW, Tim	Link Here

2450

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

2514

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

2451

  if (txVector.GetNss () > GetMaxSupportedRxSpatialStreams ())

2515

  if (txVector.GetNss () > GetMaxSupportedRxSpatialStreams ())

2452

2516

2453

      NS_LOG_DEBUG ("drop packet because not enough RX antennas");

2517

      NS_LOG_DEBUG ("Packet reception could not be started because not enough RX antennas");

2454

      NotifyRxDrop (packet);

2455

      m_plcpSuccess = false;

2518

      m_plcpSuccess = false;

2456

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

2519

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

2457

2520

Lines 2564-2571 WifiPhy::StartReceivePacket (Ptr<Packet> packet,	Link Here

2564

  InterferenceHelper::SnrPer snrPer;

2627

  InterferenceHelper::SnrPer snrPer;

2565

  snrPer = m_interference.CalculatePlcpHeaderSnrPer (event);

2628

  snrPer = m_interference.CalculatePlcpHeaderSnrPer (event);

2566

2629

2567

  NS_LOG_DEBUG ("snr(dB)=" << RatioToDb (snrPer.snr) << ", per=" << snrPer.per);

2568

2569

  if (m_random->GetValue () > snrPer.per) //plcp reception succeeded

2630

  if (m_random->GetValue () > snrPer.per) //plcp reception succeeded

2570

2631

2571

      if (IsModeSupported (txMode) || IsMcsSupported (txMode))

2632

      if (IsModeSupported (txMode) || IsMcsSupported (txMode))

Lines 2582-2588 WifiPhy::StartReceivePacket (Ptr<Packet> packet,	Link Here

2582

2643

2583

  else //plcp reception failed

2644

  else //plcp reception failed

2584

2645

2585

      NS_LOG_DEBUG ("drop packet because plcp preamble/header reception failed");

2646

      NS_LOG_DEBUG ("drop packet because PHY header reception failed");

2586

      NotifyRxDrop (packet);

2647

      NotifyRxDrop (packet);

2587

      m_plcpSuccess = false;

2648

      m_plcpSuccess = false;

2588

2649

Lines 3658-3663 void	Link Here

3658

WifiPhy::AbortCurrentReception ()

3719

WifiPhy::AbortCurrentReception ()

3659

3720

3660

  NS_LOG_FUNCTION (this);

3721

  NS_LOG_FUNCTION (this);

3722

  if (m_endPreambleDetectionEvent.IsRunning ())

3723

3724

      m_endPreambleDetectionEvent.Cancel ();

3725

3661

  if (m_endPlcpRxEvent.IsRunning ())

3726

  if (m_endPlcpRxEvent.IsRunning ())

3662

3727

3663

      m_endPlcpRxEvent.Cancel ();

3728

      m_endPlcpRxEvent.Cancel ();

Lines 3721-3742 WifiPhy::StartRx (Ptr<Packet> packet, WifiTxVector txVector, MpduType mpdutype,	Link Here

3721

3786

3722

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

3787

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

3723

      m_currentEvent = event;

3788

      m_currentEvent = event;

3724

      m_state->SwitchToRx (rxDuration);

3725

      NS_ASSERT (m_endPlcpRxEvent.IsExpired ());

3726

      NotifyRxBegin (packet);

3727

      m_interference.NotifyRxStart ();

3728

3789

3729

      if (preamble != WIFI_PREAMBLE_NONE)

3790

      m_interference.NotifyRxStart (); //We need to notify it now so that it starts recording events

3791

      if (preamble == WIFI_PREAMBLE_NONE)

3730

3792

3731

          NS_ASSERT (m_endPlcpRxEvent.IsExpired ());

3793

          m_state->SwitchToRx (rxDuration);

3732

          Time preambleAndHeaderDuration = CalculatePlcpPreambleAndHeaderDuration (txVector);

3794

          NotifyRxBegin (packet);

3733

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

3795

          m_interference.NotifyRxStart ();

3734

                                                  packet, txVector, mpdutype, event);

3735

3736

3796

3737

      NS_ASSERT (m_endRxEvent.IsExpired ());

3797

          NS_ASSERT (m_endRxEvent.IsExpired ());

3738

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

3798

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

3739

                                          packet, preamble, mpdutype, event);

3799

                                              packet, txVector.GetPreambleType (), mpdutype, event);

3800

3801

      else

3802

3803

          if (!m_endPreambleDetectionEvent.IsRunning ())

3804

3805

              Time startOfPreambleDuration = GetPreambleDetectionDuration ();

3806

              Time remainingRxDuration = rxDuration - startOfPreambleDuration;

3807

              m_endPreambleDetectionEvent = Simulator::Schedule (startOfPreambleDuration, &WifiPhy::StartReceiveHeader, this,

3808

                                                                 packet, txVector, mpdutype, event, remainingRxDuration);

3809

3810

          else

3811

3812

              NS_LOG_DEBUG ("Ignore packet because RX is already decoding preamble");

3813

3814

3740

3815

3741

  else

3816

  else

3742

3817




class MobilityModel;
class WifiPhyStateHelper;
class FrameCaptureModel;
class PreambleDetectionModel;
class WifiRadioEnergyModel;
class UniformRandomVariable;


  void SetCapabilitiesChangedCallback (Callback<void> callback);

  /**
   * Starting receiving the PHY preamble of a packet (i.e. the first bit of the preamble has arrived).
   *
   * \param packet the arriving packet
   * \param rxPowerW the receive power in W
   * \param rxDuration the duration needed for the reception of the packet
   */
  void StartReceivePreamble (Ptr<Packet> packet,
                             double rxPowerW,
                             Time rxDuration);

  /**
   * Starting receiving the PHY header of a packet (i.e. after the end of receiving the preamble).
   *
   * \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 event the corresponding event of the first time the packet arrives
   */
  void StartReceiveHeader (Ptr<Packet> packet,
                           WifiTxVector txVector,
                           MpduType mpdutype,
                           Ptr<Event> event,
                           Time rxDuration);

  /**
   * Starting receiving the payload of a packet (i.e. the first bit of the packet has arrived).

  static Time CalculatePlcpPreambleAndHeaderDuration (WifiTxVector txVector);

  /**
   *
   * \return the preamble detection duration, which is the time correletion needs to detect the start of an incoming frame.
   */
  Time GetPreambleDetectionDuration (void);

  /**
   * \param txVector the transmission parameters used for this packet
   *
   * \return the training symbol duration

   */
  void SetFrameCaptureModel (const Ptr<FrameCaptureModel> frameCaptureModel);
  /**
   * Sets the preamble detection model.
   *
   * \param preambleDetectionModel the preamble detection model
   */
  void SetPreambleDetectionModel (const Ptr<PreambleDetectionModel> preambleDetectionModel);
  /**
   * Sets the wifi radio energy model.
   *
   * \param wifiRadioEnergyModel the wifi radio energy model

  uint32_t m_txMpduReferenceNumber;    //!< A-MPDU reference number to identify all transmitted subframes belonging to the same received A-MPDU
  uint32_t m_rxMpduReferenceNumber;    //!< A-MPDU reference number to identify all received subframes belonging to the same received A-MPDU

  EventId m_endRxEvent;                //!< the end of receive event
  EventId m_endPlcpRxEvent;            //!< the end of PLCP receive event
  EventId m_endPreambleDetectionEvent;   //!< the end of preamble detection event

private:
  /**


  Ptr<Event> m_currentEvent; //!< Hold the current event
  Ptr<FrameCaptureModel> m_frameCaptureModel; //!< Frame capture model
  Ptr<PreambleDetectionModel> m_preambleDetectionModel; //!< Preamble detection model
  Ptr<WifiRadioEnergyModel> m_wifiRadioEnergyModel; //!< Wifi radio energy model
  Ptr<ErrorModel> m_postReceptionErrorModel; //!< Error model for receive packet events


(-)a/src/wifi/model/yans-wifi-channel.cc (-1 / +1 lines)

Lines 125-131 void	Link Here

125

YansWifiChannel::Receive (Ptr<YansWifiPhy> phy, Ptr<Packet> packet, double rxPowerDbm, Time duration)

125

YansWifiChannel::Receive (Ptr<YansWifiPhy> phy, Ptr<Packet> packet, double rxPowerDbm, Time duration)

126

127

  NS_LOG_FUNCTION (phy << packet << rxPowerDbm << duration.GetSeconds ());

127

  NS_LOG_FUNCTION (phy << packet << rxPowerDbm << duration.GetSeconds ());

128

  phy->StartReceivePreambleAndHeader (packet, DbmToW (rxPowerDbm + phy->GetRxGain ()), duration);

128

  phy->StartReceivePreamble (packet, DbmToW (rxPowerDbm + phy->GetRxGain ()), duration);

129

130

131

std::size_t

131

std::size_t




/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2018 University of Washington
 *
 * 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 "ns3/log.h"
#include "ns3/test.h"
#include "ns3/pointer.h"
#include "ns3/spectrum-wifi-helper.h"
#include "ns3/wifi-spectrum-value-helper.h"
#include "ns3/spectrum-wifi-phy.h"
#include "ns3/nist-error-rate-model.h"
#include "ns3/wifi-mac-header.h"
#include "ns3/wifi-mac-trailer.h"
#include "ns3/wifi-phy-tag.h"
#include "ns3/wifi-spectrum-signal-parameters.h"
#include "ns3/wifi-utils.h"
#include "ns3/threshold-preamble-detection-model.h"

using namespace ns3;

NS_LOG_COMPONENT_DEFINE ("TestThresholdPreambleDetectionWithoutFrameCapture");

static const uint8_t CHANNEL_NUMBER = 36;
static const uint32_t FREQUENCY = 5180; // MHz
static const uint16_t CHANNEL_WIDTH = 20; // MHz
static const uint16_t GUARD_WIDTH = CHANNEL_WIDTH; // MHz (expanded to channel width to model spectrum mask)

/**
 * \ingroup wifi-test
 * \ingroup tests
 *
 * \brief Wifi Preamble Detection Test
 */
class TestThresholdPreambleDetectionWithoutFrameCapture : public TestCase
{
public:
  TestThresholdPreambleDetectionWithoutFrameCapture ();
  virtual ~TestThresholdPreambleDetectionWithoutFrameCapture ();

protected:
  virtual void DoSetup (void);
  Ptr<SpectrumWifiPhy> m_phy; ///< Phy
  /**
   * Send packet function
   * \param txPowerDbm the transmit power in dBm
   */
  void SendPacket (double txPowerDbm);
  /**
   * Spectrum wifi receive success function
   * \param p the packet
   * \param snr the SNR
   * \param txVector the transmit vector
   */
  void SpectrumWifiPhyRxSuccess (Ptr<Packet> p, double snr, WifiTxVector txVector);
  /**
   * Spectrum wifi receive failure function
   */
  void SpectrumWifiPhyRxFailure (void);
  uint32_t m_countRxSuccess; ///< count RX success
  uint32_t m_countRxFailure; ///< count RX failure

private:
  virtual void DoRun (void);

  /**
   * Check the PHY state
   * \param expectedState the expected PHY state
   */
  void CheckPhyState (WifiPhyState expectedState);
  /**
   * Check the number of received packets
   * \param expectedSuccessCount the number of successfully received packets
   * \param expectedFailureCount the number of unsuccessfully received packets
   */
  void CheckRxPacketCount (uint32_t expectedSuccessCount, uint32_t expectedFailureCount);
};

TestThresholdPreambleDetectionWithoutFrameCapture::TestThresholdPreambleDetectionWithoutFrameCapture ()
  : TestCase ("Threshold preamble detection model test when no frame capture model is applied"),
    m_countRxSuccess (0),
    m_countRxFailure (0)
{
}

void
TestThresholdPreambleDetectionWithoutFrameCapture::SendPacket (double txPowerDbm)
{
  WifiTxVector txVector = WifiTxVector (WifiPhy::GetHeMcs11 (), 0, WIFI_PREAMBLE_HE_SU, 800, 1, 1, 0, 20, false, false);
  MpduType mpdutype = NORMAL_MPDU;

  Ptr<Packet> pkt = Create<Packet> (1000);
  WifiMacHeader hdr;
  WifiMacTrailer trailer;

  hdr.SetType (WIFI_MAC_QOSDATA);
  hdr.SetQosTid (0);
  uint32_t size = pkt->GetSize () + hdr.GetSize () + trailer.GetSerializedSize ();
  Time txDuration = m_phy->CalculateTxDuration (size, txVector, m_phy->GetFrequency (), mpdutype, 0);
  hdr.SetDuration (txDuration);

  pkt->AddHeader (hdr);
  pkt->AddTrailer (trailer);
  WifiPhyTag tag (txVector, mpdutype, 1);
  pkt->AddPacketTag (tag);
  Ptr<SpectrumValue> txPowerSpectrum = WifiSpectrumValueHelper::CreateHeOfdmTxPowerSpectralDensity (FREQUENCY, CHANNEL_WIDTH, DbmToW (txPowerDbm), GUARD_WIDTH);
  Ptr<WifiSpectrumSignalParameters> txParams = Create<WifiSpectrumSignalParameters> ();
  txParams->psd = txPowerSpectrum;
  txParams->txPhy = 0;
  txParams->duration = txDuration;
  txParams->packet = pkt;

  m_phy->StartRx (txParams);
}

void
TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState (WifiPhyState expectedState)
{
  WifiPhyState currentState;
  PointerValue ptr;
  m_phy->GetAttribute ("State", ptr);
  Ptr <WifiPhyStateHelper> state = DynamicCast <WifiPhyStateHelper> (ptr.Get<WifiPhyStateHelper> ());
  currentState = state->GetState ();
  NS_TEST_ASSERT_MSG_EQ (currentState, expectedState, "PHY State " << currentState << " does not match expected state " << expectedState << " at " << Simulator::Now ());
}

void
TestThresholdPreambleDetectionWithoutFrameCapture::CheckRxPacketCount (uint32_t expectedSuccessCount, uint32_t expectedFailureCount)
{
  NS_TEST_ASSERT_MSG_EQ (m_countRxSuccess, expectedSuccessCount, "Didn't receive right number of successful packets");
  NS_TEST_ASSERT_MSG_EQ (m_countRxFailure, expectedFailureCount, "Didn't receive right number of unsuccessful packets");
}

void
TestThresholdPreambleDetectionWithoutFrameCapture::SpectrumWifiPhyRxSuccess (Ptr<Packet> p, double snr, WifiTxVector txVector)
{
  NS_LOG_FUNCTION (this << p << snr << txVector);
  m_countRxSuccess++;
}

void
TestThresholdPreambleDetectionWithoutFrameCapture::SpectrumWifiPhyRxFailure (void)
{
  NS_LOG_FUNCTION (this);
  m_countRxFailure++;
}

TestThresholdPreambleDetectionWithoutFrameCapture::~TestThresholdPreambleDetectionWithoutFrameCapture ()
{
}

void
TestThresholdPreambleDetectionWithoutFrameCapture::DoSetup (void)
{
  m_phy = CreateObject<SpectrumWifiPhy> ();
  m_phy->ConfigureStandard (WIFI_PHY_STANDARD_80211ax_5GHZ);
  Ptr<ErrorRateModel> error = CreateObject<NistErrorRateModel> ();
  m_phy->SetErrorRateModel (error);
  m_phy->SetChannelNumber (CHANNEL_NUMBER);
  m_phy->SetFrequency (FREQUENCY);
  m_phy->SetReceiveOkCallback (MakeCallback (&TestThresholdPreambleDetectionWithoutFrameCapture::SpectrumWifiPhyRxSuccess, this));
  m_phy->SetReceiveErrorCallback (MakeCallback (&TestThresholdPreambleDetectionWithoutFrameCapture::SpectrumWifiPhyRxFailure, this));
  m_phy->SetCcaMode1Threshold (-62.0); //to be removed once merged!

  Ptr<ThresholdPreambleDetectionModel> preambleDetectionModel = CreateObject<ThresholdPreambleDetectionModel> ();
  m_phy->SetPreambleDetectionModel (preambleDetectionModel);
}

// Test that the expected number of packet receptions occur.
void
TestThresholdPreambleDetectionWithoutFrameCapture::DoRun (void)
{
  double txPowerDbm = -30;

  //CASE 1: send one packet and check PHY state: packet reception should succeed

  Simulator::Schedule (Seconds (1.0), &TestThresholdPreambleDetectionWithoutFrameCapture::SendPacket, this, txPowerDbm);
  // At 4us, STA PHY STATE should be IDLE
  Simulator::Schedule (Seconds (1.0) + MicroSeconds (4.0), &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState, this, WifiPhyState::IDLE);
  // At 5us, STA PHY STATE should be RX
  Simulator::Schedule (Seconds (1.0) + MicroSeconds (5.0), &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState, this, WifiPhyState::RX);
  // Packet should have been successfully received
  Simulator::Schedule (Seconds (1.1), &TestThresholdPreambleDetectionWithoutFrameCapture::CheckRxPacketCount, this, 1, 0);

  //CASE 2: send two packets with same power within the 4us window and check PHY state: PHY preamble detection should fail

  Simulator::Schedule (Seconds (2.0), &TestThresholdPreambleDetectionWithoutFrameCapture::SendPacket, this, txPowerDbm);
  Simulator::Schedule (Seconds (2.0) + MicroSeconds (2.0), &TestThresholdPreambleDetectionWithoutFrameCapture::SendPacket, this, txPowerDbm);
  Simulator::Schedule (Seconds (2.0) + MicroSeconds (4.0), &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState, this, WifiPhyState::IDLE);
  Simulator::Schedule (Seconds (2.0) + MicroSeconds (5.0), &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState, this, WifiPhyState::IDLE);
  // No more packet should have been successfully received, and since preamble detection did not pass the packet should not have been counted as a failure
  Simulator::Schedule (Seconds (2.1), &TestThresholdPreambleDetectionWithoutFrameCapture::CheckRxPacketCount, this, 1, 0);

  //CASE 3: send two packets with second one 3 dB weaker within the 4us window and check PHY state: PHY preamble detection should succeed and packet reception should fail

  Simulator::Schedule (Seconds (3.0), &TestThresholdPreambleDetectionWithoutFrameCapture::SendPacket, this, txPowerDbm);
  Simulator::Schedule (Seconds (3.0) + MicroSeconds (2.0), &TestThresholdPreambleDetectionWithoutFrameCapture::SendPacket, this, txPowerDbm - 3);
  Simulator::Schedule (Seconds (3.0) + MicroSeconds (4.0), &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState, this, WifiPhyState::IDLE);
  Simulator::Schedule (Seconds (3.0) + MicroSeconds (5.0), &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState, this, WifiPhyState::RX);
  // In this case, the first packet should be marked as a failure
  Simulator::Schedule (Seconds (3.1), &TestThresholdPreambleDetectionWithoutFrameCapture::CheckRxPacketCount, this, 1, 1);

  //CASE 4: send two packets with second one 3 dB higher within the 4us window and check PHY state: PHY preamble detection should fail and no packets should enter the reception stage
  Simulator::Schedule (Seconds (4.0), &TestThresholdPreambleDetectionWithoutFrameCapture::SendPacket, this, txPowerDbm);
  Simulator::Schedule (Seconds (4.0) + MicroSeconds (2.0), &TestThresholdPreambleDetectionWithoutFrameCapture::SendPacket, this, txPowerDbm + 3);
  Simulator::Schedule (Seconds (4.0) + MicroSeconds (4.0), &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState, this, WifiPhyState::IDLE);
  Simulator::Schedule (Seconds (4.0) + MicroSeconds (5.0), &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState, this, WifiPhyState::IDLE);
  Simulator::Schedule (Seconds (4.1), &TestThresholdPreambleDetectionWithoutFrameCapture::CheckRxPacketCount, this, 1, 1);

  //CASE 5: idem but send the second packet after the 4us window: PHY preamble detection should succeed and packet reception should fail

  Simulator::Schedule (Seconds (5.0), &TestThresholdPreambleDetectionWithoutFrameCapture::SendPacket, this, txPowerDbm);
  Simulator::Schedule (Seconds (5.0) + MicroSeconds (6.0), &TestThresholdPreambleDetectionWithoutFrameCapture::SendPacket, this, txPowerDbm + 3);
  Simulator::Schedule (Seconds (5.0) + MicroSeconds (4.0), &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState, this, WifiPhyState::IDLE);
  Simulator::Schedule (Seconds (5.0) + MicroSeconds (5.0), &TestThresholdPreambleDetectionWithoutFrameCapture::CheckPhyState, this, WifiPhyState::RX);
  Simulator::Schedule (Seconds (5.1), &TestThresholdPreambleDetectionWithoutFrameCapture::CheckRxPacketCount, this, 1, 2);

  Simulator::Run ();
  Simulator::Destroy ();
}

/**
 * \ingroup wifi-test
 * \ingroup tests
 *
 * \brief Preamble Detection Test Suite
 */
class PreambleDetectionTestSuite : public TestSuite
{
public:
  PreambleDetectionTestSuite ();
};

PreambleDetectionTestSuite::PreambleDetectionTestSuite ()
  : TestSuite ("wifi-preamble-detection", UNIT)
{
  AddTestCase (new TestThresholdPreambleDetectionWithoutFrameCapture, TestCase::QUICK);
}

static PreambleDetectionTestSuite preambleDetectionTestSuite; ///< the test suite

(-)a/src/wifi/test/wifi-test.cc (-1 / +9 lines)

Lines 1025-1031 SetChannelFrequencyTest::DoRun ()	Link Here

1025

1026

1027

  Simulator::Destroy ();

1027

  Simulator::Destroy ();

1028

1029

1028

1030

1029

1031

//-----------------------------------------------------------------------------

1030

//-----------------------------------------------------------------------------

Lines 1657-1662 void	Link Here

1657

StaWifiMacScanningTestCase::DoRun (void)

1656

StaWifiMacScanningTestCase::DoRun (void)

1658

1657

1659

1658

1659

    RngSeedManager::SetSeed (1);

1660

    RngSeedManager::SetRun (1);

1661

1660

    NodeContainer nodes = Setup (false, false);

1662

    NodeContainer nodes = Setup (false, false);

1661

    Ptr<Node> nearestAp = nodes.Get (2);

1663

    Ptr<Node> nearestAp = nodes.Get (2);

1662

    Mac48Address nearestApAddr = DynamicCast<WifiNetDevice> (nearestAp->GetDevice (0))->GetMac ()->GetAddress ();

1664

    Mac48Address nearestApAddr = DynamicCast<WifiNetDevice> (nearestAp->GetDevice (0))->GetMac ()->GetAddress ();

Lines 1671-1676 StaWifiMacScanningTestCase::DoRun (void)	Link Here

1671

1673

1672

  m_associatedApBssid = Mac48Address ();

1674

  m_associatedApBssid = Mac48Address ();

1673

1675

1676

    RngSeedManager::SetSeed (1);

1677

    RngSeedManager::SetRun (1);

1678

1674

    NodeContainer nodes = Setup (true, true);

1679

    NodeContainer nodes = Setup (true, true);

1675

    Ptr<Node> nearestAp = nodes.Get (2);

1680

    Ptr<Node> nearestAp = nodes.Get (2);

1676

    Mac48Address nearestApAddr = DynamicCast<WifiNetDevice> (nearestAp->GetDevice (0))->GetMac ()->GetAddress ();

1681

    Mac48Address nearestApAddr = DynamicCast<WifiNetDevice> (nearestAp->GetDevice (0))->GetMac ()->GetAddress ();

Lines 1683-1688 StaWifiMacScanningTestCase::DoRun (void)	Link Here

1683

1688

1684

  m_associatedApBssid = Mac48Address ();

1689

  m_associatedApBssid = Mac48Address ();

1685

1690

1691

    RngSeedManager::SetSeed (1);

1692

    RngSeedManager::SetRun (1);

1693

1686

    NodeContainer nodes = Setup (true, false);

1694

    NodeContainer nodes = Setup (true, false);

1687

    Ptr<Node> nearestAp = nodes.Get (2);

1695

    Ptr<Node> nearestAp = nodes.Get (2);

1688

    Mac48Address secondNearestApAddr = DynamicCast<WifiNetDevice> (nodes.Get (1)->GetDevice (0))->GetMac ()->GetAddress ();

1696

    Mac48Address secondNearestApAddr = DynamicCast<WifiNetDevice> (nodes.Get (1)->GetDevice (0))->GetMac ()->GetAddress ();

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

Lines 85-90 def build(bld):	Link Here

        'model/he-capabilities.cc',

        'model/he-capabilities.cc',

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

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

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

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

        'model/preamble-detection-model.cc',

        'model/threshold-preamble-detection-model.cc',

        'model/he-operation.cc',

        'model/he-operation.cc',

        'model/he-configuration.cc',

        'model/he-configuration.cc',

        'model/extended-capabilities.cc',

        'model/extended-capabilities.cc',

Lines 111-116 def build(bld):	Link Here

111

        'test/wifi-aggregation-test.cc',

113

        'test/wifi-aggregation-test.cc',

112

        'test/wifi-error-rate-models-test.cc',

114

        'test/wifi-error-rate-models-test.cc',

113

        'test/wifi-transmit-mask-test.cc',

115

        'test/wifi-transmit-mask-test.cc',

116

        'test/preamble-detection-test.cc',

114

117

115

118

116

    headers = bld(features='ns3header')

119

    headers = bld(features='ns3header')

Lines 199-204 def build(bld):	Link Here

199

        'model/he-capabilities.h',

202

        'model/he-capabilities.h',

200

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

203

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

201

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

204

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

205

        'model/preamble-detection-model.h',

206

        'model/threshold-preamble-detection-model.h',

202

        'model/qos-blocked-destinations.h',

207

        'model/qos-blocked-destinations.h',

203

        'model/he-operation.h',

208

        'model/he-operation.h',

204

        'model/he-configuration.h',

209

        'model/he-configuration.h',

Return to bug 3020