Attachment #2643 for bug #2533

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

(-)a/examples/wireless/80211n-mimo.cc (-2 / +3 lines)

Lines 132-139	Link Here

132

          // Set guard interval

132

          // Set guard interval

133

          phy.Set ("ShortGuardEnabled", BooleanValue (shortGuardInterval));

133

          phy.Set ("ShortGuardEnabled", BooleanValue (shortGuardInterval));

134

          // Set MIMO capabilities

134

          // Set MIMO capabilities

135

          phy.Set ("TxAntennas", UintegerValue (nStreams));

135

          phy.Set ("Antennas", UintegerValue (nStreams));

136

          phy.Set ("RxAntennas", UintegerValue (nStreams));

136

          phy.Set ("MaxSupportedTxSpatialStreams", UintegerValue (nStreams));

137

          phy.Set ("MaxSupportedRxSpatialStreams", UintegerValue (nStreams));

137

138

          WifiMacHelper mac;

139

          WifiMacHelper mac;

139

          WifiHelper wifi;

140

          WifiHelper wifi;




          else if (i > 31 && i <= 39)
            {
              phy.Set ("ShortGuardEnabled", BooleanValue (false));
              phy.Set ("Antennas", UintegerValue (2));
              phy.Set ("MaxSupportedTxSpatialStreams", UintegerValue (2));
              phy.Set ("MaxSupportedRxSpatialStreams", UintegerValue (2));
              channelWidth = 20;
            }
          else if (i > 39 && i <= 47)
            {
              phy.Set ("ShortGuardEnabled", BooleanValue (true));
              phy.Set ("Antennas", UintegerValue (2));
              phy.Set ("MaxSupportedTxSpatialStreams", UintegerValue (2));
              phy.Set ("MaxSupportedRxSpatialStreams", UintegerValue (2));
              channelWidth = 20;
            }
          else if (i > 47 && i <= 55)
            {
              phy.Set ("ShortGuardEnabled", BooleanValue (false));
              phy.Set ("Antennas", UintegerValue (2));
              phy.Set ("MaxSupportedTxSpatialStreams", UintegerValue (2));
              phy.Set ("MaxSupportedRxSpatialStreams", UintegerValue (2));
              channelWidth = 40;
            }
          else if (i > 55 && i <= 63)
            {
              phy.Set ("ShortGuardEnabled", BooleanValue (true));
              phy.Set ("Antennas", UintegerValue (2));
              phy.Set ("MaxSupportedTxSpatialStreams", UintegerValue (2));
              phy.Set ("MaxSupportedRxSpatialStreams", UintegerValue (2));
              channelWidth = 40;
            }
        }

          else if (i > 31 && i <= 39)
            {
              spectrumPhy.Set ("ShortGuardEnabled", BooleanValue (false));
              spectrumPhy.Set ("Antennas", UintegerValue (2));
              spectrumPhy.Set ("MaxSupportedTxSpatialStreams", UintegerValue (2));
              spectrumPhy.Set ("MaxSupportedRxSpatialStreams", UintegerValue (2));
              channelWidth = 20;
            }
          else if (i > 39 && i <= 47)
            {
              spectrumPhy.Set ("ShortGuardEnabled", BooleanValue (true));
              spectrumPhy.Set ("Antennas", UintegerValue (2));
              spectrumPhy.Set ("MaxSupportedTxSpatialStreams", UintegerValue (2));
              spectrumPhy.Set ("MaxSupportedRxSpatialStreams", UintegerValue (2));
              channelWidth = 20;
            }
          else if (i > 47 && i <= 55)
            {
              spectrumPhy.Set ("ShortGuardEnabled", BooleanValue (false));
              spectrumPhy.Set ("Antennas", UintegerValue (2));
              spectrumPhy.Set ("MaxSupportedTxSpatialStreams", UintegerValue (2));
              spectrumPhy.Set ("MaxSupportedRxSpatialStreams", UintegerValue (2));
              channelWidth = 40;
            }
          else if (i > 55 && i <= 63)
            {
              spectrumPhy.Set ("ShortGuardEnabled", BooleanValue (true));
              spectrumPhy.Set ("Antennas", UintegerValue (2));
              spectrumPhy.Set ("MaxSupportedTxSpatialStreams", UintegerValue (2));
              spectrumPhy.Set ("MaxSupportedRxSpatialStreams", UintegerValue (2));
              channelWidth = 40;
            }
        }

(-)a/src/wifi/doc/source/wifi-design.rst (-3 / +1 lines)

Lines 162-170	Link Here

162

packets.  Moreover, interference from other technologies is not modeled.

162

packets.  Moreover, interference from other technologies is not modeled.

163

The following details pertain to the physical layer and channel models:

163

The following details pertain to the physical layer and channel models:

164

165

* 802.11n/ac MIMO currently uses the same 802.11n/ac SISO Yans and Nist error rate models

165

* 802.11ac MU-MIMO is not supported, and no more than 4 antennas can be configured

166

* 802.11ac MU-MIMO is not supported

167

* Antenna diversity is not supported

168

* 802.11n/ac beamforming is not supported

166

* 802.11n/ac beamforming is not supported

169

* PLCP preamble reception is not modeled

167

* PLCP preamble reception is not modeled

170

* PHY_RXSTART is not supported

168

* PHY_RXSTART is not supported





 wifiPhyHelper.Set ("ShortGuardEnabled", BooleanValue(true));

In order to enable 802.11n/ac MIMO, the number of antennas as well as the number of supported spatial streams need to be configured.
For example, this code enables MIMO with 2 antennas and 2 spatial streams::

 wifiPhyHelper.Set ("Antennas", UintegerValue (2));
 wifiPhyHelper.Set ("MaxSupportedTxSpatialStreams", UintegerValue (2));
 wifiPhyHelper.Set ("MaxSupportedRxSpatialStreams", UintegerValue (2));

It is also possible to configure less streams than the number of antennas in order to benefit from diversity gain, and to define different MIMO capabilities for downlink and uplink.
For example, this code configures a node with 3 antennas that supports 2 spatial streams in downstream and 1 spatial stream in upstream::

 wifiPhyHelper.Set ("Antennas", UintegerValue (3));
 wifiPhyHelper.Set ("MaxSupportedTxSpatialStreams", UintegerValue (2));
 wifiPhyHelper.Set ("MaxSupportedRxSpatialStreams", UintegerValue (1));

