Attachment #2268 for bug #2296

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

(-)a/src/wifi/model/ap-wifi-mac.cc (-14 / +36 lines)

Lines 299-308 ApWifiMac::GetSupportedRates (void) const	Link Here

299

300

  NS_LOG_FUNCTION (this);

300

  NS_LOG_FUNCTION (this);

301

  SupportedRates rates;

301

  SupportedRates rates;

302

  //If it is an HT-AP then add the BSSMembershipSelectorSet

302

  //If it is an HT-AP or VHT-AP, then add the BSSMembershipSelectorSet

303

  //which only includes 127 for HT now. The standard says that the BSSMembershipSelectorSet

303

  //The standard says that the BSSMembershipSelectorSet

304

  //must have its MSB set to 1 (must be treated as a Basic Rate)

304

  //must have its MSB set to 1 (must be treated as a Basic Rate)

305

  //Also the standard mentioned that at leat 1 element should be included in the SupportedRates the rest can be in the ExtendedSupportedRates

305

  //Also the standard mentioned that at least 1 element should be included in the SupportedRates the rest can be in the ExtendedSupportedRates

306

  if (m_htSupported || m_vhtSupported)

306

  if (m_htSupported || m_vhtSupported)

307

308

      for (uint32_t i = 0; i < m_phy->GetNBssMembershipSelectors (); i++)

308

      for (uint32_t i = 0; i < m_phy->GetNBssMembershipSelectors (); i++)

Lines 310-326 ApWifiMac::GetSupportedRates (void) const	Link Here

310

          rates.SetBasicRate (m_phy->GetBssMembershipSelector (i));

310

          rates.SetBasicRate (m_phy->GetBssMembershipSelector (i));

311

312

313

//

314

  uint8_t nss = 1;  // Number of spatial streams is 1 for non-MIMO modes

313

  //Send the set of supported rates and make sure that we indicate

315

  //Send the set of supported rates and make sure that we indicate

314

  //the Basic Rate set in this set of supported rates.

316

  //the Basic Rate set in this set of supported rates.

315

  for (uint32_t i = 0; i < m_phy->GetNModes (); i++)

317

  for (uint32_t i = 0; i < m_phy->GetNModes (); i++)

316

318

317

      WifiMode mode = m_phy->GetMode (i);

319

      WifiMode mode = m_phy->GetMode (i);

318

      rates.AddSupportedRate (mode.GetDataRate (m_phy->GetChannelWidth (), false, 1));

320

      uint64_t modeDataRate = mode.GetDataRate (m_phy->GetChannelWidth (), false, nss);

321

      NS_LOG_DEBUG ("Adding supported rate of " << modeDataRate);

322

      rates.AddSupportedRate (modeDataRate);

319

      //Add rates that are part of the BSSBasicRateSet (manufacturer dependent!)

323

      //Add rates that are part of the BSSBasicRateSet (manufacturer dependent!)

320

      //here we choose to add the mandatory rates to the BSSBasicRateSet,

324

      //here we choose to add the mandatory rates to the BSSBasicRateSet,

321

      //exept for 802.11b where we assume that only the non HR-DSSS rates are part of the BSSBasicRateSet

325

      //except for 802.11b where we assume that only the non HR-DSSS rates are part of the BSSBasicRateSet

322

      if (mode.IsMandatory () && (mode.GetModulationClass () != WIFI_MOD_CLASS_HR_DSSS))

326

      if (mode.IsMandatory () && (mode.GetModulationClass () != WIFI_MOD_CLASS_HR_DSSS))

323

327

328

          NS_LOG_DEBUG ("Adding basic mode " << mode.GetUniqueName ());

324

          m_stationManager->AddBasicMode (mode);

329

          m_stationManager->AddBasicMode (mode);

325

330

326

331

Lines 328-334 ApWifiMac::GetSupportedRates (void) const	Link Here

328

  for (uint32_t j = 0; j < m_stationManager->GetNBasicModes (); j++)

333

  for (uint32_t j = 0; j < m_stationManager->GetNBasicModes (); j++)

329

334

330

      WifiMode mode = m_stationManager->GetBasicMode (j);

335

      WifiMode mode = m_stationManager->GetBasicMode (j);

331

      rates.SetBasicRate (mode.GetDataRate (m_phy->GetChannelWidth (), false, 1));

336

      uint64_t modeDataRate = mode.GetDataRate (m_phy->GetChannelWidth (), false, nss);

337

      NS_LOG_DEBUG ("Setting basic rate " << mode.GetUniqueName ());

338

      rates.SetBasicRate (modeDataRate);

332

339

333

340

334

  return rates;

341

  return rates;

Lines 361-376 ApWifiMac::GetHtCapabilities (void) const	Link Here

361

      for (uint8_t i = 0; i < m_phy->GetNMcs (); i++)

368

      for (uint8_t i = 0; i < m_phy->GetNMcs (); i++)

362

369

363

          WifiMode mcs = m_phy->GetMcs (i);

370

          WifiMode mcs = m_phy->GetMcs (i);

371

          if (mcs.GetModulationClass () != WIFI_MOD_CLASS_HT)

372

373

              continue;

374

364

          capabilities.SetRxMcsBitmask (mcs.GetMcsValue ());

375

          capabilities.SetRxMcsBitmask (mcs.GetMcsValue ());

365

          if ((mcs.GetModulationClass () == WIFI_MOD_CLASS_HT)

376

          uint8_t nss = (mcs.GetMcsValue () / 8) + 1;

366

              && (mcs.GetDataRate (m_phy->GetChannelWidth (), m_phy->GetGuardInterval (), 1) > maxSupportedRate))

377

          NS_ASSERT (nss > 0 && nss < 4);

378

          if (mcs.GetDataRate (m_phy->GetChannelWidth (), m_phy->GetGuardInterval (), nss) > maxSupportedRate)

367

379

368

              maxSupportedRate = mcs.GetDataRate (m_phy->GetChannelWidth (), m_phy->GetGuardInterval (), 1);

380

              maxSupportedRate = mcs.GetDataRate (m_phy->GetChannelWidth (), m_phy->GetGuardInterval (), nss);

381

              NS_LOG_DEBUG ("Updating maxSupportedRate to " << maxSupportedRate);

369

382

370

383

371

      capabilities.SetRxHighestSupportedDataRate (maxSupportedRate / 1e6); //in Mbit/s

384

      capabilities.SetRxHighestSupportedDataRate (maxSupportedRate / 1e6); //in Mbit/s

