Attachment #3193 for bug #3000

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

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

Lines 137-144 int main (int argc, char *argv[])	Link Here

137

          YansWifiPhyHelper phy = YansWifiPhyHelper::Default ();

137

          YansWifiPhyHelper phy = YansWifiPhyHelper::Default ();

138

          phy.SetChannel (channel.Create ());

138

          phy.SetChannel (channel.Create ());

139

140

          // Set guard interval

141

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

142

          // Set MIMO capabilities

140

          // Set MIMO capabilities

143

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

141

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

144

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

142

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

Lines 184-189 int main (int argc, char *argv[])	Link Here

184

              Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/ChannelWidth", UintegerValue (40));

182

              Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/ChannelWidth", UintegerValue (40));

185

183

186

184

185

          // Set guard interval

186

          Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/HtConfiguration/ShortGuardIntervalSupported", BooleanValue (shortGuardInterval));

187

          // mobility.

188

          // mobility.

188

          MobilityHelper mobility;

189

          MobilityHelper mobility;

189

          Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator> ();

190

          Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator> ();




              YansWifiPhyHelper phy = YansWifiPhyHelper::Default ();
              phy.SetChannel (channel.Create ());

              // Set guard interval
              phy.Set ("GuardInterval", TimeValue (NanoSeconds (gi)));

              WifiMacHelper mac;
              WifiHelper wifi;
              if (frequency == 5.0)

              NetDeviceContainer apDevice;
              apDevice = wifi.Install (phy, mac, wifiApNode);

              // Set channel width and guard interval
              Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/ChannelWidth", UintegerValue (channelWidth));
              Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/HeConfiguration/GuardInterval", TimeValue (NanoSeconds (gi)));

              // mobility.
              MobilityHelper mobility;




              YansWifiPhyHelper phy = YansWifiPhyHelper::Default ();
              phy.SetChannel (channel.Create ());

              // Set guard interval
              phy.Set ("ShortGuardEnabled", BooleanValue (sgi));

              WifiMacHelper mac;
              WifiHelper wifi;
              if (frequency == 5.0)


              // Set channel width
              Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/ChannelWidth", UintegerValue (channelWidth));
              
              // Set guard interval
              Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/HtConfiguration/ShortGuardIntervalSupported", BooleanValue (sgi));

              // mobility.
              MobilityHelper mobility;




#include "ns3/wifi-mac.h"
#include "ns3/packet-sink-helper.h"
#include "ns3/packet-sink.h"
#include "ns3/ht-configuration.h"

// This example shows how to configure mixed networks (i.e. mixed b/g and HT/non-HT) and how are performance in several scenarios.
//

  wifi.SetStandard (WIFI_PHY_STANDARD_80211n_2_4GHZ);
  NetDeviceContainer nNGFStaDevice, nGFStaDevice;
  mac.SetType ("ns3::StaWifiMac",
               "RifsSupported", BooleanValue (params.rifsSupported),
               "Ssid", SsidValue (ssid),
               "BE_MaxAmpduSize", UintegerValue (0),
               "BE_BlockAckThreshold", UintegerValue (2),
               "ShortSlotTimeSupported", BooleanValue (params.enableShortSlotTime));
  phy.Set ("GreenfieldEnabled", BooleanValue (false));
  nNGFStaDevice = wifi.Install (phy, mac, wifiNNGFStaNodes);
  phy.Set ("GreenfieldEnabled", BooleanValue (true));
  nGFStaDevice = wifi.Install (phy, mac, wifiNGFStaNodes);

  // AP

               "EnableBeaconJitter", BooleanValue (false),
               "BE_MaxAmpduSize", UintegerValue (0),
               "BE_BlockAckThreshold", UintegerValue (2),
               "RifsSupported", BooleanValue (params.rifsSupported),
               "RifsMode", BooleanValue (params.rifsMode),
               "EnableNonErpProtection", BooleanValue (params.enableErpProtection),
               "ShortSlotTimeSupported", BooleanValue (params.enableShortSlotTime));
  phy.Set ("GreenfieldEnabled", BooleanValue (params.apSupportsGreenfield));
  apDevice = wifi.Install (phy, mac, wifiApNode);

  // Set TXOP limit

    {
      Ptr<NetDevice> dev = wifiApNode.Get (0)->GetDevice (0);
      Ptr<WifiNetDevice> wifi_dev = DynamicCast<WifiNetDevice> (dev);
      Ptr<HtConfiguration> htConfiguration = wifi_dev->GetHtConfiguration ();
      htConfiguration->SetGreenfieldSupported (params.apSupportsGreenfield);
      htConfiguration->SetRifsSupported (params.rifsSupported);
      Ptr<WifiMac> wifi_mac = wifi_dev->GetMac ();
      PointerValue ptr;
      wifi_mac->GetAttribute ("BE_Txop", ptr);

    {
      Ptr<NetDevice> dev = wifiNNGFStaNodes.Get (0)->GetDevice (0);
      Ptr<WifiNetDevice> wifi_dev = DynamicCast<WifiNetDevice> (dev);
      Ptr<HtConfiguration> htConfiguration = wifi_dev->GetHtConfiguration ();
      htConfiguration->SetRifsSupported (params.rifsSupported);
      Ptr<WifiMac> wifi_mac = wifi_dev->GetMac ();
      PointerValue ptr;
      wifi_mac->GetAttribute ("BE_Txop", ptr);

    {
      Ptr<NetDevice> dev = wifiNGFStaNodes.Get (0)->GetDevice (0);
      Ptr<WifiNetDevice> wifi_dev = DynamicCast<WifiNetDevice> (dev);
      Ptr<HtConfiguration> htConfiguration = wifi_dev->GetHtConfiguration ();
      htConfiguration->SetGreenfieldSupported (true);
      htConfiguration->SetRifsSupported (params.rifsSupported);
      Ptr<WifiMac> wifi_mac = wifi_dev->GetMac ();
      PointerValue ptr;
      wifi_mac->GetAttribute ("BE_Txop", ptr);

(-)a/examples/wireless/rate-adaptation-distance.cc (-2 / +3 lines)

Lines 196-203 int main (int argc, char *argv[])	Link Here

196

  YansWifiChannelHelper wifiChannel = YansWifiChannelHelper::Default ();

196

  YansWifiChannelHelper wifiChannel = YansWifiChannelHelper::Default ();

197

  wifiPhy.SetChannel (wifiChannel.Create ());

197

  wifiPhy.SetChannel (wifiChannel.Create ());

198

199

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

200

201

  NetDeviceContainer wifiApDevices;

199

  NetDeviceContainer wifiApDevices;

202

  NetDeviceContainer wifiStaDevices;

200

  NetDeviceContainer wifiStaDevices;

203

  NetDeviceContainer wifiDevices;

201

  NetDeviceContainer wifiDevices;

Lines 296-301 int main (int argc, char *argv[])	Link Here

296

  // Set channel width

294

  // Set channel width

297

  Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/ChannelWidth", UintegerValue (chWidth));

295

  Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/ChannelWidth", UintegerValue (chWidth));

298

296

297

  // Set guard interval

298

  Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/HtConfiguration/ShortGuardIntervalSupported", BooleanValue (shortGuardInterval));

299

  // Configure the mobility.

300

  // Configure the mobility.

300

  MobilityHelper mobility;

301

  MobilityHelper mobility;

301

  Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator> ();

302

  Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator> ();




              YansWifiPhyHelper phy = YansWifiPhyHelper::Default ();
              phy.SetChannel (channel.Create ());

              // Set guard interval
              phy.Set ("ShortGuardEnabled", BooleanValue (sgi));

              WifiHelper wifi;
              wifi.SetStandard (WIFI_PHY_STANDARD_80211ac);
              WifiMacHelper mac;

              // Set channel width
              Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/ChannelWidth", UintegerValue (channelWidth));

              // Set guard interval
              Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/HtConfiguration/ShortGuardIntervalSupported", BooleanValue (sgi));

              // mobility.
              MobilityHelper mobility;
              Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator> ();




  YansWifiPhyHelper phy = YansWifiPhyHelper::Default ();
  phy.SetChannel (channel.Create ());

  // Set guard interval
  phy.Set ("ShortGuardEnabled", BooleanValue (useShortGuardInterval));

  WifiMacHelper mac;
  WifiHelper wifi;
  wifi.SetStandard (WIFI_PHY_STANDARD_80211n_5GHZ);

  // Set channel width
  Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/ChannelWidth", UintegerValue (channelWidth));

  // Set guard interval
  Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/HtConfiguration/ShortGuardIntervalSupported", BooleanValue (useShortGuardInterval));

  // mobility
  MobilityHelper mobility;
  Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator> ();




          phy.Set ("TxPowerStart", DoubleValue (1)); // dBm (1.26 mW)
          phy.Set ("TxPowerEnd", DoubleValue (1));
          phy.Set ("Frequency", UintegerValue (5180));

          if (i <= 7)
            {
              phy.Set ("ShortGuardEnabled", BooleanValue (false));
              phy.Set ("ChannelWidth", UintegerValue (20));
            }
          else if (i > 7 && i <= 15)
            {
              phy.Set ("ShortGuardEnabled", BooleanValue (true));
              phy.Set ("ChannelWidth", UintegerValue (20));
            }
          else if (i > 15 && i <= 23)
            {
              phy.Set ("ShortGuardEnabled", BooleanValue (false));
              phy.Set ("ChannelWidth", UintegerValue (40));
            }
          else
            {
              phy.Set ("ShortGuardEnabled", BooleanValue (true));
              phy.Set ("ChannelWidth", UintegerValue (40));
            }
        }
      else if (wifiType == "ns3::SpectrumWifiPhy")
        {

          spectrumPhy.Set ("Frequency", UintegerValue (5180));
          spectrumPhy.Set ("TxPowerStart", DoubleValue (1)); // dBm  (1.26 mW)
          spectrumPhy.Set ("TxPowerEnd", DoubleValue (1));

          if (i <= 7)
            {
              spectrumPhy.Set ("ShortGuardEnabled", BooleanValue (false));
              spectrumPhy.Set ("ChannelWidth", UintegerValue (20));
            }
          else if (i > 7 && i <= 15)
            {
              spectrumPhy.Set ("ShortGuardEnabled", BooleanValue (true));
              spectrumPhy.Set ("ChannelWidth", UintegerValue (20));
            }
          else if (i > 15 && i <= 23)
            {
              spectrumPhy.Set ("ShortGuardEnabled", BooleanValue (false));
              spectrumPhy.Set ("ChannelWidth", UintegerValue (40));
            }
          else
            {
              spectrumPhy.Set ("ShortGuardEnabled", BooleanValue (true));
              spectrumPhy.Set ("ChannelWidth", UintegerValue (40));
            }
        }
      else
        {

          apDevice = wifi.Install (spectrumPhy, mac, wifiApNode);
        }

      if (i <= 7)
        {
          Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/ChannelWidth", UintegerValue (20));
          Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/HtConfiguration/ShortGuardIntervalSupported", BooleanValue (false));
        }
      else if (i > 7 && i <= 15)
        {
          Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/ChannelWidth", UintegerValue (20));
          Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/HtConfiguration/ShortGuardIntervalSupported", BooleanValue (true));
        }
      else if (i > 15 && i <= 23)
        {
          Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/ChannelWidth", UintegerValue (40));
          Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/HtConfiguration/ShortGuardIntervalSupported", BooleanValue (false));
        }
      else
        {
          Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/ChannelWidth", UintegerValue (40));
          Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/HtConfiguration/ShortGuardIntervalSupported", BooleanValue (true));
        }

      // mobility.
      MobilityHelper mobility;
      Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator> ();




          channel.SetPropagationDelay ("ns3::ConstantSpeedPropagationDelayModel");
          phy.SetChannel (channel.Create ());
          phy.Set ("Frequency", UintegerValue (5180));

          if (i <= 7)
            {
              phy.Set ("ShortGuardEnabled", BooleanValue (false));
              phy.Set ("ChannelWidth", UintegerValue (20));
            }
          else if (i > 7 && i <= 15)
            {
              phy.Set ("ShortGuardEnabled", BooleanValue (true));
              phy.Set ("ChannelWidth", UintegerValue (20));
            }
          else if (i > 15 && i <= 23)
            {
              phy.Set ("ShortGuardEnabled", BooleanValue (false));
              phy.Set ("ChannelWidth", UintegerValue (40));
            }
          else
            {
              phy.Set ("ShortGuardEnabled", BooleanValue (true));
              phy.Set ("ChannelWidth", UintegerValue (40));
            }
        }
      else if (wifiType == "ns3::SpectrumWifiPhy")
        {

          spectrumPhy.SetChannel (spectrumChannel);
          spectrumPhy.SetErrorRateModel (errorModelType);
          spectrumPhy.Set ("Frequency", UintegerValue (5180)); // channel 36 at 20 MHz

          if (i <= 7)
            {
              spectrumPhy.Set ("ShortGuardEnabled", BooleanValue (false));
              spectrumPhy.Set ("ChannelWidth", UintegerValue (20));
            }
          else if (i > 7 && i <= 15)
            {
              spectrumPhy.Set ("ShortGuardEnabled", BooleanValue (true));
              spectrumPhy.Set ("ChannelWidth", UintegerValue (20));
            }
          else if (i > 15 && i <= 23)
            {
              spectrumPhy.Set ("ShortGuardEnabled", BooleanValue (false));
              spectrumPhy.Set ("ChannelWidth", UintegerValue (40));
            }
          else
            {
              spectrumPhy.Set ("ShortGuardEnabled", BooleanValue (true));
              spectrumPhy.Set ("ChannelWidth", UintegerValue (40));
            }
        }
      else
        {

          apDevice = wifi.Install (spectrumPhy, mac, wifiApNode);
        }

      if (i <= 7)
        {
          Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/ChannelWidth", UintegerValue (20));
          Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/HtConfiguration/ShortGuardIntervalSupported", BooleanValue (false));
        }
      else if (i > 7 && i <= 15)
        {
          Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/ChannelWidth", UintegerValue (20));
          Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/HtConfiguration/ShortGuardIntervalSupported", BooleanValue (true));
        }
      else if (i > 15 && i <= 23)
        {
          Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/ChannelWidth", UintegerValue (40));
          Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/HtConfiguration/ShortGuardIntervalSupported", BooleanValue (false));
        }
      else
        {
          Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/ChannelWidth", UintegerValue (40));
          Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/HtConfiguration/ShortGuardIntervalSupported", BooleanValue (true));
        }

      // mobility.
      MobilityHelper mobility;
      Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator> ();




          phy.Set ("TxPowerStart", DoubleValue (1));
          phy.Set ("TxPowerEnd", DoubleValue (1));

          if (i > 31 && i <= 39)
            {
              phy.Set ("ShortGuardEnabled", BooleanValue (false));
              channelWidth = 20;
            }
          else if (i > 7 && i <= 15)
            {
              phy.Set ("ShortGuardEnabled", BooleanValue (true));
              channelWidth = 20;
            }
          else if (i > 15 && i <= 23)
            {
              phy.Set ("ShortGuardEnabled", BooleanValue (false));
              channelWidth = 40;
            }
          else if (i > 23 && i <= 31)
            {
              phy.Set ("ShortGuardEnabled", BooleanValue (true));
              channelWidth = 40;
            }
          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 (wifiType == "ns3::SpectrumWifiPhy")

          spectrumPhy.Set ("TxPowerStart", DoubleValue (1));
          spectrumPhy.Set ("TxPowerEnd", DoubleValue (1));

          if (i > 31 && i <= 39)
            {
              spectrumPhy.Set ("ShortGuardEnabled", BooleanValue (false));
              channelWidth = 20;
            }
          else if (i > 7 && i <= 15)
            {
              spectrumPhy.Set ("ShortGuardEnabled", BooleanValue (true));
              channelWidth = 20;
            }
          else if (i > 15 && i <= 23)
            {
              spectrumPhy.Set ("ShortGuardEnabled", BooleanValue (false));
              channelWidth = 40;
            }
          else if (i > 23 && i <= 31)
            {
              spectrumPhy.Set ("ShortGuardEnabled", BooleanValue (true));
              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;
            }
        }
      else

          apDevice = wifi.Install (spectrumPhy, mac, wifiApNode);
        }

     if ((i <= 7) || (i > 31 && i <= 39))
        {
          Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/ChannelWidth", UintegerValue (20));
          Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/HtConfiguration/ShortGuardIntervalSupported", BooleanValue (false));
        }
      else if ((i > 7 && i <= 15) || (i > 39 && i <= 47))
        {
          Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/ChannelWidth", UintegerValue (20));
          Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/HtConfiguration/ShortGuardIntervalSupported", BooleanValue (true));
        }
      else if ((i > 15 && i <= 23) || (i > 47 && i <= 55))
        {
          Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/ChannelWidth", UintegerValue (40));
          Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/HtConfiguration/ShortGuardIntervalSupported", BooleanValue (false));
        }
      else
        {
          Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/ChannelWidth", UintegerValue (40));
          Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/HtConfiguration/ShortGuardIntervalSupported", BooleanValue (true));
        }

      // mobility.
      MobilityHelper mobility;

(-)a/src/wave/helper/wave-helper.cc (-1 / +1 lines)