Furthermore, 802.11n provides an optional mode (GreenField mode) to reduce preamble durations and which is only compatible with 802.11n devices. This mode is enabled as follows::


(-)a/src/wifi/examples/ideal-wifi-manager-example.cc (-5 / +7 lines)

Lines 276-285	Link Here

276

  Ptr<WifiNetDevice> wndServer = ndServer->GetObject<WifiNetDevice> ();

276

  Ptr<WifiNetDevice> wndServer = ndServer->GetObject<WifiNetDevice> ();

277

  Ptr<WifiPhy> wifiPhyPtrClient = wndClient->GetPhy ();

277

  Ptr<WifiPhy> wifiPhyPtrClient = wndClient->GetPhy ();

278

  Ptr<WifiPhy> wifiPhyPtrServer = wndServer->GetPhy ();

278

  Ptr<WifiPhy> wifiPhyPtrServer = wndServer->GetPhy ();

279

  wifiPhyPtrClient->SetNumberOfTransmitAntennas (nss);

279

  wifiPhyPtrClient->SetNumberOfAntennas (nss);

280

  wifiPhyPtrClient->SetNumberOfReceiveAntennas (nss);

280

  wifiPhyPtrClient->SetMaxSupportedTxSpatialStreams (nss);

281

  wifiPhyPtrServer->SetNumberOfTransmitAntennas (nss);

281

  wifiPhyPtrClient->SetMaxSupportedRxSpatialStreams (nss);

282

  wifiPhyPtrServer->SetNumberOfReceiveAntennas (nss);

282

  wifiPhyPtrServer->SetNumberOfAntennas (nss);

283

  wifiPhyPtrServer->SetMaxSupportedTxSpatialStreams (nss);

284

  wifiPhyPtrServer->SetMaxSupportedRxSpatialStreams (nss);

283

  // Only set the channel width and guard interval for HT and VHT modes

285

  // Only set the channel width and guard interval for HT and VHT modes

284

  if (selectedStandard.m_name == "802.11n-5GHz" ||

286

  if (selectedStandard.m_name == "802.11n-5GHz" ||

285

      selectedStandard.m_name == "802.11n-2.4GHz" ||

287

      selectedStandard.m_name == "802.11n-2.4GHz" ||

Lines 291-297	Link Here

291

      wifiPhyPtrServer->SetGuardInterval (shortGuardInterval);

293

      wifiPhyPtrServer->SetGuardInterval (shortGuardInterval);

292

294

293

  NS_LOG_DEBUG ("Channel width " << wifiPhyPtrClient->GetChannelWidth () << " noiseDbm " << noiseDbm);

295

  NS_LOG_DEBUG ("Channel width " << wifiPhyPtrClient->GetChannelWidth () << " noiseDbm " << noiseDbm);

294

  NS_LOG_DEBUG ("NSS " << wifiPhyPtrClient->GetSupportedTxSpatialStreams ());

296

  NS_LOG_DEBUG ("NSS " << wifiPhyPtrClient->GetMaxSupportedTxSpatialStreams ());

295

297

296

  // Configure signal and noise, and schedule first iteration

298

  // Configure signal and noise, and schedule first iteration

297

  noiseDbm += 10 * log10 (selectedStandard.m_width * 1000000);

299

  noiseDbm += 10 * log10 (selectedStandard.m_width * 1000000);




  Ptr<WifiNetDevice> wndClient = ndClient->GetObject<WifiNetDevice> ();
  Ptr<WifiPhy> wifiPhyPtrClient = wndClient->GetPhy ();
  wifiPhyPtrClient->SetChannelWidth (selectedStandard.m_width);
  wifiPhyPtrClient->SetNumberOfAntennas (nss);
  wifiPhyPtrClient->SetMaxSupportedTxSpatialStreams (nss);
  wifiPhyPtrClient->SetMaxSupportedRxSpatialStreams (nss);
  noiseDbm += 10 * log10 (selectedStandard.m_width * 1000000);
  NS_LOG_DEBUG ("Channel width " << wifiPhyPtrClient->GetChannelWidth () << " noiseDbm " << noiseDbm);


  Ptr<WifiNetDevice> wndServer = ndServer->GetObject<WifiNetDevice> ();
  Ptr<WifiPhy> wifiPhyPtrServer = wndServer->GetPhy ();
  wifiPhyPtrServer->SetChannelWidth (selectedStandard.m_width);
  wifiPhyPtrServer->SetNumberOfAntennas (nss);
  wifiPhyPtrServer->SetMaxSupportedTxSpatialStreams (nss);
  wifiPhyPtrServer->SetMaxSupportedRxSpatialStreams (nss);

  double rssCurrent = (selectedStandard.m_snrHigh + noiseDbm);
  rssLossModel->SetRss (rssCurrent);




      //avoid to use legacy rate adaptation algorithms for IEEE 802.11n/ac
      channelWidth = 20;
    }
  return WifiTxVector (GetSupported (station, station->m_rate), GetDefaultTxPowerLevel (), GetLongRetryCount (station), false, 1, 1, 0, channelWidth, GetAggregation (station), false);
}

WifiTxVector

  WifiTxVector rtsTxVector;
  if (GetUseNonErpProtection () == false)
    {
      rtsTxVector = WifiTxVector (GetSupported (station, 0), GetDefaultTxPowerLevel (), GetLongRetryCount (station), false, 1, 1, 0, channelWidth, GetAggregation (station), false);
    }
  else
    {
      rtsTxVector = WifiTxVector (GetNonErpSupported (station, 0), GetDefaultTxPowerLevel (), GetLongRetryCount (station), false, 1, 1, 0, channelWidth, GetAggregation (station), false);
    }
  return rtsTxVector;
}




      //avoid to use legacy rate adaptation algorithms for IEEE 802.11n/ac
      channelWidth = 20;
    }
  return WifiTxVector (GetSupported (station, station->m_rate), GetDefaultTxPowerLevel (), GetLongRetryCount (station), false, 1, 1, 0, channelWidth, GetAggregation (station), false);
}