372

      capabilities.SetTxMcsSetDefined (m_phy->GetNMcs () > 0);

385

      capabilities.SetTxMcsSetDefined (m_phy->GetNMcs () > 0);

373

      capabilities.SetTxMaxNSpatialStreams (m_phy->GetNumberOfTransmitAntennas ());

386

      capabilities.SetTxMaxNSpatialStreams (m_phy->GetSupportedTxSpatialStreams ());

374

387

375

  return capabilities;

388

  return capabilities;

376

389

Lines 405-412 ApWifiMac::GetVhtCapabilities (void) const	Link Here

405

              maxMcs = mcs.GetMcsValue ();

418

              maxMcs = mcs.GetMcsValue ();

406

419

407

420

408

      capabilities.SetRxMcsMap (maxMcs, 1); //Only 1 SS is currently supported

421

      // Support same MaxMCS for each spatial stream

409

      capabilities.SetTxMcsMap (maxMcs, 1); //Only 1 SS is currently supported

422

      for (uint8_t nss = 1; nss <= m_phy->GetSupportedRxSpatialStreams (); nss++)

423

424

          capabilities.SetRxMcsMap (maxMcs, nss);

425

426

      for (uint8_t nss = 1; nss <= m_phy->GetSupportedTxSpatialStreams (); nss++)

427

428

          capabilities.SetTxMcsMap (maxMcs, nss);

429

410

430

411

  return capabilities;

431

  return capabilities;

412

432

Lines 649-655 ApWifiMac::Receive (Ptr<Packet> packet, const WifiMacHeader *hdr)	Link Here

649

              for (uint32_t i = 0; i < m_stationManager->GetNBasicModes (); i++)

669

              for (uint32_t i = 0; i < m_stationManager->GetNBasicModes (); i++)

650

670

651

                  WifiMode mode = m_stationManager->GetBasicMode (i);

671

                  WifiMode mode = m_stationManager->GetBasicMode (i);

652

                  if (!rates.IsSupportedRate (mode.GetDataRate (m_phy->GetChannelWidth (), false, 1)))

672

                  uint8_t nss = 1; // Assume 1 spatial stream in basic mode

673

                  if (!rates.IsSupportedRate (mode.GetDataRate (m_phy->GetChannelWidth (), false, nss)))

653

674

654

                      problem = true;

675

                      problem = true;

655

                      break;

676

                      break;

Lines 697-703 ApWifiMac::Receive (Ptr<Packet> packet, const WifiMacHeader *hdr)	Link Here

697

                  for (uint32_t j = 0; j < m_phy->GetNModes (); j++)

718

                  for (uint32_t j = 0; j < m_phy->GetNModes (); j++)

698

719

699

                      WifiMode mode = m_phy->GetMode (j);

720

                      WifiMode mode = m_phy->GetMode (j);

700

                      if (rates.IsSupportedRate (mode.GetDataRate (m_phy->GetChannelWidth (), false, 1)))

721

                      uint8_t nss = 1; // Assume 1 spatial stream in basic mode

722

                      if (rates.IsSupportedRate (mode.GetDataRate (m_phy->GetChannelWidth (), false, nss)))

701

723

702

                          m_stationManager->AddSupportedMode (from, mode);

724

                          m_stationManager->AddSupportedMode (from, mode);

703

725




}