Lines 392-398 WaveHelper::Install (const WifiPhyHelper &phyHelper, const WifiMacHelper &macHe	Link Here

392

      for (std::vector<uint32_t>::const_iterator k = m_macsForChannelNumber.begin ();

392

      for (std::vector<uint32_t>::const_iterator k = m_macsForChannelNumber.begin ();

393

           k != m_macsForChannelNumber.end (); ++k)

393

           k != m_macsForChannelNumber.end (); ++k)

394

395

          Ptr<WifiMac> wifiMac = macHelper.Create ();

395

          Ptr<WifiMac> wifiMac = macHelper.Create (device);

396

          Ptr<OcbWifiMac> ocbMac = DynamicCast<OcbWifiMac> (wifiMac);

396

          Ptr<OcbWifiMac> ocbMac = DynamicCast<OcbWifiMac> (wifiMac);

397

          // we use WaveMacLow to replace original MacLow

397

          // we use WaveMacLow to replace original MacLow

398

          ocbMac->EnableForWave (device);

398

          ocbMac->EnableForWave (device);

(-)a/src/wave/model/wave-net-device.h (-2 / +2 lines)

Lines 25-31	Link Here

#include "ns3/packet.h"

#include "ns3/packet.h"

#include "ns3/traced-callback.h"

#include "ns3/traced-callback.h"

#include "ns3/mac48-address.h"

#include "ns3/mac48-address.h"

#include "ns3/net-device.h"

#include "ns3/wifi-net-device.h"

#include "ocb-wifi-mac.h"

#include "ocb-wifi-mac.h"

#include "vendor-specific-action.h"

#include "vendor-specific-action.h"

#include "channel-coordinator.h"

#include "channel-coordinator.h"

Lines 157-163 struct TxProfile	Link Here

157

 * UtcTime GetUtcTime ();

157

 * UtcTime GetUtcTime ();

158

 * void SetUtcTime ();

158

 * void SetUtcTime ();

159

*/

159

*/

160

class WaveNetDevice : public NetDevice

160

class WaveNetDevice : public WifiNetDevice

161

162

public:

162

public:

163

/**

163

/**

(-)a/src/wifi/examples/wifi-manager-example.cc (-4 / +8 lines)

Lines 54-59	Link Here

#include "ns3/packet-socket-helper.h"

#include "ns3/packet-socket-helper.h"

#include "ns3/packet-socket-client.h"

#include "ns3/packet-socket-client.h"

#include "ns3/packet-socket-server.h"

#include "ns3/packet-socket-server.h"

#include "ns3/ht-configuration.h"

#include "ns3/he-configuration.h"

using namespace ns3;

using namespace ns3;

Lines 420-436 int main (int argc, char *argv[])	Link Here

420

      || serverSelectedStandard.m_name == "802.11ac")

422

      || serverSelectedStandard.m_name == "802.11ac")

421

423

422

      wifiPhyPtrServer->SetChannelWidth (serverSelectedStandard.m_width);

424

      wifiPhyPtrServer->SetChannelWidth (serverSelectedStandard.m_width);

423

      wifiPhyPtrServer->SetShortGuardInterval (serverShortGuardInterval == 400);

424

      wifiPhyPtrClient->SetChannelWidth (clientSelectedStandard.m_width);

425

      wifiPhyPtrClient->SetChannelWidth (clientSelectedStandard.m_width);

425

      wifiPhyPtrClient->SetShortGuardInterval (clientShortGuardInterval == 400);

426

      Ptr<HtConfiguration> clientHtConfiguration = wndClient->GetHtConfiguration ();

427

      clientHtConfiguration->SetShortGuardIntervalSupported (clientShortGuardInterval == 400);

428

      Ptr<HtConfiguration> serverHtConfiguration = wndServer->GetHtConfiguration ();

429

      serverHtConfiguration->SetShortGuardIntervalSupported (serverShortGuardInterval == 400);

426

430

427

  else if (serverSelectedStandard.m_name == "802.11ax-5GHz"

431

  else if (serverSelectedStandard.m_name == "802.11ax-5GHz"

428

           || serverSelectedStandard.m_name == "802.11ax-2.4GHz")

432

           || serverSelectedStandard.m_name == "802.11ax-2.4GHz")

429

433

430

      wifiPhyPtrServer->SetChannelWidth (serverSelectedStandard.m_width);

434

      wifiPhyPtrServer->SetChannelWidth (serverSelectedStandard.m_width);

431

      wifiPhyPtrServer->SetGuardInterval (NanoSeconds (serverShortGuardInterval));

432

      wifiPhyPtrClient->SetChannelWidth (clientSelectedStandard.m_width);

435

      wifiPhyPtrClient->SetChannelWidth (clientSelectedStandard.m_width);

433

      wifiPhyPtrClient->SetGuardInterval (NanoSeconds (clientShortGuardInterval));

436

      wndServer->GetHeConfiguration ()->SetGuardInterval (NanoSeconds (clientShortGuardInterval));

437

      wndClient->GetHeConfiguration ()->SetGuardInterval (NanoSeconds (clientShortGuardInterval));

434

438

435

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

439

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

436

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

440

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

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

Lines 34-39	Link Here

#include "ns3/net-device-queue-interface.h"

#include "ns3/net-device-queue-interface.h"

#include "ns3/wifi-mac-queue.h"

#include "ns3/wifi-mac-queue.h"

#include "ns3/qos-utils.h"

#include "ns3/qos-utils.h"

#include "ns3/ht-configuration.h"

#include "ns3/vht-configuration.h"

#include "ns3/he-configuration.h"

#include "wifi-helper.h"

#include "wifi-helper.h"

namespace ns3 {

namespace ns3 {

Lines 646-653 WifiHelper::Install (const WifiPhyHelper &phyHelper,	Link Here

646

649

647

      Ptr<Node> node = *i;

650

      Ptr<Node> node = *i;

648

      Ptr<WifiNetDevice> device = CreateObject<WifiNetDevice> ();

651

      Ptr<WifiNetDevice> device = CreateObject<WifiNetDevice> ();

652

      if (m_standard >= WIFI_PHY_STANDARD_80211n_2_4GHZ)

653

654

          Ptr<HtConfiguration> htConfiguration = CreateObject<HtConfiguration> ();

655

          device->SetHtConfiguration (htConfiguration);

656

657

      if ((m_standard == WIFI_PHY_STANDARD_80211ac) || (m_standard == WIFI_PHY_STANDARD_80211ax_5GHZ))

658

659

          Ptr<VhtConfiguration> vhtConfiguration = CreateObject<VhtConfiguration> ();

660

          device->SetVhtConfiguration (vhtConfiguration);

661

662

      if (m_standard >= WIFI_PHY_STANDARD_80211ax_2_4GHZ)

663

664

          Ptr<HeConfiguration> heConfiguration = CreateObject<HeConfiguration> ();

665

          device->SetHeConfiguration (heConfiguration);

666

649

      Ptr<WifiRemoteStationManager> manager = m_stationManager.Create<WifiRemoteStationManager> ();

667

      Ptr<WifiRemoteStationManager> manager = m_stationManager.Create<WifiRemoteStationManager> ();

650

      Ptr<WifiMac> mac = macHelper.Create ();

668

      Ptr<WifiMac> mac = macHelper.Create (device);

651

      Ptr<WifiPhy> phy = phyHelper.Create (node, device);

669

      Ptr<WifiPhy> phy = phyHelper.Create (node, device);

652

      mac->SetAddress (Mac48Address::Allocate ());

670

      mac->SetAddress (Mac48Address::Allocate ());

653

      mac->ConfigureStandard (m_standard);

671

      mac->ConfigureStandard (m_standard);




 * Author: Sébastien Deronne <sebastien.deronne@gmail.com>
 */

#include "ns3/net-device.h"
#include "wifi-mac-helper.h"
#include "ns3/wifi-mac.h"
#include "ns3/boolean.h"

}

Ptr<WifiMac>
WifiMacHelper::Create (Ptr<NetDevice> device) const
{
  Ptr<WifiMac> mac = m_mac.Create<WifiMac> ();
  mac->SetDevice (device);
  return mac;
}


(-)a/src/wifi/helper/wifi-mac-helper.h (-1 / +2 lines)

Lines 26-31	Link Here

namespace ns3 {

namespace ns3 {

class WifiMac;

class WifiMac;

class NetDevice;

/**

/**

 * \brief create MAC layers for a ns3::WifiNetDevice.

 * \brief create MAC layers for a ns3::WifiNetDevice.

Lines 103-109 public:	Link Here

103

104

   * This allows the ns3::WifiHelper class to create MAC objects from ns3::WifiHelper::Install.

105

   * This allows the ns3::WifiHelper class to create MAC objects from ns3::WifiHelper::Install.

105

*/

106

*/

106

  virtual Ptr<WifiMac> Create (void) const;

107

  virtual Ptr<WifiMac> Create (Ptr<NetDevice> device) const;

107

108

109

protected:

110

protected:




  NS_LOG_FUNCTION (this);
}

void
AarfWifiManager::DoInitialize ()
{
  NS_LOG_FUNCTION (this);
  if (GetHtSupported ())
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support HT rates");
    }
  if (GetVhtSupported ())
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support VHT rates");
    }
  if (GetHeSupported ())
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support HE rates");
    }
}

WifiRemoteStation *
AarfWifiManager::DoCreateStation (void) const
{

  return true;
}

void
AarfWifiManager::SetHtSupported (bool enable)
{
  //HT is not supported by this algorithm.
  if (enable)
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support HT rates");
    }
}

void
AarfWifiManager::SetVhtSupported (bool enable)
{
  //VHT is not supported by this algorithm.
  if (enable)
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support VHT rates");
    }
}

void
AarfWifiManager::SetHeSupported (bool enable)
{
  //HE is not supported by this algorithm.
  if (enable)
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support HE rates");
    }
}

} //namespace ns3




  AarfWifiManager ();
  virtual ~AarfWifiManager ();

  // Inherited from WifiRemoteStationManager
  void SetHtSupported (bool enable);
  void SetVhtSupported (bool enable);
  void SetHeSupported (bool enable);

private:
  // Overridden from base class.
  void DoInitialize (void);
  WifiRemoteStation * DoCreateStation (void) const;
  void DoReportRxOk (WifiRemoteStation *station,
                     double rxSnr, WifiMode txMode);




  NS_LOG_FUNCTION (this);
}

void
AarfcdWifiManager::DoInitialize ()
{
  NS_LOG_FUNCTION (this);
  if (GetHtSupported ())
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support HT rates");
    }
  if (GetVhtSupported ())
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support VHT rates");
    }
  if (GetHeSupported ())
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support HE rates");
    }
}

WifiRemoteStation *
AarfcdWifiManager::DoCreateStation (void) const
{

  station->m_rtsWnd = m_minRtsWnd;
}

void
AarfcdWifiManager::SetHtSupported (bool enable)
{
  //HT is not supported by this algorithm.
  if (enable)
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support HT rates");
    }
}

void
AarfcdWifiManager::SetVhtSupported (bool enable)
{
  //VHT is not supported by this algorithm.
  if (enable)
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support VHT rates");
    }
}

void
AarfcdWifiManager::SetHeSupported (bool enable)
{
  //HE is not supported by this algorithm.
  if (enable)
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support HE rates");
    }
}

} //namespace ns3




  AarfcdWifiManager ();
  virtual ~AarfcdWifiManager ();

  // Inherited from WifiRemoteStationManager
  void SetHtSupported (bool enable);
  void SetVhtSupported (bool enable);
  void SetHeSupported (bool enable);

private:
  // Overridden from base class.
  void DoInitialize (void);
  WifiRemoteStation * DoCreateStation (void) const;
  void DoReportRxOk (WifiRemoteStation *station,
                     double rxSnr, WifiMode txMode);




  NS_LOG_FUNCTION (this);
}

void
AmrrWifiManager::DoInitialize ()
{
  NS_LOG_FUNCTION (this);
  if (GetHtSupported ())
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support HT rates");
    }
  if (GetVhtSupported ())
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support VHT rates");
    }
  if (GetHeSupported ())
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support HE rates");
    }
}

WifiRemoteStation *
AmrrWifiManager::DoCreateStation (void) const
{

  return true;
}

void
AmrrWifiManager::SetHtSupported (bool enable)
{
  //HT is not supported by this algorithm.
  if (enable)
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support HT rates");
    }
}

void
AmrrWifiManager::SetVhtSupported (bool enable)
{
  //VHT is not supported by this algorithm.
  if (enable)
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support VHT rates");
    }
}

void
AmrrWifiManager::SetHeSupported (bool enable)
{
  //HE is not supported by this algorithm.
  if (enable)
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support HE rates");
    }
}

} //namespace ns3




  AmrrWifiManager ();
  virtual ~AmrrWifiManager ();

  // Inherited from WifiRemoteStationManager
  void SetHtSupported (bool enable);
  void SetVhtSupported (bool enable);
  void SetHeSupported (bool enable);


private:
  // Overridden from base class.
  void DoInitialize (void);
  WifiRemoteStation * DoCreateStation (void) const;
  void DoReportRxOk (WifiRemoteStation *station,
                     double rxSnr, WifiMode txMode);

(-)a/src/wifi/model/ap-wifi-mac.cc (-3 / +9 lines)

Lines 34-39	Link Here

#include "msdu-aggregator.h"

#include "msdu-aggregator.h"

#include "amsdu-subframe-header.h"

#include "amsdu-subframe-header.h"

#include "wifi-phy.h"

#include "wifi-phy.h"

#include "wifi-net-device.h"

#include "ht-configuration.h"

namespace ns3 {

namespace ns3 {

Lines 562-567 ApWifiMac::GetHtOperation (void) const	Link Here

562

  HtOperation operation;

564

  HtOperation operation;

563

  if (GetHtSupported ())

565

  if (GetHtSupported ())

564

566

567

      Ptr<WifiNetDevice> device = DynamicCast<WifiNetDevice> (GetDevice ());

568

      Ptr<HtConfiguration> htConfiguration = device->GetHtConfiguration ();

565

      operation.SetHtSupported (1);

569

      operation.SetHtSupported (1);

566

      operation.SetPrimaryChannel (m_phy->GetChannelNumber ());

570

      operation.SetPrimaryChannel (m_phy->GetChannelNumber ());

567

      operation.SetRifsMode (GetRifsMode ());

571

      operation.SetRifsMode (GetRifsMode ());

Lines 589-595 ApWifiMac::GetHtOperation (void) const	Link Here

589

593

590

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

594

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

591

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

595

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

592

          uint64_t dataRate = mcs.GetDataRate (m_phy->GetChannelWidth (), m_phy->GetShortGuardInterval () ? 400 : 800, nss);

596

          uint64_t dataRate = mcs.GetDataRate (m_phy->GetChannelWidth (), htConfiguration->GetShortGuardIntervalSupported () ? 400 : 800, nss);

593

          if (dataRate > maxSupportedRate)

597

          if (dataRate > maxSupportedRate)

594

598

595

              maxSupportedRate = dataRate;

599

              maxSupportedRate = dataRate;

Lines 612-618 ApWifiMac::GetHtOperation (void) const	Link Here

612

616

613

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

617

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

614

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

618

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

615

                  uint64_t dataRate = mcs.GetDataRate (m_stationManager->GetChannelWidthSupported (i->second), m_stationManager->GetShortGuardInterval (i->second) ? 400 : 800, nss);

619

                  uint64_t dataRate = mcs.GetDataRate (m_stationManager->GetChannelWidthSupported (i->second), m_stationManager->GetShortGuardIntervalSupported (i->second) ? 400 : 800, nss);

616

                  if (dataRate > maxSupportedRateByHtSta)

620

                  if (dataRate > maxSupportedRateByHtSta)

617

621

618

                      maxSupportedRateByHtSta = dataRate;

622

                      maxSupportedRateByHtSta = dataRate;

Lines 1584-1590 ApWifiMac::GetRifsMode (void) const	Link Here

1584

          rifsMode = true;

1588

          rifsMode = true;

1585

1589

1586

1590

1587

  if (GetRifsSupported () && rifsMode)

1591

  Ptr<WifiNetDevice> device = DynamicCast<WifiNetDevice> (GetDevice ());

1592

  Ptr<HtConfiguration> htConfiguration = device->GetHtConfiguration ();

1593

  if (htConfiguration && htConfiguration->GetRifsSupported () && rifsMode)

1588

1594

1589

      m_stationManager->SetRifsPermitted (true);

1595

      m_stationManager->SetRifsPermitted (true);

1590

1596




  WifiRemoteStationManager::SetupPhy (phy);
}

void
AparfWifiManager::DoInitialize ()
{
  NS_LOG_FUNCTION (this);
  if (GetHtSupported ())
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support HT rates");
    }
  if (GetVhtSupported ())
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support VHT rates");
    }
  if (GetHeSupported ())
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support HE rates");
    }
}

WifiRemoteStation *
AparfWifiManager::DoCreateStation (void) const
{

  return true;
}

void
AparfWifiManager::SetHtSupported (bool enable)
{
  //HT is not supported by this algorithm.
  if (enable)
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support HT rates");
    }
}

void
AparfWifiManager::SetVhtSupported (bool enable)
{
  //VHT is not supported by this algorithm.
  if (enable)
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support VHT rates");
    }
}

void
AparfWifiManager::SetHeSupported (bool enable)
{
  //HE is not supported by this algorithm.
  if (enable)
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support HE rates");
    }
}

} //namespace ns3





  // Inherited from WifiRemoteStationManager
  void SetupPhy (const Ptr<WifiPhy> phy);
  void SetHtSupported (bool enable);
  void SetVhtSupported (bool enable);
  void SetHeSupported (bool enable);

  /**
   * Enumeration of the possible states of the channel.



private:
  // Overridden from base class.
  void DoInitialize (void);
  WifiRemoteStation * DoCreateStation (void) const;
  void DoReportRxOk (WifiRemoteStation *station,
                     double rxSnr, WifiMode txMode);




  NS_LOG_FUNCTION (this);
}

void
ArfWifiManager::DoInitialize ()
{
  NS_LOG_FUNCTION (this);
  if (GetHtSupported ())
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support HT rates");
    }
  if (GetVhtSupported ())
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support VHT rates");
    }
  if (GetHeSupported ())
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support HE rates");
    }
}

WifiRemoteStation *
ArfWifiManager::DoCreateStation (void) const
{

  return true;
}

void
ArfWifiManager::SetHtSupported (bool enable)
{
  //HT is not supported by this algorithm.
  if (enable)
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support HT rates");
    }
}

void
ArfWifiManager::SetVhtSupported (bool enable)
{
  //VHT is not supported by this algorithm.
  if (enable)
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support VHT rates");
    }
}

void
ArfWifiManager::SetHeSupported (bool enable)
{
  //HE is not supported by this algorithm.
  if (enable)
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support HE rates");
    }
}

} //namespace ns3




  ArfWifiManager ();
  virtual ~ArfWifiManager ();

  // Inherited from WifiRemoteStationManager
  void SetHtSupported (bool enable);
  void SetVhtSupported (bool enable);
  void SetHeSupported (bool enable);


private:
  // Overridden from base class.
  void DoInitialize (void);
  WifiRemoteStation * DoCreateStation (void) const;
  void DoReportRxOk (WifiRemoteStation *station,
                     double rxSnr, WifiMode txMode);

(-)a/src/wifi/model/block-ack-manager.cc (-1 / +1 lines)

Lines 126-132 BlockAckManager::CreateAgreement (const MgtAddBaRequestHeader *reqHdr, Mac48Addr	Link Here

126

  agreement.SetWinEnd ((agreement.GetStartingSequence () + agreement.GetBufferSize () - 1) % 4096);

126

  agreement.SetWinEnd ((agreement.GetStartingSequence () + agreement.GetBufferSize () - 1) % 4096);

127

  agreement.SetTimeout (reqHdr->GetTimeout ());

127

  agreement.SetTimeout (reqHdr->GetTimeout ());

128

  agreement.SetAmsduSupport (reqHdr->IsAmsduSupported ());

128

  agreement.SetAmsduSupport (reqHdr->IsAmsduSupported ());

129

  agreement.SetHtSupported (m_stationManager->HasHtSupported ());

129

  agreement.SetHtSupported (m_stationManager->GetHtSupported ());

130

  if (reqHdr->IsImmediateBlockAck ())

130

  if (reqHdr->IsImmediateBlockAck ())

131

132

      agreement.SetImmediateBlockAck ();

132

      agreement.SetImmediateBlockAck ();




  NS_LOG_FUNCTION (this);
}

void
CaraWifiManager::DoInitialize ()
{
  NS_LOG_FUNCTION (this);
  if (GetHtSupported ())
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support HT rates");
    }
  if (GetVhtSupported ())
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support VHT rates");
    }
  if (GetHeSupported ())
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support HE rates");
    }
}

WifiRemoteStation *
CaraWifiManager::DoCreateStation (void) const
{

  return true;
}

void
CaraWifiManager::SetHtSupported (bool enable)
{
  //HT is not supported by this algorithm.
  if (enable)
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support HT rates");
    }
}

void
CaraWifiManager::SetVhtSupported (bool enable)
{
  //VHT is not supported by this algorithm.
  if (enable)
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support VHT rates");
    }
}

void
CaraWifiManager::SetHeSupported (bool enable)
{
  //HE is not supported by this algorithm.
  if (enable)
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support HE rates");
    }
}

} //namespace ns3




  CaraWifiManager ();
  virtual ~CaraWifiManager ();

  // Inherited from WifiRemoteStationManager
  void SetHtSupported (bool enable);
  void SetVhtSupported (bool enable);
  void SetHeSupported (bool enable);


private:
  // Overridden from base class.
  void DoInitialize (void);
  WifiRemoteStation * DoCreateStation (void) const;
  void DoReportRxOk (WifiRemoteStation *station,
                     double rxSnr, WifiMode txMode);




ConstantRateWifiManager::DoGetDataTxVector (WifiRemoteStation *st)
{
  NS_LOG_FUNCTION (this << st);
  return WifiTxVector (m_dataMode, GetDefaultTxPowerLevel (), GetPreambleForTransmission (m_dataMode, GetAddress (st)), ConvertGuardIntervalToNanoSeconds (m_dataMode, GetShortGuardIntervalSupported (st), NanoSeconds (GetGuardInterval (st))), GetNumberOfAntennas (), Min (GetMaxNumberOfTransmitStreams (), GetNumberOfSupportedStreams (st)), 0, GetChannelWidthForTransmission (m_dataMode, GetChannelWidth (st)), GetAggregation (st), false);
}

WifiTxVector
ConstantRateWifiManager::DoGetRtsTxVector (WifiRemoteStation *st)
{
  NS_LOG_FUNCTION (this << st);
  return WifiTxVector (m_ctlMode, GetDefaultTxPowerLevel (), GetPreambleForTransmission (m_ctlMode, GetAddress (st)), ConvertGuardIntervalToNanoSeconds (m_ctlMode, GetShortGuardIntervalSupported (st), NanoSeconds (GetGuardInterval (st))), 1, 1, 0, GetChannelWidthForTransmission (m_ctlMode, GetChannelWidth (st)), GetAggregation (st), false);
}

bool




/* -*-  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
 *
 */