WifiTxVector

  WifiTxVector rtsTxVector;
  if (GetUseNonErpProtection () == false)
    {
      rtsTxVector = WifiTxVector (GetSupported (station, 0), GetDefaultTxPowerLevel (), GetShortRetryCount (station), false, 1, 1, 0, channelWidth, GetAggregation (station), false);
    }
  else
    {
      rtsTxVector = WifiTxVector (GetNonErpSupported (station, 0), GetDefaultTxPowerLevel (), GetShortRetryCount (station), false, 1, 1, 0, channelWidth, GetAggregation (station), false);
    }
  return rtsTxVector;
}




      //avoid to use legacy rate adaptation algorithms for IEEE 802.11n/ac
      channelWidth = 20;
    }
  return WifiTxVector (GetSupported (station, rateIndex), GetDefaultTxPowerLevel (), GetLongRetryCount (station), false, 1, 1, 0, channelWidth, GetAggregation (station), false);
}

WifiTxVector

  WifiTxVector rtsTxVector;
  if (GetUseNonErpProtection () == false)
    {
      rtsTxVector = WifiTxVector (GetSupported (station, 0), GetDefaultTxPowerLevel (), GetLongRetryCount (station), false, 1, 1, 0, channelWidth, GetAggregation (station), false);
    }
  else
    {
      rtsTxVector = WifiTxVector (GetNonErpSupported (station, 0), GetDefaultTxPowerLevel (), GetLongRetryCount (station), false, 1, 1, 0, channelWidth, GetAggregation (station), false);
    }
  return rtsTxVector;
}




      channelWidth = 20;
    }
  CheckInit (station);
  return WifiTxVector (GetSupported (station, station->m_rate), station->m_power, GetLongRetryCount (station), false, 1, 1, 0, channelWidth, GetAggregation (station), false);
}

WifiTxVector

  WifiTxVector rtsTxVector;
  if (GetUseNonErpProtection () == false)
    {
      rtsTxVector = WifiTxVector (GetSupported (station, 0), GetDefaultTxPowerLevel (), GetShortRetryCount (station), false, 1, 1, 0, channelWidth, GetAggregation (station), false);
    }
  else
    {
      rtsTxVector = WifiTxVector (GetNonErpSupported (station, 0), GetDefaultTxPowerLevel (), GetShortRetryCount (station), false, 1, 1, 0, channelWidth, GetAggregation (station), false);
    }
  return rtsTxVector;
}




      //avoid to use legacy rate adaptation algorithms for IEEE 802.11n/ac
      channelWidth = 20;
    }
  return WifiTxVector (GetSupported (station, station->m_rate), GetDefaultTxPowerLevel (), GetLongRetryCount (station), false, 1, 1, 0, channelWidth, GetAggregation (station), false);
}

WifiTxVector

  WifiTxVector rtsTxVector;
  if (GetUseNonErpProtection () == false)
    {
      rtsTxVector = WifiTxVector (GetSupported (station, 0), GetDefaultTxPowerLevel (), GetLongRetryCount (station), false, 1, 1, 0, channelWidth, GetAggregation (station), false);
    }
  else
    {
      rtsTxVector = WifiTxVector (GetNonErpSupported (station, 0), GetDefaultTxPowerLevel (), GetLongRetryCount (station), false, 1, 1, 0, channelWidth, GetAggregation (station), false);
    }
  return rtsTxVector;
}




      //avoid to use legacy rate adaptation algorithms for IEEE 802.11n/ac
      channelWidth = 20;
    }
  return WifiTxVector (GetSupported (station, station->m_rate), GetDefaultTxPowerLevel (), GetLongRetryCount (station), false, 1, 1, 0, channelWidth, GetAggregation (station), false);
}

WifiTxVector

  WifiTxVector rtsTxVector;
  if (GetUseNonErpProtection () == false)
    {
      rtsTxVector = WifiTxVector (GetSupported (station, 0), GetDefaultTxPowerLevel (), GetLongRetryCount (station), false, 1, 1, 0, channelWidth, GetAggregation (station), false);
    }
  else
    {
      rtsTxVector = WifiTxVector (GetNonErpSupported (station, 0), GetDefaultTxPowerLevel (), GetLongRetryCount (station), false, 1, 1, 0, channelWidth, GetAggregation (station), false);
    }
  return rtsTxVector;
}




ConstantRateWifiManager::DoGetDataTxVector (WifiRemoteStation *st)
{
  NS_LOG_FUNCTION (this << st);
  return WifiTxVector (m_dataMode, GetDefaultTxPowerLevel (), GetLongRetryCount (st), GetShortGuardInterval (st), GetNumberOfAntennas (), Min(GetMaxNumberOfTransmitStreams (), GetNumberOfSupportedStreams (st)), 0, GetChannelWidth (st), GetAggregation (st), false);
}

WifiTxVector
ConstantRateWifiManager::DoGetRtsTxVector (WifiRemoteStation *st)
{
  NS_LOG_FUNCTION (this << st);
  return WifiTxVector (m_ctlMode, GetDefaultTxPowerLevel (), GetShortRetryCount (st), GetShortGuardInterval (st), 1, 1, 0, GetChannelWidth (st), GetAggregation (st), false);
}

bool




            }
          else
            {
              nss = GetPhy ()->GetMaxSupportedTxSpatialStreams ();
            }
          NS_LOG_DEBUG ("Initialize, adding mode = " << mode.GetUniqueName () <<
                        " channel width " << GetPhy ()->GetChannelWidth () <<

                }
              else
                {
                  nss = GetPhy ()->GetMaxSupportedTxSpatialStreams ();
                }
              txVector.SetNss (nss);
              if (WifiPhy::IsValidTxVector (txVector) == false)

      NS_LOG_DEBUG ("New datarate: " << maxMode.GetDataRate (channelWidth, GetPhy ()->GetGuardInterval (), nss));
      m_currentRate = maxMode.GetDataRate (channelWidth, GetPhy ()->GetGuardInterval (), nss);
    }
  return WifiTxVector (maxMode, GetDefaultTxPowerLevel (), GetLongRetryCount (station), false, GetNumberOfAntennas (), nss, 0, channelWidth, GetAggregation (station), false);
}

WifiTxVector

          maxMode = mode;
        }
    }
  return WifiTxVector (maxMode, GetDefaultTxPowerLevel (), GetShortRetryCount (station), false, GetNumberOfAntennas (), nss, 0, GetChannelWidthForMode (maxMode), GetAggregation (station), false);
}

bool

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

Lines 135-140	Link Here

135

136