double
ErrorRateModel::CalculateSnr (WifiTxVector txVector, double ber) const
{
  //This is a very simple binary search.
  double low, high, precision;
  low = 1e-25;
  high = 1e25;
  precision = 1e-12;
  WifiTxVector txVector;
  txVector.SetMode (txMode);
  while (high - low > precision)
    {
      NS_ASSERT (high >= low);
      double middle = low + (high - low) / 2;
      if ((1 - GetChunkSuccessRate (txVector.GetMode (), txVector, middle, 1)) > ber)
        {
          low = middle;
        }




  static TypeId GetTypeId (void);

  /**
   * \param txVector a specific transmission vector including WifiMode
   * \param ber a target ber
   *
   * \return the snr which corresponds to the requested ber
   */
  double CalculateSnr (WifiTxVector txVector, double ber) const;

  /**
   * A pure virtual method that must be implemented in the subclass.

   * The probability of successfully receiving the chunk depends on
   * the mode, the SNR, and the size of the chunk.
   *
   * Note that both a WifiMode and a WifiTxVector (which contains a WifiMode)
   * are passed into this method.  The WifiTxVector may be from a signal that
   * contains multiple modes (e.g. PLCP header sent differently from PLCP
   * payload).  Consequently, the mode parameter is what the method uses
   * to calculate the chunk error rate, and the txVector is used for 
   * other information as needed.
   *
   * \param mode the Wi-Fi mode applicable to this chunk
   * \param txvector TXVECTOR of the overall transmission
   * \param snr the SNR of the chunk
   * \param nbits the number of bits in this chunk
   *

(-)a/src/wifi/model/ideal-wifi-manager.cc (-1 / +2 lines)

Lines 72-78 IdealWifiManager::SetupPhy (Ptr<WifiPhy> phy)	Link Here

  for (uint32_t i = 0; i < nModes; i++)

  for (uint32_t i = 0; i < nModes; i++)

      WifiMode mode = phy->GetMode (i);

      WifiMode mode = phy->GetMode (i);

      AddModeSnrThreshold (mode, phy->CalculateSnr (mode, m_ber));

      WifiTxVector txVector (mode, 0, 0, false, 1, 1, 20, false, false);

      AddModeSnrThreshold (mode, phy->CalculateSnr (txVector, m_ber));

  WifiRemoteStationManager::SetupPhy (phy);

  WifiRemoteStationManager::SetupPhy (phy);

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

Lines 273-279 InterferenceHelper::CalculateChunkSuccessRate (double snir, Time duration, WifiM	Link Here

273

274

      return 1.0;

274

      return 1.0;

275

276

  uint32_t rate = mode.GetPhyRate (txVector.GetChannelWidth (), txVector.IsShortGuardInterval (), 1);

276

  uint32_t rate = mode.GetPhyRate (txVector);

277

  uint64_t nbits = (uint64_t)(rate * duration.GetSeconds ());

277

  uint64_t nbits = (uint64_t)(rate * duration.GetSeconds ());

278

  double csr = m_errorRateModel->GetChunkSuccessRate (mode, txVector, snir, (uint32_t)nbits);

278

  double csr = m_errorRateModel->GetChunkSuccessRate (mode, txVector, snir, (uint32_t)nbits);

279

  return csr;

279

  return csr;




NistErrorRateModel::GetChunkSuccessRate (WifiMode mode, WifiTxVector txVector, double snr, uint32_t nbits) const
{
  NS_LOG_FUNCTION (this << mode << txVector.GetMode () << snr << nbits);
  uint8_t nss = txVector.GetNss ();
  if (mode.GetModulationClass () == WIFI_MOD_CLASS_ERP_OFDM
      || mode.GetModulationClass () == WIFI_MOD_CLASS_OFDM
      || mode.GetModulationClass () == WIFI_MOD_CLASS_HT
      || mode.GetModulationClass () == WIFI_MOD_CLASS_VHT)
    {
      if (mode.GetConstellationSize (nss) == 2)
        {
          if (mode.GetCodeRate (nss) == WIFI_CODE_RATE_1_2)
            {
              return GetFecBpskBer (snr,
                                    nbits,

                                    3); //b value
            }
        }
      else if (mode.GetConstellationSize (nss) == 4)
        {
          if (mode.GetCodeRate (nss) == WIFI_CODE_RATE_1_2)
            {
              return GetFecQpskBer (snr,
                                    nbits,

                                    3); //b value
            }
        }
      else if (mode.GetConstellationSize (nss) == 16)
        {
          if (mode.GetCodeRate (nss) == WIFI_CODE_RATE_1_2)
            {
              return GetFec16QamBer (snr,
                                     nbits,

                                     3); //b value
            }
        }
      else if (mode.GetConstellationSize (nss) == 64)
        {
          if (mode.GetCodeRate (nss) == WIFI_CODE_RATE_2_3)
            {
              return GetFec64QamBer (snr,
                                     nbits,
                                     2); //b value
            }
          else if (mode.GetCodeRate (nss) == WIFI_CODE_RATE_5_6)
            {
              return GetFec64QamBer (snr,
                                     nbits,

                                     3); //b value
            }
        }
      else if (mode.GetConstellationSize (nss) == 256)
        {
          if (mode.GetCodeRate (nss) == WIFI_CODE_RATE_5_6)
            {
              return GetFec256QamBer (snr,
                                      nbits,

(-)a/src/wifi/model/rraa-wifi-manager.cc (-1 / +2 lines)

Lines 394-400 RraaWifiManager::GetThresholds (RraaWifiRemoteStation *station,	Link Here

394

struct RraaWifiManager::ThresholdsItem

394

struct RraaWifiManager::ThresholdsItem

395

RraaWifiManager::GetThresholds (WifiMode mode, RraaWifiRemoteStation *station) const

395

RraaWifiManager::GetThresholds (WifiMode mode, RraaWifiRemoteStation *station) const

396

397

  switch (mode.GetDataRate (GetChannelWidth (station), GetShortGuardInterval (station), 1) / 1000000)

397

  uint8_t nss = 1;  // This RAA only supports 1 spatial stream

398

  switch (mode.GetDataRate (GetChannelWidth (station), GetShortGuardInterval (station), nss) / 1000000)

398

399

    case 54:

400

    case 54:

400

401




          for (uint32_t i = 0; i < m_phy->GetNModes (); i++)
            {
              WifiMode mode = m_phy->GetMode (i);
              uint8_t nss = 1; // Assume 1 spatial stream
              if (rates.IsSupportedRate (mode.GetDataRate (m_phy->GetChannelWidth (), false, nss)))
                {
                  m_stationManager->AddSupportedMode (hdr->GetAddr2 (), mode);
                  if (rates.IsBasicRate (mode.GetDataRate (m_phy->GetChannelWidth (), false, nss)))
                    {
                      m_stationManager->AddBasicMode (mode);
                    }

              for (uint32_t i = 0; i < m_phy->GetNModes (); i++)
                {
                  WifiMode mode = m_phy->GetMode (i);
                  uint8_t nss = 1; // Assume 1 spatial stream
                  if (rates.IsSupportedRate (mode.GetDataRate (m_phy->GetChannelWidth (), false, nss)))
                    {
                      m_stationManager->AddSupportedMode (hdr->GetAddr2 (), mode);
                      if (rates.IsBasicRate (mode.GetDataRate (m_phy->GetChannelWidth (), false, nss)))
                        {
                          m_stationManager->AddBasicMode (mode);
                        }

StaWifiMac::GetSupportedRates (void) const
{
  SupportedRates rates;
  uint8_t nss = 1;  // Number of spatial streams is 1 for non-MIMO modes
  if (m_htSupported || m_vhtSupported)
    {
      for (uint32_t i = 0; i < m_phy->GetNBssMembershipSelectors (); i++)

  for (uint32_t i = 0; i < m_phy->GetNModes (); i++)
    {
      WifiMode mode = m_phy->GetMode (i);
      uint64_t modeDataRate = mode.GetDataRate (m_phy->GetChannelWidth (), false, nss);
      NS_LOG_DEBUG ("Adding supported rate of " << modeDataRate);
      rates.AddSupportedRate (modeDataRate);
    }
  return rates;
}

      for (uint8_t i = 0; i < m_phy->GetNMcs (); i++)
        {
          WifiMode mcs = m_phy->GetMcs (i);
          if (mcs.GetModulationClass () != WIFI_MOD_CLASS_HT)
            {
              continue;
            }
          capabilities.SetRxMcsBitmask (mcs.GetMcsValue ());
          uint8_t nss = (mcs.GetMcsValue () / 8) + 1;
          NS_ASSERT (nss > 0 && nss < 4);
          if (mcs.GetDataRate (m_phy->GetChannelWidth (), m_phy->GetGuardInterval (), nss) > maxSupportedRate)
            {
              maxSupportedRate = mcs.GetDataRate (m_phy->GetChannelWidth (), m_phy->GetGuardInterval (), nss);
              NS_LOG_DEBUG ("Updating maxSupportedRate to " << maxSupportedRate);
            }
        }
      capabilities.SetRxHighestSupportedDataRate (maxSupportedRate / 1e6); //in Mbit/s
      capabilities.SetTxMcsSetDefined (m_phy->GetNMcs () > 0);
      capabilities.SetTxMaxNSpatialStreams (m_phy->GetSupportedTxSpatialStreams ());
    }
  return capabilities;
}

              maxMcs = mcs.GetMcsValue ();
            }
        }
      // Support same MaxMCS for each spatial stream
      for (uint8_t nss = 1; nss <= m_phy->GetSupportedRxSpatialStreams (); nss++)
        {
          capabilities.SetRxMcsMap (maxMcs, nss);
        }
      for (uint8_t nss = 1; nss <= m_phy->GetSupportedTxSpatialStreams (); nss++)
        {
          capabilities.SetTxMcsMap (maxMcs, nss);
        }
    }
  return capabilities;
}

(-)a/src/wifi/model/vht-capabilities.h (-1 / +23 lines)

Lines 90-99 public:	Link Here

  uint8_t GetTxStbc () const;

  uint8_t GetTxStbc () const;

  uint8_t GetMaxAmpduLengthExponent () const;

  uint8_t GetMaxAmpduLengthExponent () const;

  //MCS and NSS field information

  // MCS and NSS field information

  // For each value of NSS ranging from 1 to 8, we need to encode two bits.

  // The value 0 indicates that the maximum MCS for that spatial stream is 7.

  // The value 1 indicates that the maximum MCS for that spatial stream is 8.

  // The value 2 indicates that the maximum MCS for that spatial stream is 9.

//

  // The maps may be set all at once by passing in a 16-bit field corresponding

100

  // to the above, or incrementally for each NSS separately, where the

101

  // MCS value must be in the range 7-9.

102

/**

103

   * \param map The 16-bit encoding of Max MCS for each of 8 spatial streams

104

*/

  void SetRxMcsMap (uint16_t map);

105

  void SetRxMcsMap (uint16_t map);

106

/**

107

   * \param mcs Max MCS value (between 7 and 9)

108

   * \param nss Spatial stream for which the Max MCS value is being set

109

*/

  void SetRxMcsMap (uint8_t mcs, uint8_t nss);

110

  void SetRxMcsMap (uint8_t mcs, uint8_t nss);

111

/**

112

   * \param map The 16-bit encoding of Max MCS for each of 8 spatial streams

113

*/

  void SetTxMcsMap (uint16_t map);

114

  void SetTxMcsMap (uint16_t map);

115

/**

116

   * \param mcs Max MCS value (between 7 and 9)

117

   * \param nss Spatial stream for which the Max MCS value is being set

118

*/

  void SetTxMcsMap (uint8_t mcs, uint8_t nss);

119

  void SetTxMcsMap (uint8_t mcs, uint8_t nss);

  void SetRxHighestSupportedLgiDataRate (uint16_t supporteddatarate);

120

  void SetRxHighestSupportedLgiDataRate (uint16_t supporteddatarate);

  void SetTxHighestSupportedLgiDataRate (uint16_t supporteddatarate);

121

  void SetTxHighestSupportedLgiDataRate (uint16_t supporteddatarate);

(-)a/src/wifi/model/wifi-mode.cc (-9 / +22 lines)

Lines 20-25	Link Here

*/

*/

#include "wifi-mode.h"

#include "wifi-mode.h"

#include "wifi-tx-vector.h"

#include "ns3/simulator.h"

#include "ns3/simulator.h"

#include "ns3/assert.h"

#include "ns3/assert.h"

#include "ns3/log.h"

#include "ns3/log.h"

Lines 97-102 WifiMode::GetPhyRate (uint32_t channelWidth, bool isShortGuardInterval, uint8_t	Link Here

uint64_t

100

uint64_t

101

WifiMode::GetPhyRate (WifiTxVector txVector) const

102

103

  return GetPhyRate (txVector.GetChannelWidth (), txVector.IsShortGuardInterval (), txVector.GetNss ());

104

105

106

uint64_t

100

WifiMode::GetDataRate (uint32_t channelWidth, bool isShortGuardInterval, uint8_t nss) const

107

WifiMode::GetDataRate (uint32_t channelWidth, bool isShortGuardInterval, uint8_t nss) const

101

108

102

  struct WifiModeFactory::WifiModeItem *item = WifiModeFactory::GetFactory ()->Get (m_uid);

109

  struct WifiModeFactory::WifiModeItem *item = WifiModeFactory::GetFactory ()->Get (m_uid);

Lines 108-118 WifiMode::GetDataRate (uint32_t channelWidth, bool isShortGuardInterval, uint8_t	Link Here

108

115

109

  if (item->modClass == WIFI_MOD_CLASS_DSSS)

116

  if (item->modClass == WIFI_MOD_CLASS_DSSS)

110

117

111

      dataRate = (11000000 / 11) * log2 (GetConstellationSize (1));

118

      dataRate = (11000000 / 11) * log2 (GetConstellationSize (nss));

112

119

113

  else if (item->modClass == WIFI_MOD_CLASS_HR_DSSS)

120

  else if (item->modClass == WIFI_MOD_CLASS_HR_DSSS)

114

121

115

      dataRate = (11000000 / 8) * log2 (GetConstellationSize (1));

122

      dataRate = (11000000 / 8) * log2 (GetConstellationSize (nss));

116

123

117

  else if (item->modClass == WIFI_MOD_CLASS_OFDM || item->modClass == WIFI_MOD_CLASS_ERP_OFDM)

124

  else if (item->modClass == WIFI_MOD_CLASS_OFDM || item->modClass == WIFI_MOD_CLASS_ERP_OFDM)

118

125

Lines 134-140 WifiMode::GetDataRate (uint32_t channelWidth, bool isShortGuardInterval, uint8_t	Link Here

134

141

135

142

136

      double codingRate;

143

      double codingRate;

137

      switch (GetCodeRate (1))

144

      switch (GetCodeRate (nss))

138

145

139

        case WIFI_CODE_RATE_3_4:

146

        case WIFI_CODE_RATE_3_4:

140

          codingRate = (3.0 / 4.0);

147

          codingRate = (3.0 / 4.0);

Lines 151-163 WifiMode::GetDataRate (uint32_t channelWidth, bool isShortGuardInterval, uint8_t	Link Here

151

          break;

158

          break;

152

159

153

160

154

      uint32_t numberOfBitsPerSubcarrier = log2 (GetConstellationSize (1));

161

      uint32_t numberOfBitsPerSubcarrier = log2 (GetConstellationSize (nss));

155

162

156

      dataRate = lrint (ceil (symbolRate * usableSubCarriers * numberOfBitsPerSubcarrier * codingRate));

163

      dataRate = lrint (ceil (symbolRate * usableSubCarriers * numberOfBitsPerSubcarrier * codingRate));

157

164

158

  else if (item->modClass == WIFI_MOD_CLASS_HT || item->modClass == WIFI_MOD_CLASS_VHT)

165

  else if (item->modClass == WIFI_MOD_CLASS_HT || item->modClass == WIFI_MOD_CLASS_VHT)

159

166

160

      if (item->mcsValue == 9)

167

      if (item->modClass == WIFI_MOD_CLASS_VHT && item->mcsValue == 9)

161

168

162

          //VHT MCS 9 forbidden at 20 MHz

169

          //VHT MCS 9 forbidden at 20 MHz

163

          NS_ASSERT (channelWidth != 20);

170

          NS_ASSERT (channelWidth != 20);

Lines 208-214 WifiMode::GetDataRate (uint32_t channelWidth, bool isShortGuardInterval, uint8_t	Link Here

208

          break;

215

          break;

209

        case WIFI_CODE_RATE_UNDEFINED:

216

        case WIFI_CODE_RATE_UNDEFINED:

210

        default:

217

        default:

211

          NS_FATAL_ERROR ("trying to get datarate for a mcs without any coding rate defined");

218

          NS_FATAL_ERROR ("trying to get datarate for a mcs without any coding rate defined with nss: " << (uint16_t) nss);

212

          break;

219

          break;

213

220

214

221

Lines 220-228 WifiMode::GetDataRate (uint32_t channelWidth, bool isShortGuardInterval, uint8_t	Link Here

220

227

221

      NS_ASSERT ("undefined datarate for the modulation class!");

228

      NS_ASSERT ("undefined datarate for the modulation class!");

222

229

230

  dataRate *= nss; // number of spatial streams

223

  return dataRate;

231

  return dataRate;

224

232

225

233

234

uint64_t

235

WifiMode::GetDataRate (WifiTxVector txVector) const

236

237

  return GetDataRate (txVector.GetChannelWidth (), txVector.IsShortGuardInterval (), txVector.GetNss ());

238

239

226

enum WifiCodeRate

240

enum WifiCodeRate

227

WifiMode::GetCodeRate (uint8_t nss) const

241

WifiMode::GetCodeRate (uint8_t nss) const

228

242

Lines 230-237 WifiMode::GetCodeRate (uint8_t nss) const	Link Here

230

  if (item->modClass == WIFI_MOD_CLASS_HT)

244

  if (item->modClass == WIFI_MOD_CLASS_HT)

231

245

232

      NS_ASSERT (nss <= 4);

246

      NS_ASSERT (nss <= 4);

233

      NS_ASSERT ((item->mcsValue - (8 * (nss - 1))) >= 0 || (item->mcsValue - (8 * (nss - 1))) <= 7);

247

      switch (item->mcsValue % 8)

234

      switch (item->mcsValue - (8 * (nss - 1)))

235

248

236

        case 0:

249

        case 0:

237

        case 1:

250

        case 1:

Lines 286-292 WifiMode::GetConstellationSize (uint8_t nss) const	Link Here

286

299

287

      NS_ASSERT (nss <= 4);

300

      NS_ASSERT (nss <= 4);

288

      NS_ASSERT ((item->mcsValue - (8 * (nss - 1))) >= 0 || (item->mcsValue - (8 * (nss - 1))) <= 7);

301

      NS_ASSERT ((item->mcsValue - (8 * (nss - 1))) >= 0 || (item->mcsValue - (8 * (nss - 1))) <= 7);

289

      switch (item->mcsValue - (8 * (nss - 1)))

302

      switch (item->mcsValue % 8)

290

303

291

        case 0:

304

        case 0:

292

          return 2;

305

          return 2;

(-)a/src/wifi/model/wifi-mode.h (+17 lines)

Lines 31-36	Link Here

namespace ns3 {

namespace ns3 {

class WifiTxVector;

/**

/**

 * This enumeration defines the modulation classes per

 * This enumeration defines the modulation classes per

 * (Table 9-4 "Modulation classes"; IEEE 802.11-2012).

 * (Table 9-4 "Modulation classes"; IEEE 802.11-2012).

Lines 110-115 public:	Link Here

110

*/

112

*/

111

  uint64_t GetPhyRate (uint32_t channelWidth, bool isShortGuardInterval, uint8_t nss) const;

113

  uint64_t GetPhyRate (uint32_t channelWidth, bool isShortGuardInterval, uint8_t nss) const;

112

/**

114

/**

115

   * \param txVector the WifiTxVector of the signal

116

117

   * \returns the physical bit rate of this signal.

118

119

   * If a transmission mode uses 1/2 FEC, and if its

120

   * data rate is 3.25Mbps, the phy rate is 6.5Mbps

121

*/

122

  uint64_t GetPhyRate (WifiTxVector txVector) const;

123

/**

113

124

114

   * \param channelWidth the considered channel width in MHz

125

   * \param channelWidth the considered channel width in MHz

115

   * \param isShortGuardInterval whether short guard interval is considered or not

126

   * \param isShortGuardInterval whether short guard interval is considered or not

Lines 119-124 public:	Link Here

119

*/

130

*/

120

  uint64_t GetDataRate (uint32_t channelWidth, bool isShortGuardInterval, uint8_t nss) const;

131

  uint64_t GetDataRate (uint32_t channelWidth, bool isShortGuardInterval, uint8_t nss) const;

121

/**

132

/**

133

   * \param txVector the WifiTxVector of the signal

134

135

   * \returns the data bit rate of this signal.

136

*/

137

  uint64_t GetDataRate (WifiTxVector txVector) const;

138

/**

122

139

123

   * \param nss the considered number of streams

140

   * \param nss the considered number of streams

124

141




  virtual bool IsModeSupported (WifiMode mode) const = 0;

  /**
   * \param txVector the transmission vector
   * \param ber the probability of bit error rate
   *
   * \return the minimum snr which is required to achieve
   *          the requested ber for the specified transmission vector. (W/W)
   */
  virtual double CalculateSnr (WifiTxVector txVector, double ber) const = 0;

  /**
  * The WifiPhy::NBssMembershipSelectors() method is used

   * \param channelwidth channel width
   */
  virtual void SetChannelWidth (uint32_t channelwidth) = 0;
  /**
   * \return the maximum number of supported Rx spatial streams
   */
  virtual uint8_t GetSupportedRxSpatialStreams (void) const = 0;
  /**
   * \return the maximum number of supported Tx spatial streams
   */
  virtual uint8_t GetSupportedTxSpatialStreams (void) const = 0;
  /**
   * \param width channel width (in MHz) to support
   */
  virtual void AddSupportedChannelWidth (uint32_t width) = 0;
  /**
   * \return a vector containing the supported channel widths, values in MHz
   */
  virtual std::vector<uint32_t> GetSupportedChannelWidthSet (void) const = 0;

private:
  /**




  NS_LOG_FUNCTION (this << address << reqMode);
  WifiMode mode = GetDefaultMode ();
  bool found = false;
  uint8_t nss = 1;  // Use one spatial stream for control response
  //First, search the BSS Basic Rate set
  for (WifiModeListIterator i = m_bssBasicRateSet.begin (); i != m_bssBasicRateSet.end (); i++)
    {
      if ((!found || i->GetPhyRate (m_wifiPhy->GetChannelWidth (), 0, nss) > mode.GetPhyRate (m_wifiPhy->GetChannelWidth (), 0, nss))
          && (i->GetPhyRate (m_wifiPhy->GetChannelWidth (), 0, nss) <= reqMode.GetPhyRate (m_wifiPhy->GetChannelWidth (), 0, nss))
          && (i->GetConstellationSize (nss) <= reqMode.GetConstellationSize (nss))
          && ((i->GetModulationClass () == reqMode.GetModulationClass ())
              || (reqMode.GetModulationClass () == WIFI_MOD_CLASS_HT)
              || (reqMode.GetModulationClass () == WIFI_MOD_CLASS_VHT)))

          found = true;
        }
    }
  nss = 1;  // Continue the assumption that MIMO not used for control response
  if (HasHtSupported () || HasVhtSupported ())
    {
      if (!found)

          mode = GetDefaultMcs ();
          for (WifiModeListIterator i = m_bssBasicMcsSet.begin (); i != m_bssBasicMcsSet.end (); i++)
            {
              if ((!found || i->GetPhyRate (m_wifiPhy->GetChannelWidth (), 0, nss) > mode.GetPhyRate (m_wifiPhy->GetChannelWidth (), 0, nss))
                  && i->GetPhyRate (m_wifiPhy->GetChannelWidth (), 0, nss) <= reqMode.GetPhyRate (m_wifiPhy->GetChannelWidth (), 0, nss))
              //&& thismode.GetModulationClass () == reqMode.GetModulationClass ()) //TODO: check standard
                {
                  mode = *i;

   * \todo Note that we're ignoring the last sentence for now, because
   * there is not yet any manipulation here of PHY options.
   */
  nss = 1;  // Continue the assumption that MIMO not used for control response
  for (uint32_t idx = 0; idx < m_wifiPhy->GetNModes (); idx++)
    {
      WifiMode thismode = m_wifiPhy->GetMode (idx);

       * ...then it's our best choice so far.
       */
      if (thismode.IsMandatory ()
          && (!found || thismode.GetPhyRate (m_wifiPhy->GetChannelWidth (), 0, nss) > mode.GetPhyRate (m_wifiPhy->GetChannelWidth (), 0, nss))
          && (thismode.GetPhyRate (m_wifiPhy->GetChannelWidth (), 0, nss) <= reqMode.GetPhyRate (m_wifiPhy->GetChannelWidth (), 0, nss))
          && (thismode.GetConstellationSize (nss) <= reqMode.GetConstellationSize (nss))
          && ((thismode.GetModulationClass () == reqMode.GetModulationClass ())
              || (reqMode.GetModulationClass () == WIFI_MOD_CLASS_HT)
              || (reqMode.GetModulationClass () == WIFI_MOD_CLASS_HT)))

          found = true;
        }
    }
  nss = 1;  // Continue the assumption that MIMO not used for control response
  if (HasHtSupported () || HasVhtSupported ())
    {
      for (uint32_t idx = 0; idx < m_wifiPhy->GetNMcs (); idx++)
        {
          WifiMode thismode = m_wifiPhy->GetMcs (idx);
          if (thismode.IsMandatory ()
              && (!found || thismode.GetPhyRate (m_wifiPhy->GetChannelWidth (), 0, nss) > mode.GetPhyRate (m_wifiPhy->GetChannelWidth (), 0, nss))
              && thismode.GetPhyRate (m_wifiPhy->GetChannelWidth (), 0, nss) <= reqMode.GetPhyRate (m_wifiPhy->GetChannelWidth (), 0, nss))
              //&& thismode.GetModulationClass () == reqMode.GetModulationClass ()) //TODO: check standard
            {
              mode = thismode;

  state->m_shortGuardInterval = m_wifiPhy->GetGuardInterval ();
  state->m_greenfield = m_wifiPhy->GetGreenfield ();
  state->m_shortPreamble = m_wifiPhy->GetShortPlcpPreamble ();
  state->m_rx = 1;
  state->m_tx = 1;
  state->m_ness = 0;
  state->m_aggregation = false;
  state->m_stbc = false;

}

uint32_t
WifiRemoteStationManager::GetNumberOfReceiveAntennas (const WifiRemoteStation *station) const
{
  return station->m_state->m_rx;
}

uint32_t
WifiRemoteStationManager::GetNumberOfTransmitAntennas (const WifiRemoteStation *station) const
{
  return station->m_state->m_tx;
}

uint32_t
WifiRemoteStationManager::GetNess (const WifiRemoteStation *station) const
{
  return station->m_state->m_ness;




   */
  bool GetShortPreamble (const WifiRemoteStation *station) const;
  /**
   * Return the number of receive antennas the station has.
   *
   * \param station the station being queried
   *
   * \return the number of receive antennas the station has
   */
  uint32_t GetNumberOfReceiveAntennas (const WifiRemoteStation *station) const;
  /**
   * Return the number of transmit antennas the station has.
   *
   * \param station the station being queried
   *
   * \return the number of transmit antennas the station has
   */
  uint32_t GetNumberOfTransmitAntennas (const WifiRemoteStation *station) const;
  /**
   * \returns the number of Ness the station has.
   *
   * \param station the station being queried


  uint32_t m_channelWidth;    //!< Channel width (in MHz) supported by the remote station
  bool m_shortGuardInterval;  //!< Flag if short guard interval is supported by the remote station
  uint32_t m_rx;              //!< Number of RX antennas of the remote station
  uint32_t m_tx;              //!< Number of TX antennas of the remote station
  uint32_t m_ness;            //!< Number of streams in beamforming of the remote station
  bool m_stbc;                //!< Flag if STBC is used by the remote station
  bool m_aggregation;         //!< Flag if MPDU aggregation is used by the remote station




YansErrorRateModel::GetChunkSuccessRate (WifiMode mode, WifiTxVector txVector, double snr, uint32_t nbits) const
{
  NS_LOG_FUNCTION (this << mode << txVector.GetMode () << snr << nbits);
  uint8_t nss = txVector.GetNss ();
  if (mode.GetModulationClass () == WIFI_MOD_CLASS_ERP_OFDM
      || mode.GetModulationClass () == WIFI_MOD_CLASS_OFDM
      || mode.GetModulationClass () == WIFI_MOD_CLASS_HT
      || mode.GetModulationClass () == WIFI_MOD_CLASS_VHT)
    {
      if (mode.GetConstellationSize (nss) == 2)
        {
          if (mode.GetCodeRate (nss) == WIFI_CODE_RATE_1_2)
            {
              return GetFecBpskBer (snr,
                                    nbits,
                                    txVector.GetChannelWidth () * 1000000, //signal spread
                                    mode.GetPhyRate (txVector), //phy rate
                                    10, //dFree
                                    11); //adFree
            }

              return GetFecBpskBer (snr,
                                    nbits,
                                    txVector.GetChannelWidth () * 1000000, //signal spread
                                    mode.GetPhyRate (txVector), //phy rate
                                    5, //dFree
                                    8); //adFree
            }
        }
      else if (mode.GetConstellationSize (nss) == 4)
        {
          if (mode.GetCodeRate (nss) == WIFI_CODE_RATE_1_2)
            {
              return GetFecQamBer (snr,
                                   nbits,
                                   txVector.GetChannelWidth () * 1000000, //signal spread
                                   mode.GetPhyRate (txVector), //phy rate
                                   4, //m
                                   10, //dFree
                                   11, //adFree

              return GetFecQamBer (snr,
                                   nbits,
                                   txVector.GetChannelWidth () * 1000000, //signal spread
                                   mode.GetPhyRate (txVector), //phy rate
                                   4, //m
                                   5, //dFree
                                   8, //adFree
                                   31); //adFreePlusOne
            }
        }
      else if (mode.GetConstellationSize (nss) == 16)
        {
          if (mode.GetCodeRate (nss) == WIFI_CODE_RATE_1_2)
            {
              return GetFecQamBer (snr,
                                   nbits,
                                   txVector.GetChannelWidth () * 1000000, //signal spread
                                   mode.GetPhyRate (txVector), //phy rate
                                   16, //m
                                   10, //dFree
                                   11, //adFree

              return GetFecQamBer (snr,
                                   nbits,
                                   txVector.GetChannelWidth () * 1000000, //signal spread
                                   mode.GetPhyRate (txVector), //phy rate
                                   16, //m
                                   5, //dFree
                                   8, //adFree
                                   31); //adFreePlusOne
            }
        }
      else if (mode.GetConstellationSize (nss) == 64)
        {
          if (mode.GetCodeRate (nss) == WIFI_CODE_RATE_2_3)
            {
              return GetFecQamBer (snr,
                                   nbits,
                                   txVector.GetChannelWidth () * 1000000, //signal spread
                                   mode.GetPhyRate (txVector), //phy rate
                                   64, //m
                                   6, //dFree
                                   1, //adFree
                                   16); //adFreePlusOne
            }
          if (mode.GetCodeRate (nss) == WIFI_CODE_RATE_5_6)
            {
              //Table B.32  in Pâl Frenger et al., "Multi-rate Convolutional Codes".
              return GetFecQamBer (snr,
                                   nbits,
                                   txVector.GetChannelWidth () * 1000000, //signal spread
                                   mode.GetPhyRate (txVector), //phy rate
                                   64, //m
                                   4, //dFree
                                   14, //adFree

              return GetFecQamBer (snr,
                                   nbits,
                                   txVector.GetChannelWidth () * 1000000, //signal spread
                                   mode.GetPhyRate (txVector), //phy rate
                                   64, //m
                                   5, //dFree
                                   8, //adFree
                                   31); //adFreePlusOne
            }
        }
      else if (mode.GetConstellationSize (nss) == 256)
        {
          if (mode.GetCodeRate (nss) == WIFI_CODE_RATE_5_6)
            {
              return GetFecQamBer (snr,
                                   nbits,
                                   txVector.GetChannelWidth () * 1000000, // signal spread
                                   mode.GetPhyRate (txVector), //phy rate
                                   256, // m
                                   4,  // dFree
                                   14,  // adFree

              return GetFecQamBer (snr,
                                   nbits,
                                   txVector.GetChannelWidth () * 1000000, // signal spread
                                   mode.GetPhyRate (txVector), //phy rate
                                   256, // m
                                   5,  // dFree
                                   8,  // adFree

(-)a/src/wifi/model/yans-wifi-phy.cc (-4 / +39 lines)

Lines 406-414 YansWifiPhy::GetMobility (void)	Link Here

406

407

408

double

408

double

409

YansWifiPhy::CalculateSnr (WifiMode txMode, double ber) const

409

YansWifiPhy::CalculateSnr (WifiTxVector txVector, double ber) const

410

411

  return m_interference.GetErrorRateModel ()->CalculateSnr (txMode, ber);

411

  return m_interference.GetErrorRateModel ()->CalculateSnr (txVector, ber);

412

413

414

Ptr<WifiChannel>

414

Ptr<WifiChannel>

Lines 775-781 YansWifiPhy::SendPacket (Ptr<const Packet> packet, WifiTxVector txVector, WifiPr	Link Here

775

void

775

void

776

YansWifiPhy::SendPacket (Ptr<const Packet> packet, WifiTxVector txVector, WifiPreamble preamble, enum mpduType mpdutype)

776

YansWifiPhy::SendPacket (Ptr<const Packet> packet, WifiTxVector txVector, WifiPreamble preamble, enum mpduType mpdutype)

777

778

  NS_LOG_FUNCTION (this << packet << txVector.GetMode () << txVector.GetMode ().GetDataRate (txVector.GetChannelWidth (), txVector.IsShortGuardInterval (), 1) << preamble << (uint32_t)txVector.GetTxPowerLevel () << (uint32_t)mpdutype);

778

  NS_LOG_FUNCTION (this << packet << txVector.GetMode ()

779

    << txVector.GetMode ().GetDataRate (txVector)

780

    << preamble << (uint32_t)txVector.GetTxPowerLevel () << (uint32_t)mpdutype);

779

  /* Transmission can happen if:

781

  /* Transmission can happen if:

780

   *  - we are syncing on a packet. It is the responsability of the

782

   *  - we are syncing on a packet. It is the responsability of the

781

   *    MAC layer to avoid doing this but the PHY does nothing to

783

   *    MAC layer to avoid doing this but the PHY does nothing to

Lines 1168-1174 YansWifiPhy::EndReceive (Ptr<Packet> packet, enum WifiPreamble preamble, enum mp	Link Here

1168

1170

1169

  if (m_plcpSuccess == true)

1171

  if (m_plcpSuccess == true)

1170

1172

1171

      NS_LOG_DEBUG ("mode=" << (event->GetPayloadMode ().GetDataRate (event->GetTxVector ().GetChannelWidth (), event->GetTxVector ().IsShortGuardInterval (), 1)) <<

1173

      NS_LOG_DEBUG ("mode=" << (event->GetPayloadMode ().GetDataRate (event->GetTxVector ())) <<

1172

                    ", snr(dB)=" << RatioToDb (snrPer.snr) << ", per=" << snrPer.per << ", size=" << packet->GetSize ());

1174

                    ", snr(dB)=" << RatioToDb (snrPer.snr) << ", per=" << snrPer.per << ", size=" << packet->GetSize ());

1173

1175

1174

      if (m_random->GetValue () > snrPer.per)

1176

      if (m_random->GetValue () > snrPer.per)

Lines 1321-1326 YansWifiPhy::SetChannelWidth (uint32_t channelwidth)	Link Here

1321

1323

1322

  NS_ASSERT_MSG (channelwidth == 5 || channelwidth == 10 || channelwidth == 20 || channelwidth == 22 || channelwidth == 40 || channelwidth == 80 || channelwidth == 160, "wrong channel width value");

1324

  NS_ASSERT_MSG (channelwidth == 5 || channelwidth == 10 || channelwidth == 20 || channelwidth == 22 || channelwidth == 40 || channelwidth == 80 || channelwidth == 160, "wrong channel width value");

1323

  m_channelWidth = channelwidth;

1325

  m_channelWidth = channelwidth;

1326

  AddSupportedChannelWidth (channelwidth);

1324

1327

1325

1328

1326

uint32_t

1329

uint32_t

Lines 1329-1334 YansWifiPhy::GetChannelWidth (void) const	Link Here

1329

  return m_channelWidth;

1332

  return m_channelWidth;

1330

1333

1331

1334

1335

uint8_t

1336

YansWifiPhy::GetSupportedRxSpatialStreams (void) const

1337

1338

  return (static_cast<uint8_t> (GetNumberOfReceiveAntennas ()));

1339

1340

1341

uint8_t

1342

YansWifiPhy::GetSupportedTxSpatialStreams (void) const

1343

1344

  return (static_cast<uint8_t> (GetNumberOfTransmitAntennas ()));

1345

1346

1347

void

1348

YansWifiPhy::AddSupportedChannelWidth (uint32_t width)

1349

1350

  NS_LOG_FUNCTION (this << width);

1351

  for (std::vector<uint32_t>::size_type i = 0; i != m_supportedChannelWidthSet.size (); i++)

1352

1353

      if (m_supportedChannelWidthSet[i] == width)

1354

1355

          return;

1356

1357

1358

  m_supportedChannelWidthSet.push_back (width);

1359

1360

1361

std::vector<uint32_t>

1362

YansWifiPhy::GetSupportedChannelWidthSet (void) const

1363

1364

  return m_supportedChannelWidthSet;

1365

1366

1332

uint32_t

1367

uint32_t

1333

YansWifiPhy::GetNBssMembershipSelectors (void) const

1368

YansWifiPhy::GetNBssMembershipSelectors (void) const

1334

1369

(-)a/src/wifi/model/yans-wifi-phy.h (-1 / +6 lines)

Lines 299-305 public:	Link Here

299

  virtual WifiMode GetMode (uint32_t mode) const;

299

  virtual WifiMode GetMode (uint32_t mode) const;

300

  virtual bool IsModeSupported (WifiMode mode) const;

300

  virtual bool IsModeSupported (WifiMode mode) const;

301

  virtual bool IsMcsSupported (WifiMode mcs);

301

  virtual bool IsMcsSupported (WifiMode mcs);

302

  virtual double CalculateSnr (WifiMode txMode, double ber) const;

302

  virtual double CalculateSnr (WifiTxVector txVector, double ber) const;

303

  virtual Ptr<WifiChannel> GetChannel (void) const;

303

  virtual Ptr<WifiChannel> GetChannel (void) const;

304

305

  virtual void ConfigureStandard (enum WifiPhyStandard standard);

305

  virtual void ConfigureStandard (enum WifiPhyStandard standard);

Lines 410-415 public:	Link Here

410

*/

410

*/

411

  virtual void SetChannelWidth (uint32_t channelwidth);

411

  virtual void SetChannelWidth (uint32_t channelwidth);

412

413

  virtual uint8_t GetSupportedRxSpatialStreams (void) const;

414

  virtual uint8_t GetSupportedTxSpatialStreams (void) const;

415

  virtual void AddSupportedChannelWidth (uint32_t width);

416

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

413

  virtual uint32_t GetNBssMembershipSelectors (void) const;

417

  virtual uint32_t GetNBssMembershipSelectors (void) const;

414

  virtual uint32_t GetBssMembershipSelector (uint32_t selector) const;

418

  virtual uint32_t GetBssMembershipSelector (uint32_t selector) const;

415

  virtual WifiModeList GetMembershipSelectorModes (uint32_t selector);

419

  virtual WifiModeList GetMembershipSelectorModes (uint32_t selector);

Lines 538-543 private:	Link Here

538

  bool     m_greenfield;            //!< Flag if GreenField format is supported

542

  bool     m_greenfield;            //!< Flag if GreenField format is supported

539

  bool     m_guardInterval;         //!< Flag if short guard interval is used

543

  bool     m_guardInterval;         //!< Flag if short guard interval is used

540

  uint32_t m_channelWidth;          //!< Channel width

544

  uint32_t m_channelWidth;          //!< Channel width

545

  std::vector<uint32_t> m_supportedChannelWidthSet; //!< Supported channel width

541

  bool     m_plcpPreamble;          //!< Flag if short PLCP preamble is used

546

  bool     m_plcpPreamble;          //!< Flag if short PLCP preamble is used

542

547

543

/**

548

/**

Return to bug 2296