#include "ns3/log.h"
#include "ns3/nstime.h"
#include "ns3/uinteger.h"
#include "he-configuration.h"

namespace ns3 {

NS_LOG_COMPONENT_DEFINE ("HeConfiguration");
NS_OBJECT_ENSURE_REGISTERED (HeConfiguration);

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

TypeId
HeConfiguration::GetTypeId (void)
{
  static ns3::TypeId tid = ns3::TypeId ("ns3::HeConfiguration")
    .SetParent<Object> ()
    .SetGroupName ("Wifi")
    .AddConstructor<HeConfiguration> ()
    .AddAttribute ("GuardInterval",
                   "Specify the shortest guard interval duration that can be used for HE transmissions."
                   "Possible values are 800ns, 1600ns or 3200ns.",
                   TimeValue (NanoSeconds (3200)),
                   MakeTimeAccessor (&HeConfiguration::GetGuardInterval,
                                     &HeConfiguration::SetGuardInterval),
                   MakeTimeChecker (NanoSeconds (800), NanoSeconds (3200)))
    ;
    return tid;
}

void
HeConfiguration::SetGuardInterval (Time guardInterval)
{
  NS_LOG_FUNCTION (this << guardInterval);
  NS_ASSERT (guardInterval == NanoSeconds (800) || guardInterval == NanoSeconds (1600) || guardInterval == NanoSeconds (3200));
  m_guardInterval = guardInterval;
}

Time
HeConfiguration::GetGuardInterval (void) const
{
  return m_guardInterval;
}

} //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
 *
 */

#ifndef HE_CONFIGURATION_H
#define HE_CONFIGURATION_H

#include "ns3/object.h"

namespace ns3 {

/**
 * \brief HE configuration
 * \ingroup wifi
 *
 * This object stores HE configuration information, for use in modifying
 * AP or STA behavior and for constructing HE-related information elements.
 *
 */
class HeConfiguration : public Object
{
public:
  HeConfiguration ();
  static TypeId GetTypeId (void);

  /**
   * \param guardInterval the supported HE guard interval
   */
  void SetGuardInterval (Time guardInterval);
  /**
   * \return the supported HE guard interval
   */
  Time GetGuardInterval (void) const;


private:
  Time m_guardInterval; //!< Supported HE guard interval
};

} //namespace ns3

#endif /* HE_CONFIGURATION_H */




/* -*-  Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2018  Sébastien Deronne
 *
 * 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/boolean.h"
#include "ht-configuration.h"

namespace ns3 {

NS_LOG_COMPONENT_DEFINE ("HtConfiguration");

NS_OBJECT_ENSURE_REGISTERED (HtConfiguration);

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

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

TypeId
HtConfiguration::GetTypeId (void)
{
  static ns3::TypeId tid = ns3::TypeId ("ns3::HtConfiguration")
    .SetParent<Object> ()
    .SetGroupName ("Wifi")
    .AddConstructor<HtConfiguration> ()
    .AddAttribute ("ShortGuardIntervalSupported",
                   "Whether or not short guard interval is supported.",
                   BooleanValue (false),
                   MakeBooleanAccessor (&HtConfiguration::GetShortGuardIntervalSupported,
                                        &HtConfiguration::SetShortGuardIntervalSupported),
                   MakeBooleanChecker ())
    .AddAttribute ("GreenfieldSupported",
                   "Whether or not Greenfield is supported.",
                   BooleanValue (false),
                   MakeBooleanAccessor (&HtConfiguration::GetGreenfieldSupported,
                                        &HtConfiguration::SetGreenfieldSupported),
                   MakeBooleanChecker ())
    .AddAttribute ("RifsSupported",
                   "Whether or not RIFS is supported.",
                   BooleanValue (false),
                   MakeBooleanAccessor (&HtConfiguration::SetRifsSupported,
                                        &HtConfiguration::GetRifsSupported),
                   MakeBooleanChecker ())
    ;
    return tid;
}

void
HtConfiguration::SetShortGuardIntervalSupported (bool enable)
{
  NS_LOG_FUNCTION (this << enable);
  m_sgiSupported = enable;
}

bool
HtConfiguration::GetShortGuardIntervalSupported (void) const
{
  return m_sgiSupported;
}

void
HtConfiguration::SetGreenfieldSupported (bool enable)
{
  NS_LOG_FUNCTION (this << enable);
  m_greenfieldSupported = enable;
}

bool
HtConfiguration::GetGreenfieldSupported (void) const
{
  return m_greenfieldSupported;
}

void
HtConfiguration::SetRifsSupported (bool enable)
{
  NS_LOG_FUNCTION (this << enable);
  m_rifsSupported = enable;
}

bool
HtConfiguration::GetRifsSupported (void) const
{
  return m_rifsSupported;
}

} //namespace ns3




/* -*-  Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2018  Sébastien Deronne
 *
 * 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 HT_CONFIGURATION_H
#define HT_CONFIGURATION_H

#include "ns3/object.h"

namespace ns3 {

/**
 * \brief HT configuration
 * \ingroup wifi
 *
 * This object stores HT configuration information, for use in modifying
 * AP or STA behavior and for constructing HT-related information elements.
 *
 */
class HtConfiguration : public Object
{
public:
  HtConfiguration ();
  virtual ~HtConfiguration ();

  static TypeId GetTypeId (void);

  /**
   * Enable or disable SGI support.
   *
   * \param enable true if SGI is to be supported,
   *               false otherwise
   */
  void SetShortGuardIntervalSupported (bool enable);
  /**
   * \return whether the device supports SGI.
   *
   * \return true if SGI is supported,
   *         false otherwise.
   */
  bool GetShortGuardIntervalSupported (void) const;

  /**
   * Enable or disable Greenfield support.
   *
   * \param enable true if Greenfield is to be supported,
   *               false otherwise
   */
  void SetGreenfieldSupported (bool enable);
  /**
   * \return whether the device supports Greenfield.
   *
   * \return true if Greenfield is supported,
   *         false otherwise.
   */
  bool GetGreenfieldSupported (void) const;

  /**
   * Enable or disable RIFS support.
   *
   * \param enable true if RIFS is to be supported,
   *               false otherwise
   */
  void SetRifsSupported (bool enable);
  /**
   * \return whether the device supports RIFS capability.
   *
   * \return true if short RIFS is supported,
   *         false otherwise.
   */
  bool GetRifsSupported (void) const;


private:
  bool m_sgiSupported; ///< flag whether short guard interval is supported
  bool m_rifsSupported; ///< flag whether RIFS is supported
  bool m_greenfieldSupported; ///< flag whether Greenfield is supported
};

} //namespace ns3