InterferenceHelper::InterferenceHelper ()

136

InterferenceHelper::InterferenceHelper ()

137

  : m_errorRateModel (0),

137

  : m_errorRateModel (0),

138

    m_numRxAntennas (1),

138

    m_firstPower (0.0),

139

    m_firstPower (0.0),

139

    m_rxing (false)

140

    m_rxing (false)

140

141

Lines 195-200	Link Here

195

  return m_errorRateModel;

196

  return m_errorRateModel;

196

197

198

199

void

200

InterferenceHelper::SetNumberOfReceiveAntennas (uint8_t rx)

201

202

  m_numRxAntennas = rx;

203

204

198

Time

205

Time

199

InterferenceHelper::GetEnergyDuration (double energyW)

206

InterferenceHelper::GetEnergyDuration (double energyW)

200

207

Lines 283-288	Link Here

283

290

284

  uint32_t rate = mode.GetPhyRate (txVector);

291

  uint32_t rate = mode.GetPhyRate (txVector);

285

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

292

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

293

  if (txVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_HT || txVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_VHT)

294

295

      nbits /= txVector.GetNss (); //divide effective number of bits by NSS to achieve same chunk error rate as SISO for AWGN

296

      double gain = (txVector.GetNTx () * m_numRxAntennas); //compute gain offered by MIMO, SIMO or MISO compared to SISO for AWGN

297

      NS_LOG_DEBUG ("TX=" << (uint32_t)txVector.GetNTx () << ", RX=" << (uint32_t)m_numRxAntennas << ", SNIR improvement=+" << 10.0 * std::log10 (gain) << "dB");

298

      snir *= gain;

299

286

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

300

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

287

  return csr;

301

  return csr;

288

302

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

Lines 157-162	Link Here

157

   * \return Error rate model

157

   * \return Error rate model

158

*/

158

*/

159

  Ptr<ErrorRateModel> GetErrorRateModel (void) const;

159

  Ptr<ErrorRateModel> GetErrorRateModel (void) const;

160

/**

161

   * Set the number of RX antennas in the receiver corresponding to this

162

   * interference helper.

163

164

   * \param the number of RX antennas

165

*/

166

  void SetNumberOfReceiveAntennas (uint8_t rx);

160

167

161

/**

168

/**

162

   * \param energyW the minimum energy (W) requested

169

   * \param energyW the minimum energy (W) requested

Lines 330-335	Link Here

330

337

331

  double m_noiseFigure; /**< noise figure (linear) */

338

  double m_noiseFigure; /**< noise figure (linear) */

332

  Ptr<ErrorRateModel> m_errorRateModel;

339

  Ptr<ErrorRateModel> m_errorRateModel;

340

  uint8_t m_numRxAntennas; /**< the number of RX antennas in the corresponding receiver */

333

  /// Experimental: needed for energy duration calculation

341

  /// Experimental: needed for energy duration calculation

334

  NiChanges m_niChanges;

342

  NiChanges m_niChanges;

335

  double m_firstPower;

343

  double m_firstPower;




                  // Check capabilities of the device
                  if (!(!GetPhy ()->GetGuardInterval () && m_minstrelGroups[groupId].sgi)                   ///Is SGI supported by the transmitter?
                      && (GetPhy ()->GetChannelWidth () >= m_minstrelGroups[groupId].chWidth)               ///Is channel width supported by the transmitter?
                      && (GetPhy ()->GetMaxSupportedTxSpatialStreams () >= m_minstrelGroups[groupId].streams))  ///Are streams supported by the transmitter?
                    {
                      m_minstrelGroups[groupId].isSupported = true;


                      // Check capabilities of the device
                      if (!(!GetPhy ()->GetGuardInterval () && m_minstrelGroups[groupId].sgi)                   ///Is SGI supported by the transmitter?
                          && (GetPhy ()->GetChannelWidth () >= m_minstrelGroups[groupId].chWidth)               ///Is channel width supported by the transmitter?
                          && (GetPhy ()->GetMaxSupportedTxSpatialStreams () >= m_minstrelGroups[groupId].streams))  ///Are streams supported by the transmitter?
                        {
                          m_minstrelGroups[groupId].isSupported = true;


      McsGroup group = m_minstrelGroups[groupId];

      // Check consistency of rate selected.
      if ((group.sgi && !GetShortGuardInterval (station)) || group.chWidth > GetChannelWidth (station)  ||  (uint32_t) group.streams > GetNumberOfSupportedStreams (station))
        {
          NS_ASSERT_MSG (false,"Inconsistent group selected. Group: (" << (uint32_t)group.streams << "," << (uint32_t)group.sgi << "," << group.chWidth << ")" <<
                         " Station capabilities: (" << GetNumberOfSupportedStreams (station) << "," << GetShortGuardInterval (station) << "," << GetChannelWidth (station) << ")");
        }

      uint64_t dataRate = GetMcsSupported (station, mcsIndex).GetDataRate (group.chWidth, group.sgi, group.streams);

        }

      return WifiTxVector (GetMcsSupported (station, mcsIndex), GetDefaultTxPowerLevel (), GetLongRetryCount (station),
                           group.sgi, GetNumberOfAntennas (), group.streams, GetNess (station), group.chWidth, GetAggregation (station) && !station->m_isSampling, GetStbc (station));
    }
}


      NS_ASSERT (rateFound);

      return WifiTxVector (rtsRate, GetDefaultTxPowerLevel (), GetShortRetryCount (station),
                           false, 1, 1, 0, GetChannelWidth (station), GetAggregation (station), false);
    }
}


      if (m_minstrelGroups[groupId].isSupported)
        {
          station->m_groupsTable[groupId].m_supported = false;
          if (!(!GetVhtSupported (station) && m_minstrelGroups[groupId].isVht)                    ///Is VHT supported by the receiver?
              && (m_minstrelGroups[groupId].isVht || !GetVhtSupported (station) || !m_useVhtOnly) ///If it is an HT MCS, check if VHT only is disabled
              && !(!GetShortGuardInterval (station) && m_minstrelGroups[groupId].sgi)             ///Is SGI supported by the receiver?
              && (GetChannelWidth (station) >= m_minstrelGroups[groupId].chWidth)                 ///Is channel width supported by the receiver?
              && (GetNumberOfSupportedStreams (station) >= m_minstrelGroups[groupId].streams))    ///Are streams supported by the receiver?
            {
              NS_LOG_DEBUG ("Group " << groupId << ": (" << (uint32_t)m_minstrelGroups[groupId].streams <<
                            "," << (uint32_t)m_minstrelGroups[groupId].sgi << "," << m_minstrelGroups[groupId].chWidth << ")");




      //start the rate at half way
      station->m_txrate = station->m_nModes / 2;
    }
  return WifiTxVector (GetSupported (station, station->m_txrate), GetDefaultTxPowerLevel (), GetLongRetryCount (station), false, 1, 1, 0, channelWidth, GetAggregation (station), false);
}