#endif /* HT_CONFIGURATION_H */




      AddSnrThreshold (txVector, GetPhy ()->CalculateSnr (txVector, m_ber));
    }
  // Add all Ht and Vht MCSes
  if (GetHtSupported () || GetVhtSupported () || GetHeSupported ())
    {
      nModes = GetPhy ()->GetNMcs ();
      for (uint8_t i = 0; i < nModes; i++)

              mode = GetPhy ()->GetMcs (i);
              if (mode.GetModulationClass () == WIFI_MOD_CLASS_HT)
                {
                  uint16_t guardInterval = GetShortGuardIntervalSupported () ? 400 : 800;
                  txVector.SetGuardInterval (guardInterval);
                  //derive NSS from the MCS index
                  nss = (mode.GetMcsValue () / 8) + 1;

                  uint16_t guardInterval;
                  if (mode.GetModulationClass () == WIFI_MOD_CLASS_VHT)
                    {
                      guardInterval = GetShortGuardIntervalSupported () ? 400 : 800;
                    }
                  else
                    {
                      guardInterval = GetGuardInterval ();
                    }
                  txVector.SetGuardInterval (guardInterval);
                  for (uint8_t k = 1; k <= GetPhy ()->GetMaxSupportedTxSpatialStreams (); k++)

    }
  else
    {
      if ((GetHtSupported () || GetVhtSupported () || GetHeSupported ())
          && (GetHtSupported (st) || GetVhtSupported (st) || GetHeSupported (st)))
        {
          for (uint8_t i = 0; i < GetNMcsSupported (station); i++)
            {

              txVector.SetMode (mode);
              if (mode.GetModulationClass () == WIFI_MOD_CLASS_HT)
                {
                  guardInterval = static_cast<uint16_t> (std::max (GetShortGuardIntervalSupported (station) ? 400 : 800, GetShortGuardIntervalSupported () ? 400 : 800));
                  txVector.SetGuardInterval (guardInterval);
                  // If the node and peer are both VHT capable, only search VHT modes
                  if (GetVhtSupported () && GetVhtSupported (station))
                    {
                      continue;
                    }
                  // If the node and peer are both HE capable, only search HE modes
                  if (GetHeSupported () && GetHeSupported (station))
                    {
                      continue;
                    }

                }
              else if (mode.GetModulationClass () == WIFI_MOD_CLASS_VHT)
                {
                  guardInterval = static_cast<uint16_t> (std::max (GetShortGuardIntervalSupported (station) ? 400 : 800, GetShortGuardIntervalSupported () ? 400 : 800));
                  txVector.SetGuardInterval (guardInterval);
                  // If the node and peer are both HE capable, only search HE modes
                  if (GetHeSupported () && GetHeSupported (station))
                    {
                      continue;
                    }
                  // If the node and peer are not both VHT capable, only search HT modes
                  if (!GetVhtSupported () || !GetVhtSupported (station))
                    {
                      continue;
                    }

                }
              else //HE
                {
                  guardInterval = std::max (GetGuardInterval (station), GetGuardInterval ());
                  txVector.SetGuardInterval (guardInterval);
                  // If the node and peer are not both HE capable, only search (V)HT modes
                  if (!GetHeSupported () || !GetHeSupported (station))
                    {
                      continue;
                    }

  NS_LOG_DEBUG ("Found maxMode: " << maxMode << " channelWidth: " << channelWidth);
  if (maxMode.GetModulationClass () == WIFI_MOD_CLASS_HE)
    {
      guardInterval = std::max (GetGuardInterval (station), GetGuardInterval ());
    }
  else if ((maxMode.GetModulationClass () == WIFI_MOD_CLASS_HT) || (maxMode.GetModulationClass () == WIFI_MOD_CLASS_VHT))
    {
      guardInterval = static_cast<uint16_t> (std::max (GetShortGuardIntervalSupported (station) ? 400 : 800, GetShortGuardIntervalSupported () ? 400 : 800));
    }
  else
    {
      guardInterval = 800;
    }
  if (m_currentRate != maxMode.GetDataRate (channelWidth, guardInterval, selectedNss))
    {




                ", seq=0x" << std::hex << m_currentHdr.GetSequenceControl () << std::dec);
  if (!m_ampdu || hdr->IsAck () || hdr->IsRts () || hdr->IsCts () || hdr->IsBlockAck () || hdr->IsMgt ())
    {
      if (hdr->IsCfPoll () && m_stationManager->GetPcfSupported ())
        {
          Simulator::Schedule (GetPifs () + m_phy->CalculateTxDuration (packet->GetSize (), txVector, m_phy->GetFrequency ()), &MacLow::CfPollTimeout, this);
        }
      if (hdr->IsBeacon () && m_stationManager->GetPcfSupported ())
        {
          if (Simulator::Now () > m_lastBeacon + m_beaconInterval)
            {

            }
          m_lastBeacon = Simulator::Now ();
        }
      else if (hdr->IsCfEnd () && m_stationManager->GetPcfSupported ())
        {
          m_cfpStart = NanoSeconds (0);
          m_cfpForeshortening = NanoSeconds (0);

MacLow::EndTxNoAck (void)
{
  NS_LOG_FUNCTION (this);
  if (m_currentHdr.IsBeacon () && m_stationManager->GetPcfSupported ())
    {
      m_cfpStart = Simulator::Now ();
    }

bool
MacLow::ReceiveMpdu (Ptr<Packet> packet, WifiMacHeader hdr)
{
  if (m_stationManager->GetHtSupported ()
      || m_stationManager->GetVhtSupported ()
      || m_stationManager->GetHeSupported ())
    {
      Mac48Address originator = hdr.GetAddr2 ();
      uint8_t tid = 0;

          (*i).second.FillBlockAckBitmap (&blockAck);
          NS_LOG_DEBUG ("Got block Ack Req with seq " << reqHdr.GetStartingSequence ());

          if (!m_stationManager->GetHtSupported ()
              && !m_stationManager->GetVhtSupported ()
              && !m_stationManager->GetHeSupported ())
            {
              /* All packets with smaller sequence than starting sequence control must be passed up to Wifimac
               * See 9.10.3 in IEEE 802.11e standard.

  AcIndex ac = QosUtilsMapTidToAc (tid);
  std::map<AcIndex, Ptr<QosTxop> >::const_iterator edcaIt = m_edca.find (ac);

  if (m_stationManager->GetGreenfieldSupported ())
    {
      aPPDUMaxTime = MicroSeconds (10000);
    }

bool
MacLow::IsCfPeriod (void) const
{
  return (m_stationManager->GetPcfSupported () && m_cfpStart.IsStrictlyPositive ());
}

bool




MinstrelHtWifiManager::~MinstrelHtWifiManager ()
{
  NS_LOG_FUNCTION (this);
  for (uint8_t i = 0; i < m_numGroups; i++)
    {
      m_minstrelGroups[i].ratesFirstMpduTxTimeTable.clear ();
      m_minstrelGroups[i].ratesTxTimeTable.clear ();
          m_minstrelGroups[i].ratesFirstMpduTxTimeTable.clear ();
          m_minstrelGroups[i].ratesTxTimeTable.clear ();
        }
    }
}


}

void
MinstrelHtWifiManager::SetupMac (const Ptr<WifiMac> mac)
{
  NS_LOG_FUNCTION (this << mac);
  m_legacyManager->SetupMac (mac);
  WifiRemoteStationManager::SetupMac (mac);
}

void
MinstrelHtWifiManager::DoInitialize ()
{
  NS_LOG_FUNCTION (this);
  if (GetHeSupported ())
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support HE rates");
    }
  /**
   * Here we initialize m_minstrelGroups with all the possible groups.
   * If a group is not supported by the device, then it is marked as not supported.

   */

  // Check if the device supports HT or VHT
  if (GetHtSupported () || GetVhtSupported ())
    {
      m_numGroups = MAX_SUPPORTED_STREAMS * MAX_HT_STREAM_GROUPS;
      m_numRates = MAX_HT_GROUP_RATES;

      if (GetVhtSupported ())
        {
          m_numGroups += MAX_SUPPORTED_STREAMS * MAX_VHT_STREAM_GROUPS;
          m_numRates = MAX_VHT_GROUP_RATES;

                  m_minstrelGroups[groupId].isSupported = false;

                  // Check capabilities of the device
                  if (!(!GetShortGuardIntervalSupported () && 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?
                    {

            }
        }

      if (GetVhtSupported ())
        {
          // Initialize all VHT groups
          for (uint16_t chWidth = 20; chWidth <= MAX_VHT_WIDTH; chWidth *= 2)

                      m_minstrelGroups[groupId].isSupported = false;

                      // Check capabilities of the device
                      if (!(!GetShortGuardIntervalSupported () && 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?
                        {

    }
}

void
MinstrelHtWifiManager::SetupMac (const Ptr<WifiMac> mac)
{
  NS_LOG_FUNCTION (this << mac);
  m_legacyManager->SetupMac (mac);
  WifiRemoteStationManager::SetupMac (mac);
}

bool
MinstrelHtWifiManager::IsValidMcs (Ptr<WifiPhy> phy, uint8_t streams, uint16_t chWidth, WifiMode mode)
{

  txvector.SetGuardInterval (sgi ? 400 : 800);
  txvector.SetChannelWidth (chWidth);
  txvector.SetNess (0);
  txvector.SetStbc (0);
  txvector.SetMode (mode);
  txvector.SetPreambleType (WIFI_PREAMBLE_HT_MF);
  return phy->CalculateTxDuration (m_frameLength, txvector, phy->GetFrequency (), MPDU_IN_AGGREGATE, 0);

  txvector.SetGuardInterval (sgi ? 400 : 800);
  txvector.SetChannelWidth (chWidth);
  txvector.SetNess (0);
  txvector.SetStbc (0);
  txvector.SetMode (mode);
  txvector.SetPreambleType (WIFI_PREAMBLE_NONE);
  return phy->CalculateTxDuration (m_frameLength, txvector, phy->GetFrequency (), MPDU_IN_AGGREGATE, 0);

  station->m_ampduPacketCount = 0;

  // If the device supports HT
  if (GetHtSupported () || GetVhtSupported ())
    {
      /**
       * Assume the station is HT.

      McsGroup group = m_minstrelGroups[groupId];

      // Check consistency of rate selected.
      if ((group.sgi && !GetShortGuardIntervalSupported (station)) || group.chWidth > GetChannelWidth (station)  ||  group.streams > GetNumberOfSupportedStreams (station))
        {
          NS_FATAL_ERROR ("Inconsistent group selected. Group: (" << +group.streams <<
                         "," << +group.sgi << "," << group.chWidth << ")" <<
                         " Station capabilities: (" << GetNumberOfSupportedStreams (station) <<
                         "," << GetShortGuardIntervalSupported (station) << "," << GetChannelWidth (station) << ")");
        }
      WifiMode mode = GetMcsSupported (station, mcsIndex);
      uint64_t dataRate = mode.GetDataRate (group.chWidth, group.sgi ? 400 : 800, group.streams);

          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
              && !(!GetShortGuardIntervalSupported (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?
            {

  return htMcsList;
}

void
MinstrelHtWifiManager::SetHeSupported (bool enable)
{
  //HE is not supported yet by this algorithm.
  if (enable)
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support HE rates");
    }
}

} // namespace ns3

(-)a/src/wifi/model/minstrel-ht-wifi-manager.h (-1 lines)

Lines 204-210 public:	Link Here

204

  // Inherited from WifiRemoteStationManager

204

  // Inherited from WifiRemoteStationManager

205

  void SetupPhy (const Ptr<WifiPhy> phy);

205

  void SetupPhy (const Ptr<WifiPhy> phy);

206

  void SetupMac (const Ptr<WifiMac> mac);

206

  void SetupMac (const Ptr<WifiMac> mac);

207

  void SetHeSupported (bool enable); //HE rates not yet supported

208

207

209

/**

208

/**

210

   * TracedCallback signature for rate change events.

209

   * TracedCallback signature for rate change events.




  WifiRemoteStationManager::SetupMac (mac);
}

void
MinstrelWifiManager::DoInitialize ()
{
  NS_LOG_FUNCTION (this);
  if (GetHtSupported ())
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support HT rates");
    }
  if (GetVhtSupported ())
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support VHT rates");
    }
  if (GetHeSupported ())
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support HE rates");
    }
}

int64_t
MinstrelWifiManager::AssignStreams (int64_t stream)
{

  station->m_statsFile.flush ();
}

void
MinstrelWifiManager::SetHtSupported (bool enable)
{
  //HT is not supported by this algorithm.
  if (enable)
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support HT rates");
    }
}

void
MinstrelWifiManager::SetVhtSupported (bool enable)
{
  //VHT is not supported by this algorithm.
  if (enable)
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support VHT rates");
    }
}

void
MinstrelWifiManager::SetHeSupported (bool enable)
{
  //HE is not supported by this algorithm.
  if (enable)
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support HE rates");
    }
}

} //namespace ns3




  // Inherited from WifiRemoteStationManager
  void SetupPhy (const Ptr<WifiPhy> phy);
  void SetupMac (const Ptr<WifiMac> mac);
  void SetHtSupported (bool enable);
  void SetVhtSupported (bool enable);
  void SetHeSupported (bool enable);

  /**
   * Assign a fixed random variable stream number to the random variables

  void InitSampleTable (MinstrelWifiRemoteStation *station);

private:
  // Overridden from base class.
  void DoInitialize (void);
  WifiRemoteStation * DoCreateStation (void) const;
  void DoReportRxOk (WifiRemoteStation *station,
                     double rxSnr, WifiMode txMode);




  NS_LOG_FUNCTION (this);
}

void
OnoeWifiManager::DoInitialize ()
{
  NS_LOG_FUNCTION (this);
  if (GetHtSupported ())
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support HT rates");
    }
  if (GetVhtSupported ())
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support VHT rates");
    }
  if (GetHeSupported ())
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support HE rates");
    }
}

WifiRemoteStation *
OnoeWifiManager::DoCreateStation (void) const
{

  return false;
}

void
OnoeWifiManager::SetHtSupported (bool enable)
{
  //HT is not supported by this algorithm.
  if (enable)
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support HT rates");
    }
}

void
OnoeWifiManager::SetVhtSupported (bool enable)
{
  //VHT is not supported by this algorithm.
  if (enable)
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support VHT rates");
    }
}

void
OnoeWifiManager::SetHeSupported (bool enable)
{
  //HE is not supported by this algorithm.
  if (enable)
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support HE rates");
    }
}

} //namespace ns3




  OnoeWifiManager ();
  virtual ~OnoeWifiManager ();

  // Inherited from WifiRemoteStationManager
  void SetHtSupported (bool enable);
  void SetVhtSupported (bool enable);
  void SetHeSupported (bool enable);


private:
  // Overridden from base class.
  void DoInitialize (void);
  WifiRemoteStation * DoCreateStation (void) const;
  void DoReportRxOk (WifiRemoteStation *station,
                     double rxSnr, WifiMode txMode);




  WifiRemoteStationManager::SetupPhy (phy);
}

void
ParfWifiManager::DoInitialize ()
{
  NS_LOG_FUNCTION (this);
  if (GetHtSupported ())
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support HT rates");
    }
  if (GetVhtSupported ())
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support VHT rates");
    }
  if (GetHeSupported ())
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support HE rates");
    }
}

WifiRemoteStation *
ParfWifiManager::DoCreateStation (void) const
{

  return true;
}

void
ParfWifiManager::SetHtSupported (bool enable)
{
  //HT is not supported by this algorithm.
  if (enable)
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support HT rates");
    }
}

void
ParfWifiManager::SetVhtSupported (bool enable)
{
  //VHT is not supported by this algorithm.
  if (enable)
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support VHT rates");
    }
}

void
ParfWifiManager::SetHeSupported (bool enable)
{
  //HE is not supported by this algorithm.
  if (enable)
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support HE rates");
    }
}

} //namespace ns3





  // Inherited from WifiRemoteStationManager
  void SetupPhy (const Ptr<WifiPhy> phy);
  void SetHtSupported (bool enable);
  void SetVhtSupported (bool enable);
  void SetHeSupported (bool enable);


private:
  // Overridden from base class.
  void DoInitialize (void);
  WifiRemoteStation * DoCreateStation (void) const;
  void DoReportRxOk (WifiRemoteStation *station,
                     double rxSnr, WifiMode txMode);




QosTxop::NeedFragmentation (void) const
{
  NS_LOG_FUNCTION (this);
  if (m_stationManager->GetVhtSupported ()
      || m_stationManager->GetHeSupported ()
      || GetAmpduExist (m_currentHdr.GetAddr1 ())
      || (m_stationManager->GetHtSupported ()
          && m_currentHdr.IsQosData ()
          && GetBaAgreementExists (m_currentHdr.GetAddr1 (), GetTid (m_currentPacket, m_currentHdr))
          && GetMpduAggregator ()->GetMaxAmpduSize () >= m_currentPacket->GetSize ()))

  uint32_t packets = m_queue->GetNPacketsByTidAndAddress (tid, recipient);
  if ((GetBlockAckThreshold () > 0 && packets >= GetBlockAckThreshold ())
      || (m_mpduAggregator != 0 && m_mpduAggregator->GetMaxAmpduSize () > 0 && packets > 1)
      || m_stationManager->GetVhtSupported ()
      || m_stationManager->GetHeSupported ())
    {
      /* Block ack setup */
      uint16_t startingSequence = m_txMiddle->GetNextSeqNumberByTidAndAddress (tid, recipient);

(-)a/src/wifi/model/regular-wifi-mac.cc (-93 / +102 lines)

Lines 31-36	Link Here

#include "wifi-utils.h"

#include "wifi-utils.h"

#include "mgt-headers.h"

#include "mgt-headers.h"

#include "amsdu-subframe-header.h"

#include "amsdu-subframe-header.h"

#include "wifi-net-device.h"

#include "ht-configuration.h"

#include "vht-configuration.h"

#include "he-configuration.h"

namespace ns3 {

namespace ns3 {

Lines 40-50 NS_OBJECT_ENSURE_REGISTERED (RegularWifiMac);	Link Here

RegularWifiMac::RegularWifiMac ()

RegularWifiMac::RegularWifiMac ()

  : m_qosSupported (0),

  : m_qosSupported (0),

    m_htSupported (0),

    m_vhtSupported (0),

    m_erpSupported (0),

    m_erpSupported (0),

    m_dsssSupported (0),

    m_dsssSupported (0)

    m_heSupported (0)

  NS_LOG_FUNCTION (this);

  NS_LOG_FUNCTION (this);

  m_rxMiddle = Create<MacRxMiddle> ();

  m_rxMiddle = Create<MacRxMiddle> ();

Lines 117-122 RegularWifiMac::DoDispose ()	Link Here

117

118

  m_channelAccessManager->Dispose ();

119

  m_channelAccessManager->Dispose ();

119

  m_channelAccessManager = 0;

120

  m_channelAccessManager = 0;

121

122

  WifiMac::DoDispose ();

120

123

121

124

122

void

125

void

Lines 124-136 RegularWifiMac::SetWifiRemoteStationManager (const Ptr<WifiRemoteStationManager>	Link Here

124

127

125

  NS_LOG_FUNCTION (this << stationManager);

128

  NS_LOG_FUNCTION (this << stationManager);

126

  m_stationManager = stationManager;

129

  m_stationManager = stationManager;

127

  m_stationManager->SetHtSupported (GetHtSupported ());

128

  m_stationManager->SetVhtSupported (GetVhtSupported ());

129

  m_stationManager->SetHeSupported (GetHeSupported ());

130

  m_low->SetWifiRemoteStationManager (stationManager);

130

  m_low->SetWifiRemoteStationManager (stationManager);

131

132

  m_txop->SetWifiRemoteStationManager (stationManager);

131

  m_txop->SetWifiRemoteStationManager (stationManager);

133

134

  for (EdcaQueues::const_iterator i = m_edca.begin (); i != m_edca.end (); ++i)

132

  for (EdcaQueues::const_iterator i = m_edca.begin (); i != m_edca.end (); ++i)

135

133

136

      i->second->SetWifiRemoteStationManager (stationManager);

134

      i->second->SetWifiRemoteStationManager (stationManager);

Lines 148-164 RegularWifiMac::GetExtendedCapabilities (void) const	Link Here

148

146

149

  NS_LOG_FUNCTION (this);

147

  NS_LOG_FUNCTION (this);

150

  ExtendedCapabilities capabilities;

148

  ExtendedCapabilities capabilities;

151

  if (m_htSupported || m_vhtSupported)

149

  capabilities.SetHtSupported (GetHtSupported ());

152

150

  capabilities.SetVhtSupported (GetVhtSupported ());

153

      if (m_htSupported)

154

155

          capabilities.SetHtSupported (1);

156

157

      if (m_vhtSupported)

158

159

          capabilities.SetVhtSupported (1);

160

161

162

  //TODO: to be completed

151

  //TODO: to be completed

163

  return capabilities;

152

  return capabilities;

164

153

Lines 168-184 RegularWifiMac::GetHtCapabilities (void) const	Link Here

168

157

169

  NS_LOG_FUNCTION (this);

158

  NS_LOG_FUNCTION (this);

170

  HtCapabilities capabilities;

159

  HtCapabilities capabilities;

171

  if (m_htSupported)

160

  if (GetHtSupported ())

172

161

162

      Ptr<WifiNetDevice> device = DynamicCast<WifiNetDevice> (GetDevice ());

163

      Ptr<HtConfiguration> htConfiguration = device->GetHtConfiguration ();

164

      bool greenfieldSupported = htConfiguration->GetGreenfieldSupported ();

165

      bool sgiSupported = htConfiguration->GetShortGuardIntervalSupported ();

173

      capabilities.SetHtSupported (1);

166

      capabilities.SetHtSupported (1);

174

      capabilities.SetLdpc (m_phy->GetLdpc ());

167

      capabilities.SetLdpc (0);

175

      capabilities.SetSupportedChannelWidth (m_phy->GetChannelWidth () >= 40);

168

      capabilities.SetSupportedChannelWidth (m_phy->GetChannelWidth () >= 40);

176

      capabilities.SetShortGuardInterval20 (m_phy->GetShortGuardInterval ());

169

      capabilities.SetShortGuardInterval20 (sgiSupported);

177

      capabilities.SetShortGuardInterval40 (m_phy->GetChannelWidth () >= 40 && m_phy->GetShortGuardInterval ());

170

      capabilities.SetShortGuardInterval40 (m_phy->GetChannelWidth () >= 40 && sgiSupported);

178

      capabilities.SetGreenfield (m_phy->GetGreenfield ());

171

      capabilities.SetGreenfield (greenfieldSupported);

179

      uint32_t maxAmsduLength = std::max (std::max (m_beMaxAmsduSize, m_bkMaxAmsduSize), std::max (m_voMaxAmsduSize, m_viMaxAmsduSize));

172

      uint32_t maxAmsduLength = std::max (std::max (m_beMaxAmsduSize, m_bkMaxAmsduSize), std::max (m_voMaxAmsduSize, m_viMaxAmsduSize));

180

      capabilities.SetMaxAmsduLength (maxAmsduLength > 3839); //0 if 3839 and 1 if 7935

173

      capabilities.SetMaxAmsduLength (maxAmsduLength > 3839); //0 if 3839 and 1 if 7935

181

      capabilities.SetLSigProtectionSupport (!m_phy->GetGreenfield ());

174

      capabilities.SetLSigProtectionSupport (!greenfieldSupported);

182

      double maxAmpduLengthExponent = std::max (std::ceil ((std::log (std::max (std::max (m_beMaxAmpduSize, m_bkMaxAmpduSize), std::max (m_voMaxAmpduSize, m_viMaxAmpduSize))

175

      double maxAmpduLengthExponent = std::max (std::ceil ((std::log (std::max (std::max (m_beMaxAmpduSize, m_bkMaxAmpduSize), std::max (m_voMaxAmpduSize, m_viMaxAmpduSize))

183

                                                                      + 1.0)

176

                                                                      + 1.0)

184

                                                            / std::log (2.0))

177

                                                            / std::log (2.0))

Lines 197-203 RegularWifiMac::GetHtCapabilities (void) const	Link Here

197

          capabilities.SetRxMcsBitmask (mcs.GetMcsValue ());

190

          capabilities.SetRxMcsBitmask (mcs.GetMcsValue ());

198

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

191

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

199

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

192

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

200

          uint64_t dataRate = mcs.GetDataRate (m_phy->GetChannelWidth (), m_phy->GetShortGuardInterval () ? 400 : 800, nss);

193

          uint64_t dataRate = mcs.GetDataRate (m_phy->GetChannelWidth (), sgiSupported ? 400 : 800, nss);

201

          if (dataRate > maxSupportedRate)

194

          if (dataRate > maxSupportedRate)

202

195

203

              maxSupportedRate = dataRate;

196

              maxSupportedRate = dataRate;

Lines 219-226 RegularWifiMac::GetVhtCapabilities (void) const	Link Here

219

212

220

  NS_LOG_FUNCTION (this);

213

  NS_LOG_FUNCTION (this);

221

  VhtCapabilities capabilities;

214

  VhtCapabilities capabilities;

222

  if (m_vhtSupported)

215

  if (GetVhtSupported ())

223

216

217

      Ptr<WifiNetDevice> device = DynamicCast<WifiNetDevice> (GetDevice ());

218

      Ptr<HtConfiguration> htConfiguration = device->GetHtConfiguration ();

219

      bool sgiSupported = htConfiguration->GetShortGuardIntervalSupported ();

224

      capabilities.SetVhtSupported (1);

220

      capabilities.SetVhtSupported (1);

225

      if (m_phy->GetChannelWidth () == 160)

221

      if (m_phy->GetChannelWidth () == 160)

226

222

Lines 232-240 RegularWifiMac::GetVhtCapabilities (void) const	Link Here

232

228

233

      uint32_t maxMpduLength = std::max (std::max (m_beMaxAmsduSize, m_bkMaxAmsduSize), std::max (m_voMaxAmsduSize, m_viMaxAmsduSize)) + 56; //see section 9.11 of 11ac standard

229

      uint32_t maxMpduLength = std::max (std::max (m_beMaxAmsduSize, m_bkMaxAmsduSize), std::max (m_voMaxAmsduSize, m_viMaxAmsduSize)) + 56; //see section 9.11 of 11ac standard

234

      capabilities.SetMaxMpduLength (uint8_t (maxMpduLength > 3895) + uint8_t (maxMpduLength > 7991)); //0 if 3895, 1 if 7991, 2 for 11454

230

      capabilities.SetMaxMpduLength (uint8_t (maxMpduLength > 3895) + uint8_t (maxMpduLength > 7991)); //0 if 3895, 1 if 7991, 2 for 11454

235

      capabilities.SetRxLdpc (m_phy->GetLdpc ());

231

      capabilities.SetRxLdpc (0);

236

      capabilities.SetShortGuardIntervalFor80Mhz ((m_phy->GetChannelWidth () == 80) && m_phy->GetShortGuardInterval ());

232

      capabilities.SetShortGuardIntervalFor80Mhz ((m_phy->GetChannelWidth () == 80) && sgiSupported);

237

      capabilities.SetShortGuardIntervalFor160Mhz ((m_phy->GetChannelWidth () == 160) && m_phy->GetShortGuardInterval ());

233

      capabilities.SetShortGuardIntervalFor160Mhz ((m_phy->GetChannelWidth () == 160) && sgiSupported);

238

      double maxAmpduLengthExponent = std::max (std::ceil ((std::log (std::max (std::max (m_beMaxAmpduSize, m_bkMaxAmpduSize), std::max (m_voMaxAmpduSize, m_viMaxAmpduSize)) + 1.0) / std::log (2.0)) - 13.0), 0.0);

234

      double maxAmpduLengthExponent = std::max (std::ceil ((std::log (std::max (std::max (m_beMaxAmpduSize, m_bkMaxAmpduSize), std::max (m_voMaxAmpduSize, m_viMaxAmpduSize)) + 1.0) / std::log (2.0)) - 13.0), 0.0);

239

      NS_ASSERT (maxAmpduLengthExponent >= 0 && maxAmpduLengthExponent <= 255);

235

      NS_ASSERT (maxAmpduLengthExponent >= 0 && maxAmpduLengthExponent <= 255);

240

      capabilities.SetMaxAmpduLengthExponent (std::max<uint8_t> (7, static_cast<uint8_t> (maxAmpduLengthExponent))); //0 to 7 for VHT

236

      capabilities.SetMaxAmpduLengthExponent (std::max<uint8_t> (7, static_cast<uint8_t> (maxAmpduLengthExponent))); //0 to 7 for VHT

Lines 285-292 RegularWifiMac::GetHeCapabilities (void) const	Link Here

285

281

286

  NS_LOG_FUNCTION (this);

282

  NS_LOG_FUNCTION (this);

287

  HeCapabilities capabilities;

283

  HeCapabilities capabilities;

288

  if (m_heSupported)

284

  if (GetHeSupported ())

289

285

286

      Ptr<WifiNetDevice> device = DynamicCast<WifiNetDevice> (GetDevice ());

287

      Ptr<HeConfiguration> heConfiguration = device->GetHeConfiguration ();

290

      capabilities.SetHeSupported (1);

288

      capabilities.SetHeSupported (1);

291

      uint8_t channelWidthSet = 0;

289

      uint8_t channelWidthSet = 0;

292

      if (m_phy->GetChannelWidth () >= 40 && Is2_4Ghz (m_phy->GetFrequency ()))

290

      if (m_phy->GetChannelWidth () >= 40 && Is2_4Ghz (m_phy->GetFrequency ()))

Lines 303-314 RegularWifiMac::GetHeCapabilities (void) const	Link Here

303

301

304

      capabilities.SetChannelWidthSet (channelWidthSet);

302

      capabilities.SetChannelWidthSet (channelWidthSet);

305

      uint8_t gi = 0;

303

      uint8_t gi = 0;

306

      if (m_phy->GetGuardInterval () <= NanoSeconds (1600))

304

      if (heConfiguration->GetGuardInterval () <= NanoSeconds (1600))

307

305

308

          //todo: We assume for now that if we support 800ns GI then 1600ns GI is supported as well

306

          //todo: We assume for now that if we support 800ns GI then 1600ns GI is supported as well

309

          gi |= 0x01;

307

          gi |= 0x01;

310

308

311

      if (m_phy->GetGuardInterval () == NanoSeconds (800))

309

      if (heConfiguration->GetGuardInterval () == NanoSeconds (800))

312

310

313

          gi |= 0x02;

311

          gi |= 0x02;

314

312

Lines 580-655 RegularWifiMac::GetQosSupported () const	Link Here

580

void

578

void

581

RegularWifiMac::SetVhtSupported (bool enable)

579

RegularWifiMac::SetVhtSupported (bool enable)

582

580

583

  NS_LOG_FUNCTION (this << enable);

581

  //To be removed once deprecated API is cleaned up

584

  m_vhtSupported = enable;

585

  if (enable)

586

587

      SetQosSupported (true);

588

589

  if (!enable && !m_htSupported)

590

591

      DisableAggregation ();

592

593

  else

594

595

      EnableAggregation ();

596

597

582

598

583

599

void

584

void

600

RegularWifiMac::SetHtSupported (bool enable)

585

RegularWifiMac::SetHtSupported (bool enable)

601

586

602

  NS_LOG_FUNCTION (this << enable);

587

  //To be removed once deprecated API is cleaned up

603

  m_htSupported = enable;

604

  if (enable)

605

606

      SetQosSupported (true);

607

608

  if (!enable && !m_vhtSupported)

609

610

      DisableAggregation ();

611

612

  else

613

614

      EnableAggregation ();

615

616

588

617

589

618

void

590

void

619

RegularWifiMac::SetHeSupported (bool enable)

591

RegularWifiMac::SetHeSupported (bool enable)

620

592

621

  NS_LOG_FUNCTION (this << enable);

593

  //To be removed once deprecated API is cleaned up

622

  m_heSupported = enable;

623

  if (enable)

624

625

      SetQosSupported (true);

626

627

  if (!enable && !m_htSupported && !m_vhtSupported)

628

629

      DisableAggregation ();

630

631

  else

632

633

      EnableAggregation ();

634

635

594

636

595

637

bool

596

bool

638

RegularWifiMac::GetVhtSupported () const

597

RegularWifiMac::GetHtSupported () const

639

598

640

  return m_vhtSupported;

599

  Ptr<WifiNetDevice> device = DynamicCast<WifiNetDevice> (GetDevice ());

600

  if (device->GetHtConfiguration ())

601

602

      return true;

603

604

  return false;

641

605

642

606

643

bool

607

bool

644

RegularWifiMac::GetHtSupported () const

608

RegularWifiMac::GetVhtSupported () const

645

609

646

  return m_htSupported;

610

  Ptr<WifiNetDevice> device = DynamicCast<WifiNetDevice> (GetDevice ());

611

  if (device->GetVhtConfiguration ())

612

613

      return true;

614

615

  return false;

647

616

648

617

649

bool

618

bool

650

RegularWifiMac::GetHeSupported () const

619

RegularWifiMac::GetHeSupported () const

651

620

652

  return m_heSupported;

621

  Ptr<WifiNetDevice> device = DynamicCast<WifiNetDevice> (GetDevice ());

622

  if (device->GetHeConfiguration ())

623

624

      return true;

625

626

  return false;

653

627

654

628

655

bool

629

bool

Lines 870-881 void	Link Here

870

RegularWifiMac::SetRifsSupported (bool enable)

844

RegularWifiMac::SetRifsSupported (bool enable)

871

845

872

  NS_LOG_FUNCTION (this << enable);

846

  NS_LOG_FUNCTION (this << enable);

847

  Ptr<WifiNetDevice> device = DynamicCast<WifiNetDevice> (GetDevice ());

848

  if (device)

849

850

      Ptr<HtConfiguration> htConfiguration = device->GetHtConfiguration ();

851

      if (htConfiguration)

852

853

          htConfiguration->SetRifsSupported (enable);

854

855

873

  m_rifsSupported = enable;

856

  m_rifsSupported = enable;

874

857

875

858

876

bool

859

bool

877

RegularWifiMac::GetRifsSupported (void) const

860

RegularWifiMac::GetRifsSupported (void) const

878

861

862

  Ptr<WifiNetDevice> device = DynamicCast<WifiNetDevice> (GetDevice ());

863

  if (device)

864

865

      Ptr<HtConfiguration> htConfiguration = device->GetHtConfiguration ();

866

      if (htConfiguration)

867

868

          return htConfiguration->GetRifsSupported ();

869

870

879

  return m_rifsSupported;

871

  return m_rifsSupported;

880

872

881

873

Lines 1090-1108 RegularWifiMac::GetTypeId (void)	Link Here

1090

                   BooleanValue (false),

1082

                   BooleanValue (false),

1091

                   MakeBooleanAccessor (&RegularWifiMac::SetHtSupported,

1083

                   MakeBooleanAccessor (&RegularWifiMac::SetHtSupported,

1092

                                        &RegularWifiMac::GetHtSupported),

1084

                                        &RegularWifiMac::GetHtSupported),

1093

                   MakeBooleanChecker ())

1085

                   MakeBooleanChecker (),

1086

                   TypeId::DEPRECATED, "Not used anymore")

1094

    .AddAttribute ("VhtSupported",

1087

    .AddAttribute ("VhtSupported",

1095

                   "This Boolean attribute is set to enable 802.11ac support at this STA.",

1088

                   "This Boolean attribute is set to enable 802.11ac support at this STA.",

1096

                   BooleanValue (false),

1089

                   BooleanValue (false),

1097

                   MakeBooleanAccessor (&RegularWifiMac::SetVhtSupported,

1090

                   MakeBooleanAccessor (&RegularWifiMac::SetVhtSupported,

1098

                                        &RegularWifiMac::GetVhtSupported),

1091

                                        &RegularWifiMac::GetVhtSupported),

1099

                   MakeBooleanChecker ())

1092

                   MakeBooleanChecker (),

1093

                   TypeId::DEPRECATED, "Not used anymore")

1100

    .AddAttribute ("HeSupported",

1094

    .AddAttribute ("HeSupported",

1101

                   "This Boolean attribute is set to enable 802.11ax support at this STA.",

1095

                   "This Boolean attribute is set to enable 802.11ax support at this STA.",

1102

                   BooleanValue (false),

1096

                   BooleanValue (false),

1103

                   MakeBooleanAccessor (&RegularWifiMac::SetHeSupported,

1097

                   MakeBooleanAccessor (&RegularWifiMac::SetHeSupported,

1104

                                        &RegularWifiMac::GetHeSupported),

1098

                                        &RegularWifiMac::GetHeSupported),

1105

                   MakeBooleanChecker ())

1099

                   MakeBooleanChecker (),

1100

                   TypeId::DEPRECATED, "Not used anymore")

1106

    .AddAttribute ("CtsToSelfSupported",

1101

    .AddAttribute ("CtsToSelfSupported",

1107

                   "Use CTS to Self when using a rate that is not in the basic rate set.",

1102

                   "Use CTS to Self when using a rate that is not in the basic rate set.",

1108

                   BooleanValue (false),

1103

                   BooleanValue (false),

Lines 1227-1233 RegularWifiMac::GetTypeId (void)	Link Here

1227

                   BooleanValue (false),

1222

                   BooleanValue (false),

1228

                   MakeBooleanAccessor (&RegularWifiMac::SetRifsSupported,

1223

                   MakeBooleanAccessor (&RegularWifiMac::SetRifsSupported,

1229

                                        &RegularWifiMac::GetRifsSupported),

1224

                                        &RegularWifiMac::GetRifsSupported),

1230

                   MakeBooleanChecker ())

1225

                   MakeBooleanChecker (),

1226

                   TypeId::DEPRECATED, "Use the HtConfiguration instead")

1231

    .AddAttribute ("Txop",

1227

    .AddAttribute ("Txop",

1232

                   "The Txop object.",

1228

                   "The Txop object.",

1233

                   PointerValue (),

1229

                   PointerValue (),

Lines 1274-1291 RegularWifiMac::FinishConfigureStandard (WifiPhyStandard standard)	Link Here

1274

  switch (standard)

1270

  switch (standard)

1275

1271

1276

    case WIFI_PHY_STANDARD_80211ax_5GHZ:

1272

    case WIFI_PHY_STANDARD_80211ax_5GHZ:

1277

      SetHeSupported (true);

1278

    case WIFI_PHY_STANDARD_80211ac:

1273

    case WIFI_PHY_STANDARD_80211ac:

1279

      SetVhtSupported (true);

1280

    case WIFI_PHY_STANDARD_80211n_5GHZ:

1274

    case WIFI_PHY_STANDARD_80211n_5GHZ:

1281

      SetHtSupported (true);

1275

1282

      cwmin = 15;

1276

        EnableAggregation ();

1283

      cwmax = 1023;

1277

        //To be removed once deprecated RifsSupported attribute is removed

1284

      break;

1278

        Ptr<WifiNetDevice> device = DynamicCast<WifiNetDevice> (GetDevice ());

1279

        Ptr<HtConfiguration> htConfiguration = device->GetHtConfiguration ();

1280

        NS_ASSERT (htConfiguration);

1281

        htConfiguration->SetRifsSupported (m_rifsSupported);

1282

        SetQosSupported (true);

1283

        cwmin = 15;

1284

        cwmax = 1023;

1285

        break;

1286

1285

    case WIFI_PHY_STANDARD_80211ax_2_4GHZ:

1287

    case WIFI_PHY_STANDARD_80211ax_2_4GHZ:

1286

      SetHeSupported (true);

1287

    case WIFI_PHY_STANDARD_80211n_2_4GHZ:

1288

    case WIFI_PHY_STANDARD_80211n_2_4GHZ:

1288

      SetHtSupported (true);

1289

1290

        EnableAggregation ();

1291

        //To be removed once deprecated RifsSupported attribute is removed

1292

        Ptr<WifiNetDevice> device = DynamicCast<WifiNetDevice> (GetDevice ());

1293

        Ptr<HtConfiguration> htConfiguration = device->GetHtConfiguration ();

1294

        NS_ASSERT (htConfiguration);

1295

        htConfiguration->SetRifsSupported (m_rifsSupported);

1296

        SetQosSupported (true);

1297

1289

    case WIFI_PHY_STANDARD_80211g:

1298

    case WIFI_PHY_STANDARD_80211g:

1290

      SetErpSupported (true);

1299

      SetErpSupported (true);

1291

    case WIFI_PHY_STANDARD_holland:

1300

    case WIFI_PHY_STANDARD_holland:




   *
   * \param enable true if RIFS is to be supported,
   *               false otherwise
   * \deprecated
   */
  void SetRifsSupported (bool enable);
  /**

   *
   * \return true if short RIFS is supported,
   *         false otherwise.
   * \deprecated
   */
  bool GetRifsSupported (void) const;

  /**
   * \return the MAC address associated to this MAC layer.
   */

   */
  bool m_qosSupported;
  /**
    * This Boolean is set \c true iff this WifiMac is to model
    * 802.11n. It is exposed through the attribute system.
    *
    * At the moment, this flag is the sole selection between HT and
    * non-HT operation for the STA (whether IBSS, AP, or
    * non-AP). Ultimately, we will want a HT-enabled STA to be able to
    * fall back to non-HT operation with a non-HT peer. This'll
    * require further intelligence - i.e., per-association HT
    * state. Having a big switch seems like a good intermediate stage,
    * however.
    */
  bool m_htSupported;
  /**
   * This Boolean is set \c true iff this WifiMac is to model
   * 802.11ac. It is exposed through the attribute system.
   */
  bool m_vhtSupported;
  /**
   * This Boolean is set \c true iff this WifiMac is to model
   * 802.11g. It is exposed through the attribute system.
   */

   * 802.11b. It is exposed through the attribute system.
   */
  bool m_dsssSupported;
  /**
   * This Boolean is set \c true iff this WifiMac is to model
   * 802.11ax. It is exposed through the attribute system.
   */
  bool m_heSupported;

  /// Configure aggregation function
  void ConfigureAggregation (void);

  TracedCallback<const WifiMacHeader &> m_txErrCallback; ///< transmit error callback

  bool m_shortSlotTimeSupported; ///< flag whether short slot time is supported
  bool m_rifsSupported; ///< flag whether RIFS is supported (deprecated)
};

} //namespace ns3




  return tid;
}


RraaWifiManager::RraaWifiManager ()
  : WifiRemoteStationManager (),
    m_currentRate (0)

  WifiRemoteStationManager::SetupMac (mac);
}

void
RraaWifiManager::DoInitialize ()
{
  NS_LOG_FUNCTION (this);
  if (GetHtSupported ())
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support HT rates");
    }
  if (GetVhtSupported ())
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support VHT rates");
    }
  if (GetHeSupported ())
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support HE rates");
    }
}

Time
RraaWifiManager::GetCalcTxTime (WifiMode mode) const
{

  return true;
}

void
RraaWifiManager::SetHtSupported (bool enable)
{
  //HT is not supported by this algorithm.
  if (enable)
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support HT rates");
    }
}

void
RraaWifiManager::SetVhtSupported (bool enable)
{
  //VHT is not supported by this algorithm.
  if (enable)
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support VHT rates");
    }
}

void
RraaWifiManager::SetHeSupported (bool enable)
{
  //HE is not supported by this algorithm.
  if (enable)
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support HE rates");
    }
}

} //namespace ns3




  // Inherited from WifiRemoteStationManager
  virtual void SetupPhy (const Ptr<WifiPhy> phy);
  virtual void SetupMac (const Ptr<WifiMac> mac);
  void SetHtSupported (bool enable);
  void SetVhtSupported (bool enable);
  void SetHeSupported (bool enable);


private:
  // Overridden from base class.
  void DoInitialize (void);
  WifiRemoteStation * DoCreateStation (void) const;
  void DoReportRxOk (WifiRemoteStation *station,
                     double rxSnr, WifiMode txMode);




  WifiRemoteStationManager::SetupMac (mac);
}

void
RrpaaWifiManager::DoInitialize ()
{
  NS_LOG_FUNCTION (this);
  if (GetHtSupported ())
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support HT rates");
    }
  if (GetVhtSupported ())
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support VHT rates");
    }
  if (GetHeSupported ())
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support HE rates");
    }
}

Time
RrpaaWifiManager::GetCalcTxTime (WifiMode mode) const
{

  return true;
}

void
RrpaaWifiManager::SetHtSupported (bool enable)
{
  //HT is not supported by this algorithm.
  if (enable)
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support HT rates");
    }
}

void
RrpaaWifiManager::SetVhtSupported (bool enable)
{
  //VHT is not supported by this algorithm.
  if (enable)
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support VHT rates");
    }
}

void
RrpaaWifiManager::SetHeSupported (bool enable)
{
  //HE is not supported by this algorithm.
  if (enable)
    {
      NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support HE rates");
    }
}

} // namespace ns3




  // Inherited from WifiRemoteStationManager
  virtual void SetupPhy (const Ptr<WifiPhy> phy);
  virtual void SetupMac (const Ptr<WifiMac> mac);
  virtual void SetHtSupported (bool enable);
  virtual void SetVhtSupported (bool enable);
  virtual void SetHeSupported (bool enable);

  /**
   * Assign a fixed random variable stream number to the random variables

  int64_t AssignStreams (int64_t stream);

private:
  // Overridden from base class.
  void DoInitialize (void);
  virtual WifiRemoteStation * DoCreateStation (void) const;
  virtual void DoReportRxOk (WifiRemoteStation *station,
                             double rxSnr, WifiMode txMode);

(-)a/src/wifi/model/sta-wifi-mac.cc (-2 / +8 lines)

Lines 28-33	Link Here

#include "mac-low.h"

#include "mac-low.h"

#include "mgt-headers.h"

#include "mgt-headers.h"

#include "snr-tag.h"

#include "snr-tag.h"

#include "wifi-net-device.h"

#include "ht-configuration.h"

namespace ns3 {

namespace ns3 {

Lines 802-808 StaWifiMac::UpdateApInfoFromBeacon (MgtBeaconHeader beacon, Mac48Address apAddr,	Link Here

802

804

803

              m_stationManager->SetUseGreenfieldProtection (false);

805

              m_stationManager->SetUseGreenfieldProtection (false);

804

806

805

          if (!GetVhtSupported () && GetRifsSupported () && htOperation.GetRifsMode ())

807

          Ptr<WifiNetDevice> device = DynamicCast<WifiNetDevice> (GetDevice ());

808

          Ptr<HtConfiguration> htConfiguration = device->GetHtConfiguration ();

809

          if (!GetVhtSupported () && htConfiguration && htConfiguration->GetRifsSupported () && htOperation.GetRifsMode ())

806

810

807

              m_stationManager->SetRifsPermitted (true);

811

              m_stationManager->SetRifsPermitted (true);

808

812

Lines 1001-1007 StaWifiMac::UpdateApInfoFromAssocResp (MgtAssocResponseHeader assocResp, Mac48Ad	Link Here

1001

1005

1002

              m_stationManager->SetUseGreenfieldProtection (false);

1006

              m_stationManager->SetUseGreenfieldProtection (false);

1003

1007

1004

          if (!GetVhtSupported () && GetRifsSupported () && htOperation.GetRifsMode ())

1008

          Ptr<WifiNetDevice> device = DynamicCast<WifiNetDevice> (GetDevice ());

1009

          Ptr<HtConfiguration> htConfiguration = device->GetHtConfiguration ();

1010

          if (!GetVhtSupported () && htConfiguration && htConfiguration->GetRifsSupported () && htOperation.GetRifsMode ())

1005

1011

1006

              m_stationManager->SetRifsPermitted (true);

1012

              m_stationManager->SetRifsPermitted (true);

1007

1013

(-)a/src/wifi/model/sta-wifi-mac.h (+8 lines)

Lines 26-31	Link Here

#include "infrastructure-wifi-mac.h"

#include "infrastructure-wifi-mac.h"

#include "mgt-headers.h"

#include "mgt-headers.h"

class TwoLevelAggregationTest;

class AmpduAggregationTest;

namespace ns3  {

namespace ns3  {

class SupportedRates;

class SupportedRates;

Lines 102-107 struct ApInfo	Link Here

102

class StaWifiMac : public InfrastructureWifiMac

105

class StaWifiMac : public InfrastructureWifiMac

103

106

104

public:

107

public:

108

  /// Allow test cases to access private members

109

  friend class ::TwoLevelAggregationTest;

110

  /// Allow test cases to access private members

111

  friend class ::AmpduAggregationTest;

112

105

/**

113

/**

106

   * \brief Get the type ID.

114

   * \brief Get the type ID.

107

   * \return the object TypeId

115

   * \return the object TypeId




/* -*-  Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2018  Sébastien Deronne
 *
 * 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 "vht-configuration.h"

namespace ns3 {

NS_LOG_COMPONENT_DEFINE ("VhtConfiguration");

NS_OBJECT_ENSURE_REGISTERED (VhtConfiguration);

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

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

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

} //namespace ns3




/* -*-  Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2018  Sébastien Deronne
 *
 * 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 VHT_CONFIGURATION_H
#define VHT_CONFIGURATION_H

#include "ns3/object.h"

namespace ns3 {

/**
 * \brief VHT configuration
 * \ingroup wifi
 *
 * This object stores VHT configuration information, for use in modifying
 * AP or STA behavior and for constructing VHT-related information elements.
 *
 */
class VhtConfiguration : public Object
{
public:
  VhtConfiguration ();
  virtual ~VhtConfiguration ();

  static TypeId GetTypeId (void);
};

} //namespace ns3

#endif /* VHT_CONFIGURATION_H */




}

void
WifiMac::DoDispose ()
{
  m_device = 0;
}

void
WifiMac::SetDevice (const Ptr<NetDevice> device)
{
  m_device = device;
}

Ptr<NetDevice>
WifiMac::GetDevice (void) const
{
  return m_device;
}

void
WifiMac::SetMaxPropagationDelay (Time delay)
{
  NS_LOG_FUNCTION (this << delay);

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

Lines 21-26	Link Here

#ifndef WIFI_MAC_H

#ifndef WIFI_MAC_H

#define WIFI_MAC_H

#define WIFI_MAC_H

#include "ns3/net-device.h"

#include "wifi-phy-standard.h"

#include "wifi-phy-standard.h"

#include "wifi-remote-station-manager.h"

#include "wifi-remote-station-manager.h"

#include "qos-utils.h"

#include "qos-utils.h"

Lines 42-47 class Txop;	Link Here

class WifiMac : public Object

class WifiMac : public Object

public:

public:

  virtual void DoDispose ();

/**

/**

   * \brief Get the type ID.

   * \brief Get the type ID.

   * \return the object TypeId

   * \return the object TypeId

Lines 49-54 public:	Link Here

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

/**

/**

   * Sets the device this PHY is associated with.

   * \param device the device this PHY is associated with

*/

  void SetDevice (const Ptr<NetDevice> device);

/**

   * Return the device this PHY is associated with

   * \return the device this PHY is associated with

*/

  Ptr<NetDevice> GetDevice (void) const;

/**

   * \param slotTime the slot duration

   * \param slotTime the slot duration

*/

*/

  virtual void SetSlot (Time slotTime) = 0;

  virtual void SetSlot (Time slotTime) = 0;

Lines 151-160 public:	Link Here

151

   * \return whether the device supports short slot time capability.

167

   * \return whether the device supports short slot time capability.

152

*/

168

*/

153

  virtual bool GetShortSlotTimeSupported (void) const = 0;

169

  virtual bool GetShortSlotTimeSupported (void) const = 0;

154

/**

155

   * \return whether the device supports RIFS capability.

156

*/

157

  virtual bool GetRifsSupported (void) const = 0;

158

170

159

/**

171

/**

160

   * \param packet the packet to send.

172

   * \param packet the packet to send.

Lines 398-403 private:	Link Here

398

  virtual void FinishConfigureStandard (WifiPhyStandard standard) = 0;

410

  virtual void FinishConfigureStandard (WifiPhyStandard standard) = 0;

399

411

400

  Time m_maxPropagationDelay; ///< maximum propagation delay

412

  Time m_maxPropagationDelay; ///< maximum propagation delay

413

  Ptr<NetDevice> m_device;    ///< Pointer to the device

401

414

402

/**

415

/**

403

   * This method sets 802.11a standards-compliant defaults for following attributes:

416

   * This method sets 802.11a standards-compliant defaults for following attributes:

(-)a/src/wifi/model/wifi-net-device.cc (+54 lines)

Lines 27-32	Link Here

#include "wifi-net-device.h"

#include "wifi-net-device.h"

#include "wifi-phy.h"

#include "wifi-phy.h"

#include "wifi-mac.h"

#include "wifi-mac.h"

#include "ht-configuration.h"

#include "vht-configuration.h"

#include "he-configuration.h"

namespace ns3 {

namespace ns3 {

Lines 65-70 WifiNetDevice::GetTypeId (void)	Link Here

                   MakePointerAccessor (&WifiNetDevice::SetRemoteStationManager,

                   MakePointerAccessor (&WifiNetDevice::SetRemoteStationManager,

                                        &WifiNetDevice::GetRemoteStationManager),

                                        &WifiNetDevice::GetRemoteStationManager),

                   MakePointerChecker<WifiRemoteStationManager> ())

                   MakePointerChecker<WifiRemoteStationManager> ())

    .AddAttribute ("HtConfiguration",

                   "The HtConfiguration object.",

                   PointerValue (),

                   MakePointerAccessor (&WifiNetDevice::GetHtConfiguration),

                   MakePointerChecker<HtConfiguration> ())

    .AddAttribute ("VhtConfiguration",

                   "The VhtConfiguration object.",

                   PointerValue (),

                   MakePointerAccessor (&WifiNetDevice::GetVhtConfiguration),

                   MakePointerChecker<VhtConfiguration> ())

    .AddAttribute ("HeConfiguration",

                   "The HeConfiguration object.",

                   PointerValue (),

                   MakePointerAccessor (&WifiNetDevice::GetHeConfiguration),

                   MakePointerChecker<HeConfiguration> ())

  return tid;

  return tid;

Lines 394-397 WifiNetDevice::SupportsSendFrom (void) const	Link Here

394

  return m_mac->SupportsSendFrom ();

412

  return m_mac->SupportsSendFrom ();

395

413

396

414

415

void

416

WifiNetDevice::SetHtConfiguration (Ptr<HtConfiguration> htConfiguration)

417

418

  m_htConfiguration = htConfiguration;

419

420

421

Ptr<HtConfiguration>

422

WifiNetDevice::GetHtConfiguration (void) const

423

424

  return m_htConfiguration;

425

426

427

void

428

WifiNetDevice::SetVhtConfiguration (Ptr<VhtConfiguration> vhtConfiguration)

429

430

  m_vhtConfiguration = vhtConfiguration;

431

432

433

Ptr<VhtConfiguration>

434

WifiNetDevice::GetVhtConfiguration (void) const

435

436

  return m_vhtConfiguration;

437

438

439

void

440

WifiNetDevice::SetHeConfiguration (Ptr<HeConfiguration> heConfiguration)

441

442

  m_heConfiguration = heConfiguration;

443

444

445

Ptr<HeConfiguration>

446

WifiNetDevice::GetHeConfiguration (void) const

447

448

  return m_heConfiguration;

449

450

397

} //namespace ns3

451

} //namespace ns3

(-)a/src/wifi/model/wifi-net-device.h (+31 lines)

Lines 29-34 namespace ns3 {	Link Here

class WifiRemoteStationManager;

class WifiRemoteStationManager;

class WifiPhy;

class WifiPhy;

class WifiMac;

class WifiMac;

class HtConfiguration;

class VhtConfiguration;

class HeConfiguration;

/// This value conforms to the 802.11 specification

/// This value conforms to the 802.11 specification

static const uint16_t MAX_MSDU_SIZE = 2304;

static const uint16_t MAX_MSDU_SIZE = 2304;

Lines 84-89 public:	Link Here

*/

*/

  Ptr<WifiRemoteStationManager> GetRemoteStationManager (void) const;

  Ptr<WifiRemoteStationManager> GetRemoteStationManager (void) const;

/**

   * \param htConfiguration pointer to HtConfiguration

*/

  void SetHtConfiguration (Ptr<HtConfiguration> htConfiguration);

/**

   * \return pointer to HtConfiguration if it exists

*/

  Ptr<HtConfiguration> GetHtConfiguration (void) const;

/**

   * \param vhtConfiguration pointer to VhtConfiguration

100

*/

101

  void SetVhtConfiguration (Ptr<VhtConfiguration> vhtConfiguration);

102

/**

103

   * \return pointer to VhtConfiguration if it exists

104

*/

105

  Ptr<VhtConfiguration> GetVhtConfiguration (void) const;

106

/**

107

   * \param heConfiguration pointer to HeConfiguration

108

*/

109

  void SetHeConfiguration (Ptr<HeConfiguration> heConfiguration);

110

/**

111

   * \return pointer to HeConfiguration if it exists

112

*/

113

  Ptr<HeConfiguration> GetHeConfiguration (void) const;

114

  //inherited from NetDevice base class.

115

  //inherited from NetDevice base class.

  void SetIfIndex (const uint32_t index);

116

  void SetIfIndex (const uint32_t index);

  uint32_t GetIfIndex (void) const;

117

  uint32_t GetIfIndex (void) const;

Lines 162-167 private:	Link Here

162

  Ptr<WifiPhy> m_phy; //!< the phy

190

  Ptr<WifiPhy> m_phy; //!< the phy

163

  Ptr<WifiMac> m_mac; //!< the MAC

191

  Ptr<WifiMac> m_mac; //!< the MAC

164

  Ptr<WifiRemoteStationManager> m_stationManager; //!< the station manager

192

  Ptr<WifiRemoteStationManager> m_stationManager; //!< the station manager

193

  Ptr<HtConfiguration> m_htConfiguration; //!< the HtConfiguration

194

  Ptr<VhtConfiguration> m_vhtConfiguration; //!< the VhtConfiguration

195

  Ptr<HeConfiguration> m_heConfiguration; //!< the HeConfiguration

165

  NetDevice::ReceiveCallback m_forwardUp; //!< forward up callback

196

  NetDevice::ReceiveCallback m_forwardUp; //!< forward up callback

166

  NetDevice::PromiscReceiveCallback m_promiscRx; //!< promiscious receive callback

197

  NetDevice::PromiscReceiveCallback m_promiscRx; //!< promiscious receive callback

167

198




#include "frame-capture-model.h"
#include "wifi-radio-energy-model.h"
#include "error-rate-model.h"
#include "wifi-net-device.h"
#include "ht-configuration.h"
#include "he-configuration.h"

namespace ns3 {


                   BooleanValue (false),
                   MakeBooleanAccessor (&WifiPhy::GetShortGuardInterval,
                                        &WifiPhy::SetShortGuardInterval),
                   MakeBooleanChecker (),
                   TypeId::DEPRECATED, "Use the HtConfiguration instead")
    .AddAttribute ("GuardInterval",
                   "Whether 800ns, 1600ns or 3200ns guard interval is used for HE transmissions."
                   "This parameter is only valuable for 802.11ax STAs and APs.",
                   TimeValue (NanoSeconds (3200)),
                   MakeTimeAccessor (&WifiPhy::GetGuardInterval,
                                     &WifiPhy::SetGuardInterval),
                   MakeTimeChecker (NanoSeconds (800), NanoSeconds (3200)),
                   TypeId::DEPRECATED, "Use the HeConfiguration instead")
                   "Whether or not LDPC is enabled (not supported yet!).",
                   BooleanValue (false),
                   MakeBooleanAccessor (&WifiPhy::GetLdpc,
                                        &WifiPhy::SetLdpc),
                   MakeBooleanChecker ())
    .AddAttribute ("STBCEnabled",
                   "Whether or not STBC is enabled (not supported yet!).",
                   BooleanValue (false),
                   MakeBooleanAccessor (&WifiPhy::GetStbc,
                                        &WifiPhy::SetStbc),
                   MakeBooleanChecker ())
    .AddAttribute ("GreenfieldEnabled",
                   "Whether or not Greenfield is enabled."
                   "This parameter is only valuable for 802.11n STAs and APs.",
                   BooleanValue (false),
                   MakeBooleanAccessor (&WifiPhy::GetGreenfield,
                                        &WifiPhy::SetGreenfield),
                   MakeBooleanChecker (),
                   TypeId::DEPRECATED, "Use the HtConfiguration instead")
    .AddAttribute ("ShortPlcpPreambleSupported",
                   "Whether or not short PLCP preamble is supported."
                   "This parameter is only valuable for 802.11b STAs and APs."

}

void
WifiPhy::SetLdpc (bool ldpc)
{
  NS_LOG_FUNCTION (this << ldpc);
  m_ldpc = ldpc;
}

bool
WifiPhy::GetLdpc (void) const
{
  return m_ldpc;
}

void
WifiPhy::SetStbc (bool stbc)
{
  NS_LOG_FUNCTION (this << stbc);
  m_stbc = stbc;
}

bool
WifiPhy::GetStbc (void) const
{
  return m_stbc;
}

void
WifiPhy::SetGreenfield (bool greenfield)
{
  NS_LOG_FUNCTION (this << greenfield);
  Ptr<WifiNetDevice> device = DynamicCast<WifiNetDevice> (GetDevice ());
  if (device)
    {
      Ptr<HtConfiguration> htConfiguration = device->GetHtConfiguration ();
      if (htConfiguration)
        {
          htConfiguration->SetGreenfieldSupported (greenfield);
        }
    }
  m_greenfield = greenfield;
}

bool
WifiPhy::GetGreenfield (void) const
{
  Ptr<WifiNetDevice> device = DynamicCast<WifiNetDevice> (GetDevice ());
  if (device)
    {
      Ptr<HtConfiguration> htConfiguration = device->GetHtConfiguration ();
      if (htConfiguration)
        {
          return htConfiguration->GetGreenfieldSupported ();
        }
    }
  return m_greenfield;
}


WifiPhy::SetShortGuardInterval (bool shortGuardInterval)
{
  NS_LOG_FUNCTION (this << shortGuardInterval);
  Ptr<WifiNetDevice> device = DynamicCast<WifiNetDevice> (GetDevice ());
  if (device)
    {
      Ptr<HtConfiguration> htConfiguration = device->GetHtConfiguration ();
      if (htConfiguration)
        {
          htConfiguration->SetShortGuardIntervalSupported (shortGuardInterval);
        }
    }
  m_shortGuardInterval = shortGuardInterval;
}

bool
WifiPhy::GetShortGuardInterval (void) const
{
  Ptr<WifiNetDevice> device = DynamicCast<WifiNetDevice> (GetDevice ());
  if (device)
    {
      Ptr<HtConfiguration> htConfiguration = device->GetHtConfiguration ();
      if (htConfiguration)
        {
          return htConfiguration->GetShortGuardIntervalSupported ();
        }
    }
  return m_shortGuardInterval;
}


{
  NS_LOG_FUNCTION (this << guardInterval);
  NS_ASSERT (guardInterval == NanoSeconds (800) || guardInterval == NanoSeconds (1600) || guardInterval == NanoSeconds (3200));
  Ptr<WifiNetDevice> device = DynamicCast<WifiNetDevice> (GetDevice ());
  if (device)
    {
      Ptr<HeConfiguration> heConfiguration = device->GetHeConfiguration ();
      if (heConfiguration)
        {
          heConfiguration->SetGuardInterval (guardInterval);
        }
    }
  m_guardInterval = guardInterval;
}

Time
WifiPhy::GetGuardInterval (void) const
{
  Ptr<WifiNetDevice> device = DynamicCast<WifiNetDevice> (GetDevice ());
  if (device)
    {
      Ptr<HeConfiguration> heConfiguration = device->GetHeConfiguration ();
      if (heConfiguration)
        {
          return heConfiguration->GetGuardInterval ();
        }
    }
  return m_guardInterval;
}


WifiPhy::SetDevice (const Ptr<NetDevice> device)
{
  m_device = device;
  //TODO: to be removed once deprecated API is cleaned up
  Ptr<HtConfiguration> htConfiguration = DynamicCast<WifiNetDevice> (device)->GetHtConfiguration ();
  if (htConfiguration)
    {
      htConfiguration->SetShortGuardIntervalSupported (m_shortGuardInterval);
      htConfiguration->SetGreenfieldSupported (m_greenfield);
    }
  Ptr<HeConfiguration> heConfiguration = DynamicCast<WifiNetDevice> (device)->GetHeConfiguration ();
  if (heConfiguration)
    {
      heConfiguration->SetGuardInterval (m_guardInterval);
    }
}

Ptr<NetDevice>

(-)a/src/wifi/model/wifi-phy.h (-28 / +15 lines)

Lines 1350-1404 public:	Link Here

1350

   * Enable or disable support for HT/VHT short guard interval.

1350

   * Enable or disable support for HT/VHT short guard interval.

1351

1352

   * \param shortGuardInterval Enable or disable support for short guard interval

1352

   * \param shortGuardInterval Enable or disable support for short guard interval

1353

1354

   * \deprecated

1353

*/

1355

*/

1354

  void SetShortGuardInterval (bool shortGuardInterval);

1356

  void SetShortGuardInterval (bool shortGuardInterval);

1355

/**

1357

/**

1356

   * Return whether short guard interval is supported.

1358

   * Return whether short guard interval is supported.

1357

1359

1358

   * \return true if short guard interval is supported, false otherwise

1360

   * \return true if short guard interval is supported, false otherwise

1361

1362

   * \deprecated

1359

*/

1363

*/

1360

  bool GetShortGuardInterval (void) const;

1364

  bool GetShortGuardInterval (void) const;

1361

/**

1365

/**

1362

   * \param guardInterval the supported HE guard interval

1366

   * \param guardInterval the supported HE guard interval

1367

1368

   * \deprecated

1363

*/

1369

*/

1364

  void SetGuardInterval (Time guardInterval);

1370

  void SetGuardInterval (Time guardInterval);

1365

/**

1371

/**

1366

   * \return the supported HE guard interval

1372

   * \return the supported HE guard interval

1367

*/

1368

  Time GetGuardInterval (void) const;

1369

/**

1370

   * Enable or disable LDPC.

1371

   * \param ldpc Enable or disable LDPC

1372

*/

1373

  void SetLdpc (bool ldpc);

1374

/**

1375

   * Return if LDPC is supported.

1376

1373

1377

   * \return true if LDPC is supported, false otherwise

1374

   * \deprecated

1378

*/

1375

*/

1379

  bool GetLdpc (void) const;

1376

  Time GetGuardInterval (void) const;

1380

/**

1381

   * Enable or disable STBC.

1382

1383

   * \param stbc Enable or disable STBC

1384

*/

1385

  void SetStbc (bool stbc);

1386

/**

1387

   * Return whether STBC is supported.

1388

1389

   * \return true if STBC is supported, false otherwise

1390

*/

1391

  bool GetStbc (void) const;

1392

/**

1377

/**

1393

   * Enable or disable Greenfield support.

1378

   * Enable or disable Greenfield support.

1394

1379

1395

   * \param greenfield Enable or disable Greenfield

1380

   * \param greenfield Enable or disable Greenfield

1381

1382

   * \deprecated

1396

*/

1383

*/

1397

  void SetGreenfield (bool greenfield);

1384

  void SetGreenfield (bool greenfield);

1398

/**

1385

/**

1399

   * Return whether Greenfield is supported.

1386

   * Return whether Greenfield is supported.

1400

1387

1401

   * \return true if Greenfield is supported, false otherwise

1388

   * \return true if Greenfield is supported, false otherwise

1389

1390

   * \deprecated

1402

*/

1391

*/

1403

  bool GetGreenfield (void) const;

1392

  bool GetGreenfield (void) const;

1404

/**

1393

/**

Lines 1761-1773 private:	Link Here

1761

  double   m_txPowerEndDbm;       //!< Maximum transmission power (dBm)

1750

  double   m_txPowerEndDbm;       //!< Maximum transmission power (dBm)

1762

  uint8_t  m_nTxPower;            //!< Number of available transmission power levels

1751

  uint8_t  m_nTxPower;            //!< Number of available transmission power levels

1763

1752

1764

  bool     m_ldpc;               //!< Flag if LDPC is used

1753

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

1765

  bool     m_stbc;               //!< Flag if STBC is used

1754

  bool     m_shortGuardInterval; //!< Flag if HT/VHT short guard interval is supported (deprecated)

1766

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

1767

  bool     m_shortGuardInterval; //!< Flag if HT/VHT short guard interval is supported

1768

  bool     m_shortPreamble;      //!< Flag if short PLCP preamble is supported

1755

  bool     m_shortPreamble;      //!< Flag if short PLCP preamble is supported

1769

1756

1770

  Time m_guardInterval; //!< Supported HE guard interval

1757

  Time m_guardInterval; //!< Supported HE guard interval (deprecated)

1771

1758

1772

  uint8_t m_numberOfAntennas;  //!< Number of transmitters

1759

  uint8_t m_numberOfAntennas;  //!< Number of transmitters

1773

  uint8_t m_txSpatialStreams;  //!< Number of supported TX spatial streams

1760

  uint8_t m_txSpatialStreams;  //!< Number of supported TX spatial streams




#include "ns3/boolean.h"
#include "ns3/uinteger.h"
#include "ns3/enum.h"
#include "ns3/packet.h"
#include "ns3/simulator.h"
#include "ns3/tag.h"
#include "wifi-remote-station-manager.h"
#include "wifi-phy.h"
#include "wifi-mac.h"

#include "ht-capabilities.h"
#include "vht-capabilities.h"
#include "he-capabilities.h"
#include "ht-configuration.h"
#include "vht-configuration.h"
#include "he-configuration.h"
#include "wifi-net-device.h"

namespace ns3 {


}

WifiRemoteStationManager::WifiRemoteStationManager ()
  : m_pcfSupported (false),
    m_vhtSupported (false),
    m_heSupported (false),
    m_pcfSupported (false),
    m_useNonErpProtection (false),
    m_useNonHtProtection (false),
    m_useGreenfieldProtection (false),

  m_wifiPhy = phy;
  m_defaultTxMode = phy->GetMode (0);
  NS_ASSERT (m_defaultTxMode.IsMandatory ());
  if (GetHtSupported () || GetVhtSupported () || GetHeSupported ())
    {
      m_defaultTxMcs = phy->GetMcs (0);
    }

}

void
WifiRemoteStationManager::SetHtSupported (bool enable)
{
  NS_LOG_FUNCTION (this << enable);
  m_htSupported = enable;
}

void
WifiRemoteStationManager::SetFragmentationThreshold (uint32_t threshold)
{
  NS_LOG_FUNCTION (this << threshold);

}

bool
WifiRemoteStationManager::GetHtSupported (void) const
{
  Ptr<WifiNetDevice> device = DynamicCast<WifiNetDevice> (m_wifiPhy->GetDevice ());
  Ptr<HtConfiguration> htConfiguration = device->GetHtConfiguration ();
  if (htConfiguration)
    {
      return true;
    }
  return false;
}

bool
WifiRemoteStationManager::GetVhtSupported (void) const
{
  Ptr<WifiNetDevice> device = DynamicCast<WifiNetDevice> (m_wifiPhy->GetDevice ());
  Ptr<VhtConfiguration> vhtConfiguration = device->GetVhtConfiguration ();
  if (vhtConfiguration)
    {
      return true;
    }
  return false;
}

bool
WifiRemoteStationManager::GetHeSupported (void) const
{
  Ptr<WifiNetDevice> device = DynamicCast<WifiNetDevice> (m_wifiPhy->GetDevice ());
  Ptr<HeConfiguration> heConfiguration = device->GetHeConfiguration ();
  if (heConfiguration)
    {
      return true;
    }
  return false;
}

void
WifiRemoteStationManager::SetPcfSupported (bool enable)
{
  m_pcfSupported = enable;
}

bool
WifiRemoteStationManager::GetPcfSupported (void) const
{
  return m_pcfSupported;
}

bool
WifiRemoteStationManager::GetGreenfieldSupported (void) const
{
  if (GetHtSupported ())
    {
      Ptr<WifiNetDevice> device = DynamicCast<WifiNetDevice> (m_wifiPhy->GetDevice ());
      Ptr<HtConfiguration> htConfiguration = device->GetHtConfiguration ();
      NS_ASSERT (htConfiguration); //If HT is supported, we should have a HT configuration attached
      if (htConfiguration->GetGreenfieldSupported ())
        {
          return true;
        }
    }
  return false;
}

bool
WifiRemoteStationManager::GetShortGuardIntervalSupported (void) const
{
  if (GetHtSupported ())
    {
      Ptr<WifiNetDevice> device = DynamicCast<WifiNetDevice> (m_wifiPhy->GetDevice ());
      Ptr<HtConfiguration> htConfiguration = device->GetHtConfiguration ();
      NS_ASSERT (htConfiguration); //If HT is supported, we should have a HT configuration attached
      if (htConfiguration->GetShortGuardIntervalSupported ())
        {
          return true;
        }
    }
  return false;
}

uint16_t
WifiRemoteStationManager::GetGuardInterval (void) const
{
  uint16_t gi = 0;
  if (GetHeSupported ())
    {
      Ptr<WifiNetDevice> device = DynamicCast<WifiNetDevice> (m_wifiPhy->GetDevice ());
      Ptr<HeConfiguration> heConfiguration = device->GetHeConfiguration ();
      NS_ASSERT (heConfiguration); //If HE is supported, we should have a HE configuration attached
      gi = static_cast<uint16_t>(heConfiguration->GetGuardInterval ().GetNanoSeconds ());
    }
  return gi;
}

uint32_t

      v.SetPreambleType (GetPreambleForTransmission (mode, address));
      v.SetTxPowerLevel (m_defaultTxPowerLevel);
      v.SetChannelWidth (GetChannelWidthForTransmission (mode, m_wifiPhy->GetChannelWidth ()));
      v.SetGuardInterval (ConvertGuardIntervalToNanoSeconds (mode, DynamicCast<WifiNetDevice> (m_wifiPhy->GetDevice ())));
      v.SetNTx (1);
      v.SetNss (1);
      v.SetNess (0);
      v.SetStbc (0);
      return v;
    }
  if (!IsLowLatency ())

      txVector.SetMode (mgtMode);
      txVector.SetPreambleType (GetPreambleForTransmission (mgtMode, address));
      txVector.SetChannelWidth (GetChannelWidthForTransmission (mgtMode, m_wifiPhy->GetChannelWidth ()));
      txVector.SetGuardInterval (ConvertGuardIntervalToNanoSeconds (mgtMode, DynamicCast<WifiNetDevice> (m_wifiPhy->GetDevice ())));
    }
  return txVector;
}

  return WifiTxVector (defaultMode,
                       GetDefaultTxPowerLevel (),
                       defaultPreamble,
                       ConvertGuardIntervalToNanoSeconds (defaultMode, DynamicCast<WifiNetDevice> (m_wifiPhy->GetDevice ())),
                       GetNumberOfAntennas (),
                       GetMaxNumberOfTransmitStreams (),
                       0,

              return false;
            }
        }
      if (GetHtSupported ())
        {
          //search for the BSS Basic MCS set, if the used mode is in the basic set then there is no need for Cts To Self
          for (WifiModeListIterator i = m_bssBasicMcsSet.begin (); i != m_bssBasicMcsSet.end (); i++)

          found = true;
        }
    }
  if (GetHtSupported () || GetVhtSupported () || GetHeSupported ())
    {
      if (!found)
        {

          found = true;
        }
    }
  if (GetHtSupported () || GetVhtSupported () || GetHeSupported ())
    {
      for (uint8_t idx = 0; idx < m_wifiPhy->GetNMcs (); idx++)
        {

  v.SetGuardInterval (DoGetCtsTxGuardInterval (address, ctsMode));
  v.SetNss (DoGetCtsTxNss (address, ctsMode));
  v.SetNess (DoGetCtsTxNess (address, ctsMode));
  v.SetStbc (0);
  return v;
}


  v.SetGuardInterval (DoGetAckTxGuardInterval (address, ackMode));
  v.SetNss (DoGetAckTxNss (address, ackMode));
  v.SetNess (DoGetAckTxNess (address, ackMode));
  v.SetStbc (0);
  return v;
}


  v.SetGuardInterval (DoGetBlockAckTxGuardInterval (address, blockAckMode));
  v.SetNss (DoGetBlockAckTxNss (address, blockAckMode));
  v.SetNess (DoGetBlockAckTxNess (address, blockAckMode));
  v.SetStbc (0);
  return v;
}


uint16_t
WifiRemoteStationManager::DoGetCtsTxGuardInterval (Mac48Address address, WifiMode ctsMode)
{
  return ConvertGuardIntervalToNanoSeconds (ctsMode, DynamicCast<WifiNetDevice> (m_wifiPhy->GetDevice ()));
}

uint8_t

uint16_t
WifiRemoteStationManager::DoGetAckTxGuardInterval (Mac48Address address, WifiMode ackMode)
{
  return ConvertGuardIntervalToNanoSeconds (ackMode, DynamicCast<WifiNetDevice> (m_wifiPhy->GetDevice ()));
}

uint8_t

uint16_t
WifiRemoteStationManager::DoGetBlockAckTxGuardInterval (Mac48Address address, WifiMode blockAckMode)
{
  return ConvertGuardIntervalToNanoSeconds (blockAckMode, DynamicCast<WifiNetDevice> (m_wifiPhy->GetDevice ()));
}

uint8_t

  state->m_operationalRateSet.push_back (GetDefaultMode ());
  state->m_operationalMcsSet.push_back (GetDefaultMcs ());
  state->m_channelWidth = m_wifiPhy->GetChannelWidth ();
  state->m_shortGuardInterval = GetShortGuardIntervalSupported ();
  state->m_guardInterval = GetGuardInterval ();
  state->m_greenfield = GetGreenfieldSupported ();
  state->m_streams = 1;
  state->m_ness = 0;
  state->m_aggregation = false;

}

bool
WifiRemoteStationManager::GetShortGuardIntervalSupported (const WifiRemoteStation *station) const
{
  return station->m_state->m_shortGuardInterval;
}

}

bool
WifiRemoteStationManager::GetShortGuardIntervalSupported (Mac48Address address) const
{
  return LookupState (address)->m_shortGuardInterval;
}

    {
      preamble = WIFI_PREAMBLE_VHT;
    }
  else if (mode.GetModulationClass () == WIFI_MOD_CLASS_HT && GetGreenfieldSupported () && GetGreenfieldSupported (dest) && !GetUseGreenfieldProtection ())
    {
      //If protection for greenfield is used we go for HT_MF preamble which is the default protection for GF format defined in the standard.
      preamble = WIFI_PREAMBLE_HT_GF;




   */
  void AddStationHeCapabilities (Mac48Address from, HeCapabilities hecapabilities);
  /**
   * Enable or disable HT capability support.
   *
   * \param enable enable or disable HT capability support
   */
  virtual void SetHtSupported (bool enable);
  /**
   * Return whether the device has HT capability support enabled.
   *
   * \return true if HT capability support is enabled, false otherwise
   */
  bool GetHtSupported (void) const;
  /**
   * Enable or disable VHT capability support.
   *
   * \param enable enable or disable VHT capability support
   */
  virtual void SetVhtSupported (bool enable);
  /**
   * Return whether the device has VHT capability support enabled.
   *
   * \return true if VHT capability support is enabled, false otherwise
   */
  bool GetVhtSupported (void) const;
  /**
   * Enable or disable HE capability support.
   *
   * \param enable enable or disable HE capability support
   */
  virtual void SetHeSupported (bool enable);
  /**
   * Return whether the device has HE capability support enabled.
   *
   * \return true if HE capability support is enabled, false otherwise
   */
  bool GetHeSupported (void) const;
  /**
   * Enable or disable PCF capability support.
   *
   * \param enable enable or disable PCF capability support
   */
  void SetPcfSupported (bool enable);
  /**
   * Return whether the device has PCF capability support enabled.
   *
   * \return true if PCF capability support is enabled, false otherwise
   */
  bool GetPcfSupported (void) const;
  /**
   * Return whether the device has HT Greenfield support enabled.
   *
   * \return true if HT Grenfield support is enabled, false otherwise
   */
  bool GetGreenfieldSupported (void) const;
  /**
   * Return whether the device has SGI support enabled.
   *
   * \return true if SGI support is enabled, false otherwise
   */
  bool GetShortGuardIntervalSupported (void) const;
  /**
   * Return the supported HE guard interval duration (in nanoseconds).
   *
   * \return the supported HE guard interval duration (in nanoseconds)
   */
  uint16_t GetGuardInterval (void) const;
  /**
   * Enable or disable protection for non-ERP stations.
   *

   * \return true if the station supports HT/VHT short guard interval,
   *         false otherwise
   */
  bool GetShortGuardIntervalSupported (Mac48Address address) const;
  /**
   * Return the number of spatial streams supported by the station.
   *

   * \return true if the station supports HT/VHT short guard interval,
   *         false otherwise
   */
  bool GetShortGuardIntervalSupported (const WifiRemoteStation *station) const;
  /**
   * Return the HE guard interval duration supported by the station.
   *

  WifiMode m_defaultTxMode; //!< The default transmission mode
  WifiMode m_defaultTxMcs;   //!< The default transmission modulation-coding scheme (MCS)

  bool m_htSupported;  //!< Flag if HT capability is supported
  bool m_vhtSupported; //!< Flag if VHT capability is supported
  bool m_heSupported;  //!< Flag if HE capability is supported
  bool m_pcfSupported; //!< Flag if PCF capability is supported
  uint32_t m_maxSsrc;  //!< Maximum STA short retry count (SSRC)
  uint32_t m_maxSlrc;  //!< Maximum STA long retry count (SLRC)




 * Author: Sébastien Deronne <sebastien.deronne@gmail.com>
 */

#include "ns3/packet.h"
#include "ns3/nstime.h"
#include "wifi-utils.h"
#include "ctrl-headers.h"
#include "wifi-mac-header.h"
#include "wifi-mac-trailer.h"
#include "wifi-net-device.h"
#include "ht-configuration.h"
#include "he-configuration.h"
#include "wifi-mode.h"

namespace ns3 {

}

uint16_t
ConvertGuardIntervalToNanoSeconds (WifiMode mode, const Ptr<WifiNetDevice> device)
{
  uint16_t gi = 800;
  if (mode.GetModulationClass () == WIFI_MOD_CLASS_HE)
    {
      Ptr<HeConfiguration> heConfiguration = device->GetHeConfiguration ();
      NS_ASSERT (heConfiguration); //If HE modulation is used, we should have a HE configuration attached
      gi = static_cast<uint16_t> (heConfiguration->GetGuardInterval ().GetNanoSeconds ());
    }
  else if (mode.GetModulationClass () == WIFI_MOD_CLASS_HT || mode.GetModulationClass () == WIFI_MOD_CLASS_VHT)
    {
      Ptr<HtConfiguration> htConfiguration = device->GetHtConfiguration ();
      NS_ASSERT (htConfiguration); //If HT/VHT modulation is used, we should have a HT configuration attached
      gi = htConfiguration->GetShortGuardIntervalSupported () ? 400 : 800;
    }
  return gi;
}

uint16_t
ConvertGuardIntervalToNanoSeconds (WifiMode mode, bool htShortGuardInterval, Time heGuardInterval)
{
  uint16_t gi;





namespace ns3 {

class WifiNetDevice;
class WifiMacHeader;
class WifiMode;
class Packet;

 * Convert the guard interval to nanoseconds based on the wifimode.
 *
 * \param mode the wifimode
 * \param device pointer to the WifiNetDevice object
 *
 * \return the guard interval duration in nanoseconds
 */
uint16_t ConvertGuardIntervalToNanoSeconds (WifiMode mode, const Ptr<WifiNetDevice> device);
/**
 * Convert the guard interval to nanoseconds based on the wifimode.
 *
 * \param mode the wifimode
 * \param htShortGuardInterval whether HT/VHT short guard interval is enabled
 * \param heGuardInterval the HE guard interval duration
 *




  /*
   * Create mac layer. We use Adhoc because association is not needed to get supported rates.
   */
  Ptr<WifiNetDevice> dev = CreateObject<WifiNetDevice> ();
  Ptr<AdhocWifiMac> mac = CreateObject<AdhocWifiMac> ();
  mac->SetDevice (dev);
  mac->ConfigureStandard (WIFI_PHY_STANDARD_80211a);

  /*

  /*
   * Create and configure phy layer.
   */
  Ptr<WifiNetDevice> dev = CreateObject<WifiNetDevice> ();
  Ptr<YansWifiPhy> phy = CreateObject<YansWifiPhy> ();
  phy->SetChannel (channel);
  phy->SetDevice (dev);




#include "ns3/test.h"
#include "ns3/simulator.h"
#include "ns3/wifi-mac-queue.h"
#include "ns3/sta-wifi-mac.h"
#include "ns3/qos-txop.h"
#include "ns3/yans-wifi-phy.h"
#include "ns3/mac-tx-middle.h"
#include "ns3/mac-low.h"
#include "ns3/msdu-aggregator.h"
#include "ns3/mpdu-aggregator.h"
#include "ns3/wifi-net-device.h"
#include "ns3/ht-configuration.h"

using namespace ns3;



private:
  virtual void DoRun (void);
  Ptr<WifiNetDevice> m_device; ///<WifiNetDevice
  Ptr<StaWifiMac> m_mac; ///< Mac
  Ptr<YansWifiPhy> m_phy; ///< Phy
  Ptr<QosTxop> m_txop; ///< QosTxop
  Ptr<MacTxMiddle> m_txMiddle; ///< MacTxMiddle
  Ptr<WifiRemoteStationManager> m_manager; ///< remote station manager
  ObjectFactory m_factory; ///< factory
  Ptr<MpduAggregator> m_mpduAggregator; ///< A-MPDU aggregrator
  Ptr<ChannelAccessManager> m_channelAccessManager; ///< channel access manager
};

AmpduAggregationTest::AmpduAggregationTest ()

AmpduAggregationTest::DoRun (void)
{
  /*
   * Create device and attach HT configuration.
   */
  m_device = CreateObject<WifiNetDevice> ();
  Ptr<HtConfiguration> htConfiguration = CreateObject<HtConfiguration> ();
  m_device->SetHtConfiguration (htConfiguration);

  /*
   * Create and configure phy layer.
   */
  m_phy = CreateObject<YansWifiPhy> ();
  m_phy->SetDevice (m_device);
  m_phy->ConfigureStandard (WIFI_PHY_STANDARD_80211n_5GHZ);
  m_device->SetPhy (m_phy);

  /*
   * Create and configure manager.

  m_factory.Set ("DataMode", StringValue ("HtMcs7"));
  m_manager = m_factory.Create<WifiRemoteStationManager> ();
  m_manager->SetupPhy (m_phy);
  m_device->SetRemoteStationManager (m_manager);

  /*
   * Create and configure mac layer.
   */
  m_mac = CreateObject<StaWifiMac> ();
  m_mac->SetDevice (m_device);
  m_mac->SetWifiPhy (m_phy);
  m_mac->SetWifiRemoteStationManager (m_manager);
  m_mac->SetAddress (Mac48Address ("00:00:00:00:00:01"));
  m_mac->ConfigureStandard (WIFI_PHY_STANDARD_80211n_5GHZ);
  m_device->SetMac (m_mac);
  m_channelAccessManager->SetupPhyListener (m_phy);
  m_channelAccessManager->SetSlot (MicroSeconds (9));

  m_txop = CreateObject<QosTxop> ();
  m_txop->SetMacLow (m_low);
  m_txop->SetAccessCategory (AC_BE);
  m_txop->SetWifiRemoteStationManager (m_manager);
  m_txop->SetChannelAccessManager (m_channelAccessManager);

  m_txMiddle = Create<MacTxMiddle> ();
  m_txop->SetTxMiddle (m_txMiddle);
  m_txop->CompleteConfig ();

  /*
   * Configure MPDU aggregation.
   */
  m_mac->GetBEQueue ()->GetMpduAggregator ()->SetMaxAmpduSize (65535);
  m_factory.SetTypeId ("ns3::MpduAggregator");
  m_mpduAggregator = m_factory.Create<MpduAggregator> ();
  m_mpduAggregator->SetMaxAmpduSize (65535);
  m_txop->SetMpduAggregator (m_mpduAggregator);

  /*
   * Create a dummy packet of 1500 bytes and fill mac header fields.

  hdr.SetAddr2 (Mac48Address ("00:00:00:00:00:01"));
  hdr.SetType (WIFI_MAC_QOSDATA);
  hdr.SetQosTid (0);
  uint16_t sequence = m_mac->m_txMiddle->GetNextSequenceNumberFor (&hdr);
  hdr.SetSequenceNumber (sequence);
  hdr.SetFragmentNumber (0);
  hdr.SetNoMoreFragments ();

  reqHdr.SetBufferSize (0);
  reqHdr.SetTimeout (0);
  reqHdr.SetStartingSequence (0);
  m_mac->GetBEQueue ()->m_baManager->CreateAgreement (&reqHdr, hdr.GetAddr1 ());

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

  /*
   * Test behavior when no other packets are in the queue
   */
  m_mac->GetBEQueue ()->GetLow ()->m_currentHdr = hdr;
  m_mac->GetBEQueue ()->GetLow ()->m_currentPacket = pkt->Copy ();
  m_mac->GetBEQueue ()->GetLow ()->m_currentTxVector = m_mac->GetBEQueue ()->GetLow ()->GetDataTxVector (m_mac->GetBEQueue ()->GetLow ()->m_currentPacket, &m_mac->GetBEQueue ()->GetLow ()->m_currentHdr);

  bool isAmpdu = m_mac->GetBEQueue ()->GetLow ()->IsAmpdu (pkt, hdr);
  NS_TEST_EXPECT_MSG_EQ (isAmpdu, false, "a single packet should not result in an A-MPDU");
  NS_TEST_EXPECT_MSG_EQ (m_mac->GetBEQueue ()->GetLow ()->m_aggregateQueue[0]->GetNPackets (), 0, "aggregation queue is not flushed");

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


  hdr2.SetType (WIFI_MAC_QOSDATA);
  hdr2.SetQosTid (0);

  m_mac->GetBEQueue ()->GetWifiMacQueue ()->Enqueue (Create<WifiMacQueueItem> (pkt1, hdr1));
  m_mac->GetBEQueue ()->GetWifiMacQueue ()->Enqueue (Create<WifiMacQueueItem> (pkt2, hdr2));

  isAmpdu = m_mac->GetBEQueue ()->GetLow ()->IsAmpdu (pkt, hdr);
  uint32_t aggregationQueueSize = m_mac->GetBEQueue ()->GetLow ()->m_aggregateQueue[0]->GetNPackets ();
  NS_TEST_EXPECT_MSG_EQ (isAmpdu, true, "MPDU aggregation failed");
  NS_TEST_EXPECT_MSG_EQ (m_mac->GetBEQueue ()->GetLow ()->m_currentPacket->GetSize (), 4606, "A-MPDU size is not correct");
  NS_TEST_EXPECT_MSG_EQ (aggregationQueueSize, 3, "aggregation queue should not be empty");
  NS_TEST_EXPECT_MSG_EQ (m_mac->GetBEQueue ()->GetWifiMacQueue ()->GetNPackets (), 0, "queue should be empty");

  Ptr <WifiMacQueueItem> dequeuedItem;
  WifiMacHeader dequeuedHdr;
  uint32_t i = 0;
  for (; aggregationQueueSize > 0; aggregationQueueSize--, i++)
    {
      dequeuedItem = m_mac->GetBEQueue ()->GetLow ()->m_aggregateQueue[0]->Dequeue ();
      dequeuedHdr = dequeuedItem->GetHeader ();
      NS_TEST_EXPECT_MSG_EQ (dequeuedHdr.GetSequenceNumber (), i, "wrong sequence number");
    }

  hdr3.SetType (WIFI_MAC_DATA);
  hdr3.SetQosTid (0);

  m_mac->GetBEQueue ()->GetWifiMacQueue ()->Enqueue (Create<WifiMacQueueItem> (pkt3, hdr3));

  isAmpdu = m_mac->GetBEQueue ()->GetLow ()->IsAmpdu (pkt1, hdr1);
  NS_TEST_EXPECT_MSG_EQ (isAmpdu, false, "a single packet for this destination should not result in an A-MPDU");
  NS_TEST_EXPECT_MSG_EQ (m_mac->GetBEQueue ()->GetLow ()->m_aggregateQueue[0]->GetNPackets (), 0, "aggregation queue is not flushed");

  m_mac->GetBEQueue ()->m_currentHdr = hdr2;
  m_mac->GetBEQueue ()->m_currentPacket = pkt2->Copy ();
  isAmpdu = m_mac->GetBEQueue ()->GetLow ()->IsAmpdu (pkt2, hdr2);
  NS_TEST_EXPECT_MSG_EQ (isAmpdu, false, "no MPDU aggregation should be performed if there is no agreement");
  NS_TEST_EXPECT_MSG_EQ (m_mac->GetBEQueue ()->GetLow ()->m_aggregateQueue[0]->GetNPackets (), 0, "aggregation queue is not flushed");

  m_manager->SetMaxSsrc (0); //set to 0 in order to fake that the maximum number of retries has been reached
  m_mac->GetBEQueue ()->MissedAck ();

  NS_TEST_EXPECT_MSG_EQ (m_mac->GetBEQueue ()->m_currentPacket, 0, "packet should be discarded");
  m_mac->GetBEQueue ()->GetWifiMacQueue ()->Remove (pkt3);

  Simulator::Destroy ();

  m_manager->Dispose ();
  m_manager = 0;
  m_low->Dispose ();
  m_low = 0;

  m_device->Dispose ();
  m_device = 0;

  htConfiguration = 0;
  m_channelAccessManager = 0;
}

/**


private:
  virtual void DoRun (void);
  Ptr<WifiNetDevice> m_device; ///<WifiNetDevice
  Ptr<StaWifiMac> m_mac; ///< Mac
  Ptr<YansWifiPhy> m_phy; ///< Phy
  Ptr<QosTxop> m_txop; ///< QosTxop
  Ptr<WifiRemoteStationManager> m_manager; ///< remote station manager
  ObjectFactory m_factory; ///< factory
  Ptr<MsduAggregator> m_msduAggregator; ///< A-MSDU aggregator
  Ptr<MpduAggregator> m_mpduAggregator; ///< A-MPDU aggregator
};

TwoLevelAggregationTest::TwoLevelAggregationTest ()

TwoLevelAggregationTest::DoRun (void)
{
  /*
   * Create device and attach HT configuration.
   */
  m_device = CreateObject<WifiNetDevice> ();
  Ptr<HtConfiguration> htConfiguration = CreateObject<HtConfiguration> ();
  m_device->SetHtConfiguration (htConfiguration);

  /*
   * Create and configure phy layer.
   */
  m_phy = CreateObject<YansWifiPhy> ();
  m_phy->SetDevice (m_device);
  m_phy->ConfigureStandard (WIFI_PHY_STANDARD_80211n_5GHZ);
  m_device->SetPhy (m_phy);

  /*
   * Create and configure manager.

  m_factory.Set ("DataMode", StringValue ("HtMcs7"));
  m_manager = m_factory.Create<WifiRemoteStationManager> ();
  m_manager->SetupPhy (m_phy);
  m_device->SetRemoteStationManager (m_manager);

  /*
   * Create and configure mac layer.
   */
  m_mac = CreateObject<StaWifiMac> ();
  m_mac->SetDevice (m_device);
  m_mac->SetWifiPhy (m_phy);
  m_mac->SetWifiRemoteStationManager (m_manager);
  m_mac->SetAddress (Mac48Address ("00:00:00:00:00:01"));
  m_mac->ConfigureStandard (WIFI_PHY_STANDARD_80211n_5GHZ);
  m_device->SetMac (m_mac);
  m_txop->SetWifiRemoteStationManager (m_manager);
  m_txop->CompleteConfig ();

  /*
   * Configure aggregation.
   */
  m_mac->GetBEQueue ()->GetMsduAggregator ()->SetMaxAmsduSize (4095);
  m_mac->GetBEQueue ()->GetMpduAggregator ()->SetMaxAmpduSize (65535);

  m_msduAggregator->SetMaxAmsduSize (4095);
  m_mpduAggregator->SetMaxAmpduSize (65535);

  m_txop->SetMsduAggregator (m_msduAggregator);
  m_txop->SetMpduAggregator (m_mpduAggregator);

  /*
   * Create dummy packets of 1500 bytes and fill mac header fields that will be used for the tests.

   *      - A-MSDU frame size should be 3030 bytes (= 2 packets + headers + padding);
   *      - one packet should be removed from the queue (the other packet is removed later in MacLow::AggregateToAmpdu) .
   */
  m_mac->GetBEQueue ()->GetWifiMacQueue ()->Enqueue (Create<WifiMacQueueItem> (pkt, hdr));
  m_mac->GetBEQueue ()->GetWifiMacQueue ()->Enqueue (Create<WifiMacQueueItem> (pkt, hdr));

  Ptr<const WifiMacQueueItem> peekedItem = m_mac->GetBEQueue ()->GetWifiMacQueue ()->PeekByTidAndAddress (0, hdr.GetAddr1 ());
  Ptr<const Packet> peekedPacket = peekedItem->GetPacket ();
  peekedHdr = peekedItem->GetHeader ();
  tstamp = peekedItem->GetTimeStamp ();
  m_mac->GetBEQueue ()->GetLow ()->m_currentPacket = peekedPacket->Copy ();
  m_mac->GetBEQueue ()->GetLow ()->m_currentHdr = peekedHdr;
  m_mac->GetBEQueue ()->GetLow ()->m_currentTxVector = m_mac->GetBEQueue ()->GetLow ()->GetDataTxVector (m_mac->GetBEQueue ()->GetLow ()->m_currentPacket, &m_mac->GetBEQueue ()->GetLow ()->m_currentHdr);

  Ptr<Packet> packet = m_mac->GetBEQueue ()->GetLow ()->PerformMsduAggregation (peekedPacket, &peekedHdr, &tstamp, currentAggregatedPacket, 0);

  bool result = (packet != 0);
  NS_TEST_EXPECT_MSG_EQ (result, true, "aggregation failed");
  NS_TEST_EXPECT_MSG_EQ (packet->GetSize (), 3030, "wrong packet size");
  NS_TEST_EXPECT_MSG_EQ (m_mac->GetBEQueue ()->GetWifiMacQueue ()->GetNPackets (), 0, "aggregated packets not removed from the queue");

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


   * It checks whether MSDU aggregation has been rejected because the maximum MPDU size is set to 0 (returned packet should be equal to 0).
   * This test is needed to ensure that no packets are removed from the queue in MacLow::PerformMsduAggregation, since aggregation will no occur in MacLow::AggregateToAmpdu.
   */
  m_mac->GetBEQueue ()->GetMpduAggregator ()->SetMaxAmpduSize (65535);
  m_factory.SetTypeId ("ns3::MpduAggregator");
  m_mpduAggregator = m_factory.Create<MpduAggregator> ();
  m_mpduAggregator->SetMaxAmpduSize (65535);
  m_txop->SetMpduAggregator (m_mpduAggregator);

  m_mac->GetBEQueue ()->GetWifiMacQueue ()->Enqueue (Create<WifiMacQueueItem> (pkt, hdr));
  packet = m_mac->GetBEQueue ()->GetLow ()->PerformMsduAggregation (peekedPacket, &peekedHdr, &tstamp, currentAggregatedPacket, 0);

  result = (packet != 0);
  NS_TEST_EXPECT_MSG_EQ (result, false, "maximum aggregated frame size check failed");

   * It checks whether MSDU aggregation has been rejected because there is no packets ready in the queue (returned packet should be equal to 0).
   * This test is needed to ensure that there is no issue when the queue is empty.
   */
  m_mac->GetBEQueue ()->GetMpduAggregator ()->SetMaxAmpduSize (4095);

  m_mac->GetBEQueue ()->GetWifiMacQueue ()->Remove (pkt);
  m_mac->GetBEQueue ()->GetWifiMacQueue ()->Remove (pkt);
  packet = m_mac->GetBEQueue ()->GetLow ()->PerformMsduAggregation (peekedPacket, &peekedHdr, &tstamp, currentAggregatedPacket, 0);

  result = (packet != 0);
  NS_TEST_EXPECT_MSG_EQ (result, false, "aggregation failed to stop as queue is empty");

  Simulator::Destroy ();

  m_device = 0;
  htConfiguration = 0;

  m_txop->Dispose ();
  m_txop = 0;
}


/**
 * \ingroup wifi-test
 * \ingroup tests




#include "ns3/wifi-phy-tag.h"
#include "ns3/yans-wifi-phy.h"
#include "ns3/mgt-headers.h"
#include "ns3/ht-configuration.h"

using namespace ns3;


  Ptr<WifiNetDevice> dev = CreateObject<WifiNetDevice> ();

  Ptr<WifiMac> mac = m_mac.Create<WifiMac> ();
  mac->SetDevice (dev);
  mac->ConfigureStandard (WIFI_PHY_STANDARD_80211a);
  Ptr<ConstantPositionMobilityModel> mobility = CreateObject<ConstantPositionMobilityModel> ();
  Ptr<YansWifiPhy> phy = CreateObject<YansWifiPhy> ();

  Ptr<WifiNetDevice> dev = CreateObject<WifiNetDevice> ();

  Ptr<WifiMac> mac = m_mac.Create<WifiMac> ();
  mac->SetDevice (dev);
  mac->ConfigureStandard (WIFI_PHY_STANDARD_80211a);
  Ptr<ConstantPositionMobilityModel> mobility = CreateObject<ConstantPositionMobilityModel> ();
  Ptr<YansWifiPhy> phy = CreateObject<YansWifiPhy> ();

  Ptr<Node> txNode = CreateObject<Node> ();
  Ptr<WifiNetDevice> txDev = CreateObject<WifiNetDevice> ();
  Ptr<WifiMac> txMac = m_mac.Create<WifiMac> ();
  txMac->SetDevice (txDev);
  txMac->ConfigureStandard (WIFI_PHY_STANDARD_80211a);
  //Fix the stream assignment to the Dcf Txop objects (backoffs)
  //The below stream assignment will result in the Txop object


  Ptr<Node> apNode = CreateObject<Node> ();
  Ptr<WifiNetDevice> apDev = CreateObject<WifiNetDevice> ();
  Ptr<HtConfiguration> apHtConfiguration = CreateObject<HtConfiguration> ();
  apDev->SetHtConfiguration (apHtConfiguration);
  ObjectFactory mac;
  mac.SetTypeId ("ns3::ApWifiMac");
  mac.Set ("EnableBeaconJitter", BooleanValue (false));
  Ptr<WifiMac> apMac = mac.Create<WifiMac> ();
  apMac->SetDevice (apDev);
  apMac->ConfigureStandard (WIFI_PHY_STANDARD_80211ax_5GHZ);

  Ptr<Node> staNode = CreateObject<Node> ();
  Ptr<WifiNetDevice> staDev = CreateObject<WifiNetDevice> ();
  Ptr<HtConfiguration> staHtConfiguration = CreateObject<HtConfiguration> ();
  staDev->SetHtConfiguration (staHtConfiguration);
  mac.SetTypeId ("ns3::StaWifiMac");
  Ptr<WifiMac> staMac = mac.Create<WifiMac> ();
  staMac->SetDevice (staDev);
  staMac->ConfigureStandard (WIFI_PHY_STANDARD_80211ax_5GHZ);

  Ptr<ConstantPositionMobilityModel> apMobility = CreateObject<ConstantPositionMobilityModel> ();

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

Lines 84-92 def build(bld):	Link Here

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

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

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

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

        'model/he-operation.cc',

        'model/he-operation.cc',

        'model/he-configuration.cc',

        'model/extended-capabilities.cc',

        'model/extended-capabilities.cc',

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

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

        'model/wifi-mac-queue-item.cc',

        'model/wifi-mac-queue-item.cc',

        'model/ht-configuration.cc',

        'model/vht-configuration.cc',

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

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

        'helper/athstats-helper.cc',

        'helper/athstats-helper.cc',

        'helper/wifi-helper.cc',

        'helper/wifi-helper.cc',

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

194

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

197

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

195

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

198

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

196

        'model/he-operation.h',

199

        'model/he-operation.h',

200

        'model/he-configuration.h',

197

        'model/extended-capabilities.h',

201

        'model/extended-capabilities.h',

198

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

202

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

199

        'model/wifi-mac-queue-item.h',

203

        'model/wifi-mac-queue-item.h',

Lines 201-206 def build(bld):	Link Here

201

        'model/wifi-phy-listener.h',

205

        'model/wifi-phy-listener.h',

202

        'model/block-ack-type.h',

206

        'model/block-ack-type.h',

203

        'model/wifi-mpdu-type.h',

207

        'model/wifi-mpdu-type.h',

208

        'model/ht-configuration.h',

209

        'model/vht-configuration.h',

204

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

210

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

205

        'helper/athstats-helper.h',

211

        'helper/athstats-helper.h',

206

        'helper/wifi-helper.h',

212

        'helper/wifi-helper.h',

Return to bug 3000