WifiTxVector

  WifiTxVector rtsTxVector;
  if (GetUseNonErpProtection () == false)
    {
      rtsTxVector = WifiTxVector (GetSupported (station, 0), GetDefaultTxPowerLevel (), GetShortRetryCount (station), false, 1, 1, 0, channelWidth, GetAggregation (station), false);
    }
  else
    {
      rtsTxVector = WifiTxVector (GetNonErpSupported (station, 0), GetDefaultTxPowerLevel (), GetShortRetryCount (station), false, 1, 1, 0, channelWidth, GetAggregation (station), false);
    }
  return rtsTxVector;
}




      //avoid to use legacy rate adaptation algorithms for IEEE 802.11n/ac
      channelWidth = 20;
    }
  return WifiTxVector (GetSupported (station, rateIndex), GetDefaultTxPowerLevel (), GetLongRetryCount (station), false, 1, 1, 0, channelWidth, GetAggregation (station), false);
}

WifiTxVector

  WifiTxVector rtsTxVector;
  if (GetUseNonErpProtection () == false)
    {
      rtsTxVector = WifiTxVector (GetSupported (station, 0), GetDefaultTxPowerLevel (), GetShortRetryCount (station), false, 1, 1, 0, channelWidth, GetAggregation (station), false);
    }
  else
    {
      rtsTxVector = WifiTxVector (GetNonErpSupported (station, 0), GetDefaultTxPowerLevel (), GetShortRetryCount (station), false, 1, 1, 0, channelWidth, GetAggregation (station), false);
    }
  return rtsTxVector;
}




      channelWidth = 20;
    }
  CheckInit (station);
  return WifiTxVector (GetSupported (station, station->m_currentRate), station->m_currentPower, GetLongRetryCount (station), false, 1, 1, 0, channelWidth, GetAggregation (station), false);
}

WifiTxVector

  WifiTxVector rtsTxVector;
  if (GetUseNonErpProtection () == false)
    {
      rtsTxVector = WifiTxVector (GetSupported (station, 0), GetDefaultTxPowerLevel (), GetShortRetryCount (station), false, 1, 1, 0, channelWidth, GetAggregation (station), false);
    }
  else
    {
      rtsTxVector = WifiTxVector (GetNonErpSupported (station, 0), GetDefaultTxPowerLevel (), GetShortRetryCount (station), false, 1, 1, 0, channelWidth, GetAggregation (station), false);
    }
  return rtsTxVector;
}




        }
      capabilities.SetRxHighestSupportedDataRate (maxSupportedRate / 1e6); //in Mbit/s
      capabilities.SetTxMcsSetDefined (m_phy->GetNMcs () > 0);
      capabilities.SetTxMaxNSpatialStreams (m_phy->GetMaxSupportedTxSpatialStreams ());
    }
  return capabilities;
}

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




    {
      ResetCountersBasic (station);
    }
  return WifiTxVector (GetSupported (station, station->m_rate), GetDefaultTxPowerLevel (), GetLongRetryCount (station), false, 1, 1, 0, channelWidth, GetAggregation (station), false);
}

WifiTxVector

  WifiTxVector rtsTxVector;
  if (GetUseNonErpProtection () == false)
    {
      rtsTxVector = WifiTxVector (GetSupported (st, 0), GetDefaultTxPowerLevel (), GetShortRetryCount (st), false, 1, 1, 0, channelWidth, GetAggregation (station), false);
    }
  else
    {
      rtsTxVector = WifiTxVector (GetNonErpSupported (st, 0), GetDefaultTxPowerLevel (), GetShortRetryCount (st), false, 1, 1, 0, channelWidth, GetAggregation (station), false);
    }
  return rtsTxVector;
}




      NS_FATAL_ERROR ("MCS value does not match NSS value: MCS = " << (uint16_t)txVector.GetMode ().GetMcsValue () << ", NSS = " << (uint16_t)txVector.GetNss ());
    }

  if (txVector.GetNss () > GetMaxSupportedRxSpatialStreams ())
    {
      NS_FATAL_ERROR ("Reception ends in failure because of an unsupported number of spatial streams");
      NotifyRxDrop (packet);
      NS_LOG_INFO ("Reception ends in failure because less RX antennas than number of spatial streams");
      SwitchMaybeToCcaBusy ();
      return;
    }

  enum WifiPreamble preamble = tag.GetWifiPreamble ();

   *  - we are idle
   */
  NS_ASSERT (!m_state->IsStateTx () && !m_state->IsStateSwitching ());
  
  if (txVector.GetNss () > GetMaxSupportedTxSpatialStreams ())
    {
      NS_FATAL_ERROR ("Unsupported number of spatial streams!");
    }

  if (m_state->IsStateSleep ())
    {




uint32_t
WifiPhyTag::GetSerializedSize (void) const
{
  return (4 + (7 * 1) + 4 + 2);
}

void

  i.WriteU8 (m_wifiTxVector.GetTxPowerLevel ());
  i.WriteU8 (m_wifiTxVector.GetRetries ());
  i.WriteU8 (m_wifiTxVector.IsShortGuardInterval ());
  i.WriteU8 (m_wifiTxVector.GetNTx ());
  i.WriteU8 (m_wifiTxVector.GetNss ());
  i.WriteU8 (m_wifiTxVector.GetNess ());
  i.WriteU8 (m_wifiTxVector.IsStbc ());

  m_wifiTxVector.SetTxPowerLevel (i.ReadU8 ());
  m_wifiTxVector.SetRetries (i.ReadU8 ());
  m_wifiTxVector.SetShortGuardInterval (i.ReadU8 ());
  m_wifiTxVector.SetNTx (i.ReadU8 ());
  m_wifiTxVector.SetNss (i.ReadU8 ());
  m_wifiTxVector.SetNess (i.ReadU8 ());
  m_wifiTxVector.SetStbc (i.ReadU8 ());




                   TimeValue (MicroSeconds (250)),
                   MakeTimeAccessor (&WifiPhy::m_channelSwitchDelay),
                   MakeTimeChecker ())
    .AddAttribute ("Antennas",
                   "The number of antennas on the device.",
                   UintegerValue (1),
                   MakeUintegerAccessor (&WifiPhy::GetNumberOfAntennas,
                                         &WifiPhy::SetNumberOfAntennas),
                   MakeUintegerChecker<uint32_t> ())
    .AddAttribute ("MaxSupportedTxSpatialStreams",
                   "The maximum number of supported TX spatial streams."
                   "This parameter is only valuable for 802.11n/ac STAs and APs.",
                   UintegerValue (1),
                   MakeUintegerAccessor (&WifiPhy::GetMaxSupportedTxSpatialStreams,
                                         &WifiPhy::SetMaxSupportedTxSpatialStreams),
                   MakeUintegerChecker<uint8_t> ())
    .AddAttribute ("MaxSupportedRxSpatialStreams",
                   "The maximum number of supported RX spatial streams."
                   "This parameter is only valuable for 802.11n/ac STAs and APs.",
                   UintegerValue (1),
                   MakeUintegerAccessor (&WifiPhy::GetMaxSupportedRxSpatialStreams,
                                         &WifiPhy::SetMaxSupportedRxSpatialStreams),
                   MakeUintegerChecker<uint8_t> ())
    .AddAttribute ("ShortGuardEnabled",
                   "Whether or not short guard interval is enabled."
                   "This parameter is only valuable for 802.11n/ac STAs and APs.",

{
  NS_LOG_FUNCTION (this << noiseFigureDb);
  m_interference.SetNoiseFigure (DbToRatio (noiseFigureDb));
  m_interference.SetNumberOfReceiveAntennas (GetNumberOfAntennas ());
}

double

WifiPhy::SetErrorRateModel (Ptr<ErrorRateModel> rate)
{
  m_interference.SetErrorRateModel (rate);
  m_interference.SetNumberOfReceiveAntennas (GetNumberOfAntennas ());
}

Ptr<ErrorRateModel>

      m_deviceMcsSet.push_back (WifiPhy::GetHtMcs5 ());
      m_deviceMcsSet.push_back (WifiPhy::GetHtMcs6 ());
      m_deviceMcsSet.push_back (WifiPhy::GetHtMcs7 ());
      if (GetMaxSupportedTxSpatialStreams () > 1)
        {
          m_deviceMcsSet.push_back (WifiPhy::GetHtMcs8 ());
          m_deviceMcsSet.push_back (WifiPhy::GetHtMcs9 ());

          m_deviceMcsSet.push_back (WifiPhy::GetHtMcs14 ());
          m_deviceMcsSet.push_back (WifiPhy::GetHtMcs15 ());
        }
      if (GetMaxSupportedTxSpatialStreams () > 2)
        {
          m_deviceMcsSet.push_back (WifiPhy::GetHtMcs16 ());
          m_deviceMcsSet.push_back (WifiPhy::GetHtMcs17 ());

          m_deviceMcsSet.push_back (WifiPhy::GetHtMcs22 ());
          m_deviceMcsSet.push_back (WifiPhy::GetHtMcs23 ());
        }
      if (GetMaxSupportedTxSpatialStreams () > 3)
        {
          m_deviceMcsSet.push_back (WifiPhy::GetHtMcs24 ());
          m_deviceMcsSet.push_back (WifiPhy::GetHtMcs25 ());

}

void
WifiPhy::SetNumberOfAntennas (uint8_t antennas)
{
  NS_ASSERT_MSG (antennas > 0 && antennas <= 4, "unsupported number of antennas");
  m_numberOfAntennas = antennas;
  m_interference.SetNumberOfReceiveAntennas (antennas);
}

uint8_t
WifiPhy::GetNumberOfAntennas (void) const
{
  return m_numberOfAntennas;
}

void
WifiPhy::SetMaxSupportedTxSpatialStreams (uint8_t streams)
{
  NS_ASSERT (streams <= GetNumberOfAntennas ());
  m_txSpatialStreams = streams;
  ConfigureHtDeviceMcsSet ();
}

uint8_t 
WifiPhy::GetMaxSupportedTxSpatialStreams (void) const
{
  return m_txSpatialStreams;
}

void
WifiPhy::SetMaxSupportedRxSpatialStreams (uint8_t streams)
{
  NS_ASSERT (streams <= GetNumberOfAntennas ());
  m_rxSpatialStreams = streams;

uint32_t
WifiPhy::GetNumberOfReceiveAntennas (void) const
{
  return m_numberOfReceivers;
}

uint8_t 
WifiPhy::GetMaxSupportedRxSpatialStreams (void) const
{
  return m_rxSpatialStreams;
}

uint8_t 
WifiPhy::GetSupportedTxSpatialStreams (void) const
{
  return (static_cast<uint8_t> (GetNumberOfTransmitAntennas ()));
}

uint32_t




   */
  virtual uint32_t GetFrequency (void) const;
  /**
   * \param antennas the number of antennas on this node.
   */
  virtual void SetNumberOfAntennas (uint8_t antennas);
  /**
   * \return the number of antennas on this device
   */
  virtual uint8_t GetNumberOfAntennas (void) const;
  /**
   * \param streams the maximum number of supported TX spatial streams.
   */
  virtual void SetMaxSupportedTxSpatialStreams (uint8_t streams);
  /**
   * \return the maximum number of supported TX spatial streams
   */
  virtual uint8_t GetMaxSupportedTxSpatialStreams (void) const;
  /**
   * \param streams the maximum number of supported RX spatial streams.
   */
  virtual void SetMaxSupportedRxSpatialStreams (uint8_t streams);
  /**
   * \return the maximum number of supported RX spatial streams
   */
  virtual uint8_t GetMaxSupportedRxSpatialStreams (void) const;

  /**
   * Enable or disable short/long guard interval.

   */
  virtual std::vector<uint32_t> GetSupportedChannelWidthSet (void) const;
  /**
   * \return the maximum number of supported Rx spatial streams
   */
  virtual uint8_t GetSupportedRxSpatialStreams (void) const;
  /**
   * \return the maximum number of supported Tx spatial streams
   */
  virtual uint8_t GetSupportedTxSpatialStreams (void) const;
  /**
   * Convert from dBm to Watts.
   *
   * \param dbm the power in dBm

  bool     m_guardInterval;         //!< Flag if short guard interval is used
  bool     m_shortPreamble;         //!< Flag if short PLCP preamble is supported

  uint32_t m_numberOfAntennas;  //!< Number of transmitters
  uint32_t m_txSpatialStreams;  //!< Number of supported TX spatial streams
  uint32_t m_rxSpatialStreams;  //!< Number of supported RX spatial streams

  typedef std::map<ChannelNumberStandardPair,FrequencyWidthPair> ChannelToFrequencyWidthMap;
  static ChannelToFrequencyWidthMap m_channelToFrequencyWidth;

  std::vector<uint32_t> m_supportedChannelWidthSet; //!< Supported channel width
  uint16_t              m_channelNumber;            //!< Operating channel number
  uint16_t              m_initialChannelNumber;     //!< Initial channel number

  Time m_channelSwitchDelay;     //!< Time required to switch between channel
  uint32_t m_totalAmpduSize;     //!< Total size of the previously transmitted MPDUs in an A-MPDU, used for the computation of the number of symbols needed for the last MPDU in the A-MPDU

(-)a/src/wifi/model/wifi-remote-station-manager.cc (-10 / +17 lines)

Lines 766-775	Link Here

766

  return WifiTxVector (GetDefaultMode (),

766

  return WifiTxVector (GetDefaultMode (),

767

                       GetDefaultTxPowerLevel (),

767

                       GetDefaultTxPowerLevel (),

768

0,

768

0,

769

                       m_wifiPhy->GetGuardInterval (),

770

                       GetNumberOfAntennas (),

771

                       GetMaxNumberOfTransmitStreams (),

772

0,

769

                       m_wifiPhy->GetChannelWidth (),

773

                       m_wifiPhy->GetChannelWidth (),

770

                       m_wifiPhy->GetGuardInterval (),

771

                       GetNumberOfTransmitAntennas (),

772

                       GetNumberOfTransmitAntennas (),

773

                       false,

774

                       false,

774

                       false);

775

                       false);

775

776

Lines 1467-1473	Link Here

1467

  state->m_channelWidth = m_wifiPhy->GetChannelWidth ();

1468

  state->m_channelWidth = m_wifiPhy->GetChannelWidth ();

1468

  state->m_shortGuardInterval = m_wifiPhy->GetGuardInterval ();

1469

  state->m_shortGuardInterval = m_wifiPhy->GetGuardInterval ();

1469

  state->m_greenfield = m_wifiPhy->GetGreenfield ();

1470

  state->m_greenfield = m_wifiPhy->GetGreenfield ();

1470

  state->m_rx = 1;

1471

  state->m_streams = 1;

1471

  state->m_ness = 0;

1472

  state->m_ness = 0;

1472

  state->m_aggregation = false;

1473

  state->m_aggregation = false;

1473

  state->m_stbc = false;

1474

  state->m_stbc = false;

Lines 1534-1540	Link Here

1534

1535

  state->m_htSupported = true;

1536

  state->m_htSupported = true;

1536

  state->m_greenfield = htCapabilities.GetGreenfield ();

1537

  state->m_greenfield = htCapabilities.GetGreenfield ();

1537

  state->m_rx = htCapabilities.GetRxHighestSupportedAntennas ();

1538

  state->m_streams = htCapabilities.GetRxHighestSupportedAntennas ();

1538

1539

1540

void

1541

void

Lines 1813-1821	Link Here

1813

1814

1815

uint8_t

1816

uint8_t

1816

WifiRemoteStationManager::GetNumberOfSupportedRxAntennas (const WifiRemoteStation *station) const

1817

WifiRemoteStationManager::GetNumberOfSupportedStreams (const WifiRemoteStation *station) const

1817

1818

  return station->m_state->m_rx;

1819

  return station->m_state->m_streams;

1819

1820

1821

uint32_t

1822

uint32_t

Lines 1893-1902	Link Here

1893

  m_defaultTxPowerLevel = txPower;

1894

  m_defaultTxPowerLevel = txPower;

1894

1895

1896

uint32_t

1897

uint8_t

1897

WifiRemoteStationManager::GetNumberOfTransmitAntennas (void)

1898

WifiRemoteStationManager::GetNumberOfAntennas (void)

1898

1899

  return m_wifiPhy->GetNumberOfTransmitAntennas ();

1900

  return m_wifiPhy->GetNumberOfAntennas ();

1901

1902

1903

uint8_t

1904

WifiRemoteStationManager::GetMaxNumberOfTransmitStreams (void)

1905

1906

  return m_wifiPhy->GetMaxSupportedTxSpatialStreams ();

1900

1907

1901

1908

1902

WifiRemoteStationInfo::WifiRemoteStationInfo ()

1909

WifiRemoteStationInfo::WifiRemoteStationInfo ()




   */
  void SetDefaultTxPowerLevel (uint8_t txPower);
  /**
   * \return the number of antennas supported by the phy layer
   */
  uint8_t GetNumberOfAntennas (void);
  /**
   * \return the maximum number of spatial streams supported by the phy layer
   */
  uint8_t GetMaxNumberOfTransmitStreams (void);

  /**
   * TracedCallback signature for power change events.

  bool GetGreenfield (const WifiRemoteStation *station) const;

  /**
   * Return the number of supported streams the station has.
   *
   * \param station the station being queried
   *
   * \return the number of supported streams the station has
   */
  uint8_t GetNumberOfSupportedStreams (const WifiRemoteStation *station) const;
  /**
   * \returns the number of Ness the station has.
   *


  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
  uint8_t m_streams;          //!< Number of supported streams by the remote station
  uint32_t m_ness;            //!< Number of streams in beamforming of the remote station
  bool m_stbc;                //!< Flag if STBC is supported by the remote station
  bool m_aggregation;         //!< Flag if MPDU aggregation is used by the remote station

(-)a/src/wifi/model/wifi-tx-vector.cc (-3 / +20 lines)

Lines 28-33	Link Here

  : m_retries (0),

  : m_retries (0),

    m_channelWidth (20),

    m_channelWidth (20),

    m_shortGuardInterval (false),

    m_shortGuardInterval (false),

    m_nTx (1),

    m_nss (1),

    m_nss (1),

    m_ness (0),

    m_ness (0),

    m_aggregation (false),

    m_aggregation (false),

Lines 37-50	Link Here

WifiTxVector::WifiTxVector (WifiMode mode, uint8_t powerLevel, uint8_t retries,

WifiTxVector::WifiTxVector (WifiMode mode, uint8_t powerLevel,

                            bool shortGuardInterval, uint8_t nss, uint8_t ness,

                            uint8_t retries, bool shortGuardInterval,

                            uint32_t channelWidth, bool aggregation, bool stbc)

                            uint8_t nTx, uint8_t nss,

                            uint8_t ness, uint32_t channelWidth,

                            bool aggregation, bool stbc)

  : m_mode (mode),

  : m_mode (mode),

    m_txPowerLevel (powerLevel),

    m_txPowerLevel (powerLevel),

    m_retries (retries),

    m_retries (retries),

    m_channelWidth (channelWidth),

    m_channelWidth (channelWidth),

    m_shortGuardInterval (shortGuardInterval),

    m_shortGuardInterval (shortGuardInterval),

    m_nTx (nTx),

    m_nss (nss),

    m_nss (nss),

    m_ness (ness),

    m_ness (ness),

    m_aggregation (aggregation),

    m_aggregation (aggregation),

Lines 93-98	Link Here

uint8_t

uint8_t

100

WifiTxVector::GetNTx (void) const

101

102

  return m_nTx;

103

104

105

uint8_t

WifiTxVector::GetNss (void) const

106

WifiTxVector::GetNss (void) const

107

  return m_nss;

108

  return m_nss;

Lines 149-154	Link Here

149

159

150

160

151

void

161

void

162

WifiTxVector::SetNTx (uint8_t nTx)

163

164

  m_nTx = nTx;

165

166

167

void

152

WifiTxVector::SetNss (uint8_t nss)

168

WifiTxVector::SetNss (uint8_t nss)

153

169

154

  m_nss = nss;

170

  m_nss = nss;

Lines 179-184	Link Here

179

    " retries: " << (uint32_t)v.GetRetries () <<

195

    " retries: " << (uint32_t)v.GetRetries () <<

180

    " channel width: " << v.GetChannelWidth () <<

196

    " channel width: " << v.GetChannelWidth () <<

181

    " Short GI: " << v.IsShortGuardInterval () <<

197

    " Short GI: " << v.IsShortGuardInterval () <<

198

    " NTx: " << (uint32_t)v.GetNTx () <<

182

    " Nss: " << (uint32_t)v.GetNss () <<

199

    " Nss: " << (uint32_t)v.GetNss () <<

183

    " Ness: " << (uint32_t)v.GetNess () <<

200

    " Ness: " << (uint32_t)v.GetNess () <<

184

    " MPDU aggregation: " << v.IsAggregation () <<

201

    " MPDU aggregation: " << v.IsAggregation () <<




   * \param powerLevel transmission power level
   * \param retries retries
   * \param shortGuardInterval enable or disable short guard interval
   * \param nTx the number of TX antennas
   * \param nss the number of spatial STBC streams (NSS)
   * \param ness the number of extension spatial streams (NESS)
   * \param channelWidth the channel width in MHz

                uint8_t powerLevel,
                uint8_t retries,
                bool shortGuardInterval,
                uint8_t nTx,
                uint8_t nss,
                uint8_t ness,
                uint32_t channelWidth,

  */
  void SetShortGuardInterval (bool guardinterval);
  /**
   * \returns the number of TX antennas
   */
  uint8_t GetNTx (void) const;
  /**
   * Sets the number of TX antennas
   *
   * \param nTx
   */
  void SetNTx (uint8_t nTx);
  /**
   * \returns the number of Nss
   */
  uint8_t GetNss (void) const;

                                 for Click radiotap information */
  uint32_t m_channelWidth;       /**< channel width in MHz */
  bool     m_shortGuardInterval; /**< true if short GI is going to be used */
  uint8_t  m_nTx;                /**< number of TX antennas */
  uint8_t  m_nss;                /**< number of spatial streams */
  uint8_t  m_ness;               /**< number of spatial streams in beamforming */
  bool     m_aggregation;        /** Flag whether the PSDU contains A-MPDU. */
  bool     m_stbc;               /**< STBC used or not */





      NS_FATAL_ERROR ("MCS value does not match NSS value: MCS = " << (uint16_t)txVector.GetMode ().GetMcsValue () << ", NSS = " << (uint16_t)txVector.GetNss ());
    }
  
  if (txVector.GetNss () > GetMaxSupportedRxSpatialStreams ())
    {
      NS_FATAL_ERROR ("Reception ends in failure because of an unsupported number of spatial streams");
      NotifyRxDrop (packet);
      NS_LOG_INFO ("Reception ends in failure because less RX antennas than number of spatial streams");
      SwitchMaybeToCcaBusy ();
      return;
    }

  enum WifiPreamble preamble = tag.GetWifiPreamble ();

   */
  NS_ASSERT (!m_state->IsStateTx () && !m_state->IsStateSwitching ());
  
  if (txVector.GetNss () > GetMaxSupportedTxSpatialStreams ())
    {
      NS_FATAL_ERROR ("Unsupported number of spatial streams!");
    }

  if (m_state->IsStateSleep ())

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

Lines 73-79	Link Here

  WifiPreamble preamble;

  WifiPreamble preamble;

  preamble = WIFI_PREAMBLE_LONG;

  preamble = WIFI_PREAMBLE_LONG;

  WifiMode mode = WifiPhy::GetOfdmRate6Mbps ();

  WifiMode mode = WifiPhy::GetOfdmRate6Mbps ();

  WifiTxVector txVector = WifiTxVector (mode, 0, 0, false, 1, 0, 20000000, false, false);

  WifiTxVector txVector = WifiTxVector (mode, 0, 0, false, 1, 1, 0, 20000000, false, false);

  enum mpduType mpdutype = NORMAL_MPDU;

  enum mpduType mpdutype = NORMAL_MPDU;

  Ptr<Packet> pkt = Create<Packet> (1000);

  Ptr<Packet> pkt = Create<Packet> (1000);

Return to bug 2533