Attachment #2670 for bug #2551

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

(-)a/examples/wireless/power-adaptation-distance.cc (-1 / +2 lines)

Lines 172-178	Link Here

172

      WifiMode mode = phy->GetMode (i);

172

      WifiMode mode = phy->GetMode (i);

173

      WifiTxVector txVector;

173

      WifiTxVector txVector;

174

      txVector.SetMode (mode);

174

      txVector.SetMode (mode);

175

      timeTable.push_back (std::make_pair (phy->CalculateTxDuration (packetSize, txVector, WIFI_PREAMBLE_LONG, phy->GetFrequency ()), mode));

175

      txVector.SetPreambleType (WIFI_PREAMBLE_LONG);

176

      timeTable.push_back (std::make_pair (phy->CalculateTxDuration (packetSize, txVector, phy->GetFrequency ()), mode));

176

177

178

179

(-)a/examples/wireless/power-adaptation-interference.cc (-1 / +2 lines)

Lines 168-174	Link Here

168

      WifiMode mode = phy->GetMode (i);

168

      WifiMode mode = phy->GetMode (i);

169

      WifiTxVector txVector;

169

      WifiTxVector txVector;

170

      txVector.SetMode (mode);

170

      txVector.SetMode (mode);

171

      timeTable.push_back (std::make_pair (phy->CalculateTxDuration (packetSize, txVector, WIFI_PREAMBLE_LONG, phy->GetFrequency ()), mode));

171

      txVector.SetPreambleType (WIFI_PREAMBLE_LONG);

172

      timeTable.push_back (std::make_pair (phy->CalculateTxDuration (packetSize, txVector, phy->GetFrequency ()), mode));

172

173

174

175




double g_noiseDbmAvg;
uint32_t g_samples;
uint16_t g_channelNumber;
uint32_t g_rate;

void MonitorSniffRx (Ptr<const Packet> packet, uint16_t channelFreqMhz,
                     uint16_t channelNumber, WifiTxVector txVector,
                     MpduInfo aMpdu, SignalNoiseDbm signalNoise)
                     struct mpduInfo aMpdu, struct signalNoiseDbm signalNoise)

{
  g_samples++;
  g_signalDbmAvg += ((signalNoise.signal - g_signalDbmAvg) / g_samples);
  g_noiseDbmAvg += ((signalNoise.noise - g_noiseDbmAvg) / g_samples);
  g_rate = rate;
  g_channelNumber = channelNumber;
}


      g_noiseDbmAvg = 0;
      g_samples = 0;
      g_channelNumber = 0;
      g_rate = 0;

      Simulator::Stop (Seconds (simulationTime + 1));
      Simulator::Run ();




double g_noiseDbmAvg;
uint32_t g_samples;
uint16_t g_channelNumber;
uint32_t g_rate;

void MonitorSniffRx (Ptr<const Packet> packet, uint16_t channelFreqMhz,
                     uint16_t channelNumber, WifiTxVector txVector,
                     MpduInfo aMpdu, SignalNoiseDbm signalNoise)
                     struct mpduInfo aMpdu, struct signalNoiseDbm signalNoise)

{
  g_samples++;
  g_signalDbmAvg += ((signalNoise.signal - g_signalDbmAvg) / g_samples);
  g_noiseDbmAvg += ((signalNoise.noise - g_noiseDbmAvg) / g_samples);
  g_rate = rate;
  g_channelNumber = channelNumber;
}


      g_noiseDbmAvg = 0;
      g_samples = 0;
      g_channelNumber = 0;
      g_rate = 0;

      // Make sure we are tuned to 5180 MHz; if not, the example will
      // not work properly

(-)a/src/mesh/model/dot11s/airtime-metric.cc (-1 / +2 lines)

Lines 93-102	Link Here

  NS_ASSERT (failAvg < 1.0);

  NS_ASSERT (failAvg < 1.0);

  WifiTxVector txVector;

  WifiTxVector txVector;

  txVector.SetMode (mode);

  txVector.SetMode (mode);

  txVector.SetPreambleType (WIFI_PREAMBLE_LONG);

  //calculate metric

  //calculate metric

  uint32_t metric = (uint32_t)((double)( /*Overhead + payload*/

  uint32_t metric = (uint32_t)((double)( /*Overhead + payload*/

                                 mac->GetPifs () + mac->GetSlot () + mac->GetEifsNoDifs () + //DIFS + SIFS + AckTxTime = PIFS + SLOT + EifsNoDifs

                                 mac->GetPifs () + mac->GetSlot () + mac->GetEifsNoDifs () + //DIFS + SIFS + AckTxTime = PIFS + SLOT + EifsNoDifs

                                 mac->GetWifiPhy ()->CalculateTxDuration (m_testFrame->GetSize (), txVector, WIFI_PREAMBLE_LONG, mac->GetWifiPhy ()->GetFrequency())

100

                                 mac->GetWifiPhy ()->CalculateTxDuration (m_testFrame->GetSize (), txVector, mac->GetWifiPhy ()->GetFrequency())

100

                                 ).GetMicroSeconds () / (10.24 * (1.0 - failAvg)));

101

                                 ).GetMicroSeconds () / (10.24 * (1.0 - failAvg)));

101

  return metric;

102

  return metric;

102

103

(-)a/src/network/model/packet-tag-list.h (-1 / +1 lines)

158

*/

158

*/

159

    enum TagData_e

159

    enum TagData_e

160

161

      MAX_SIZE = 21           /**< Size of serialization buffer #data */

161

      MAX_SIZE = 26           /**< Size of serialization buffer #data */

162

};

162

};

163

164

    uint8_t data[MAX_SIZE];   /**< Serialization buffer */

164

    uint8_t data[MAX_SIZE];   /**< Serialization buffer */

(-)a/src/wave/model/channel-manager.cc (+7 lines)

Lines 161-166	Link Here

161

  return m_channels[channelNumber]->dataRate;

161

  return m_channels[channelNumber]->dataRate;

162

163

164

WifiPreamble

165

ChannelManager::GetManagementPreamble (uint32_t channelNumber)

166

167

  NS_LOG_FUNCTION (this << channelNumber);

168

  return m_channels[channelNumber]->preamble;

169

170

164

uint32_t

171

uint32_t

165

ChannelManager::GetManagementPowerLevel (uint32_t channelNumber)

172

ChannelManager::GetManagementPowerLevel (uint32_t channelNumber)

166

173

(-)a/src/wave/model/channel-manager.h (+8 lines)

Lines 21-26	Link Here

#include <vector>

#include <vector>

#include "ns3/object.h"

#include "ns3/object.h"

#include "ns3/wifi-mode.h"

#include "ns3/wifi-mode.h"

#include "ns3/wifi-preamble.h"

namespace ns3 {

namespace ns3 {

Lines 116-121	Link Here

116

  WifiMode GetManagementDataRate (uint32_t channelNumber);

117

  WifiMode GetManagementDataRate (uint32_t channelNumber);

117

/**

118

/**

118

   * \param channelNumber the specific channel

119

   * \param channelNumber the specific channel

120

   * \return the preamble for management frames

121

*/

122

  WifiPreamble GetManagementPreamble (uint32_t channelNumber);

123

/**

124

   * \param channelNumber the specific channel

119

   * \return the tx power level for management frames

125

   * \return the tx power level for management frames

120

*/

126

*/

121

  uint32_t GetManagementPowerLevel (uint32_t channelNumber);

127

  uint32_t GetManagementPowerLevel (uint32_t channelNumber);

Lines 130-135	Link Here

130

    uint32_t operatingClass;

136

    uint32_t operatingClass;

131

    bool adaptable;

137

    bool adaptable;

132

    WifiMode dataRate;

138

    WifiMode dataRate;

139

    WifiPreamble preamble;

133

    uint32_t txPowerLevel;

140

    uint32_t txPowerLevel;

134

141

135

    WaveChannel (uint32_t channel)

142

    WaveChannel (uint32_t channel)

Lines 137-142	Link Here

137

        operatingClass (DEFAULT_OPERATING_CLASS),

144

        operatingClass (DEFAULT_OPERATING_CLASS),

138

        adaptable (true),

145

        adaptable (true),

139

        dataRate (WifiMode ("OfdmRate6MbpsBW10MHz")),

146

        dataRate (WifiMode ("OfdmRate6MbpsBW10MHz")),

147

        preamble (WIFI_PREAMBLE_LONG),

140

        txPowerLevel (4)

148

        txPowerLevel (4)

141

149

142

150

(-)a/src/wave/model/vsa-manager.cc (+1 lines)

Lines 178-183	Link Here

178

  txVector.SetChannelWidth (10);

178

  txVector.SetChannelWidth (10);

179

  txVector.SetTxPowerLevel (manager->GetManagementPowerLevel (channel));

179

  txVector.SetTxPowerLevel (manager->GetManagementPowerLevel (channel));

180

  txVector.SetMode (manager->GetManagementDataRate (channel));

180

  txVector.SetMode (manager->GetManagementDataRate (channel));

181

  txVector.SetPreambleType (manager->GetManagementPreamble (channel));

181

  HigherLayerTxVectorTag tag = HigherLayerTxVectorTag (txVector, manager->GetManagementAdaptable (channel));

182

  HigherLayerTxVectorTag tag = HigherLayerTxVectorTag (txVector, manager->GetManagementAdaptable (channel));

182

  vsc->AddPacketTag (tag);

183

  vsc->AddPacketTag (tag);

183

184




  if (txHigher.GetMode ().GetDataRate (txHigher.GetChannelWidth (), txHigher.IsShortGuardInterval (), 1) > txMac.GetMode ().GetDataRate (txMac.GetChannelWidth (), txMac.IsShortGuardInterval (), 1))
    {
      txAdapter.SetMode (txHigher.GetMode ());
      txAdapter.SetPreambleType (txHigher.GetPreambleType ());
    }
  else
    {
      txAdapter.SetMode (txMac.GetMode ());
      txAdapter.SetPreambleType (txMac.GetPreambleType ());
    }
  // the TxPwr_Level set by higher layer is the maximum transmit
  // power which is the upper bound for the actual transmit power;

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

Lines 411-416	Link Here

411

      txVector.SetChannelWidth (10);

411

      txVector.SetChannelWidth (10);

412

      txVector.SetTxPowerLevel (txInfo.txPowerLevel);

412

      txVector.SetTxPowerLevel (txInfo.txPowerLevel);

413

      txVector.SetMode (txInfo.dataRate);

413

      txVector.SetMode (txInfo.dataRate);

414

      txVector.SetPreambleType (txInfo.preamble);

414

      HigherLayerTxVectorTag tag = HigherLayerTxVectorTag (txVector, false);

415

      HigherLayerTxVectorTag tag = HigherLayerTxVectorTag (txVector, false);

415

      packet->AddPacketTag (tag);

416

      packet->AddPacketTag (tag);

416

417

Lines 618-623	Link Here

618

      WifiTxVector txVector;

619

      WifiTxVector txVector;

619

      txVector.SetTxPowerLevel (m_txProfile->txPowerLevel);

620

      txVector.SetTxPowerLevel (m_txProfile->txPowerLevel);

620

      txVector.SetMode (m_txProfile->dataRate);

621

      txVector.SetMode (m_txProfile->dataRate);

622

      txVector.SetPreambleType (m_txProfile->preamble);

621

      HigherLayerTxVectorTag tag = HigherLayerTxVectorTag (txVector, m_txProfile->adaptable);

623

      HigherLayerTxVectorTag tag = HigherLayerTxVectorTag (txVector, m_txProfile->adaptable);

622

      packet->AddPacketTag (tag);

624

      packet->AddPacketTag (tag);

623

625




  uint32_t channelNumber;
  uint32_t priority;
  WifiMode dataRate;
  WifiPreamble preamble;
  uint32_t txPowerLevel;
  // Time expiryTime;   // unsupported
  TxInfo ()

  {

  }
  TxInfo (uint32_t channel, uint32_t prio = 7, WifiMode rate = WifiMode (), WifiPreamble preamble = WIFI_PREAMBLE_NONE, uint32_t powerLevel = 8)
    : channelNumber (channel),
      priority (prio),
      dataRate (rate),

  bool adaptable;
  uint32_t txPowerLevel;
  WifiMode dataRate;
  WifiPreamble preamble;
  TxProfile (void)
    : channelNumber (SCH1),
      adaptable (false),
      txPowerLevel (4),
      preamble (WIFI_PREAMBLE_LONG)
  {
      dataRate = WifiMode ("OfdmRate6MbpsBW10MHz");
  }

      txPowerLevel (powerLevel)
  {
      dataRate = WifiMode ("OfdmRate6MbpsBW10MHz");
      preamble = WIFI_PREAMBLE_LONG;
  }
};





    // invalid user priority
    Simulator::Schedule (Seconds (0.4), &ChannelRoutingTestCase::SendWsmp, this, false, TxInfo (CCH, 8));
    // invalid tx parameters
    Simulator::Schedule (Seconds (0.4), &ChannelRoutingTestCase::SendWsmp, this, false, TxInfo (CCH, 7, WifiMode ("OfdmRate6Mbps"), WIFI_PREAMBLE_LONG, 7));
    Simulator::Schedule (Seconds (0.4), &ChannelRoutingTestCase::SendWsmp, this, false, TxInfo (CCH, 7, WifiMode ("OfdmRate3MbpsBW10MHz"), WIFI_PREAMBLE_LONG, 10));
    // valid tx parameters
    Simulator::Schedule (Seconds (0.4), &ChannelRoutingTestCase::SendWsmp, this, true, TxInfo (CCH, 7, WifiMode ("OfdmRate3MbpsBW10MHz"), WIFI_PREAMBLE_LONG, 7));
    Simulator::Schedule (Seconds (0.4), &ChannelRoutingTestCase::SendWsmp, this, true, TxInfo (CCH, 7, WifiMode (), WIFI_PREAMBLE_LONG, 8));

    // release channel access at 0.6s
    Simulator::Schedule (Seconds (0.5), &WaveNetDevice::StopSch, m_sender, SCH1);

  SchInfo infoSender = SchInfo (SCH1, false, EXTENDED_ALTERNATING);
  Simulator::Schedule (MilliSeconds (0), &WaveNetDevice::StartSch, m_sender, infoSender);

  TxInfo txInfo = TxInfo (CCH, 0, WifiMode ("OfdmRate3MbpsBW10MHz"), WIFI_PREAMBLE_LONG, 0);
  // the packet size with 2312 bytes costs 6.42s, which will cancel this transmission in the CCH Interval
  // so the receiver will receive this packet in next CCH Interval
  Simulator::Schedule (MilliSeconds (45), &AnnexC_TestCase::SendPacket, this, 2304, txInfo, 1);

  // so the receiver can this packet is this CCH Interval
  Simulator::Schedule (MilliSeconds (145), &AnnexC_TestCase::SendPacket, this, 312, txInfo, 2);

  txInfo = TxInfo (SCH1, 0, WifiMode ("OfdmRate3MbpsBW10MHz"), WIFI_PREAMBLE_LONG, 0);
  // the packet size with 2312 bytes costs 6.42ms, which will cancel this transmission in the SCH Interval
  // so the receiver will receive this packet in next SCH Interval
  Simulator::Schedule (MilliSeconds (295), &AnnexC_TestCase::SendPacket, this, 2304, txInfo, 3);




    uint32_t txPowerLevelB;
    uint32_t packetSizeA;
    uint32_t packetSizeB;
    WifiPhyStandard standard;
    WifiPreamble preamble;
  };

  InterferenceExperiment ();

  WifiTxVector txVector;
  txVector.SetTxPowerLevel (m_input.txPowerLevelA);
  txVector.SetMode (WifiMode (m_input.txModeA));
  txVector.SetPreambleType (m_input.preamble);
  m_txA->SendPacket (p, txVector);
}

void

  WifiTxVector txVector;
  txVector.SetTxPowerLevel (m_input.txPowerLevelB);
  txVector.SetMode (WifiMode (m_input.txModeB));
  txVector.SetPreambleType (m_input.preamble);
  m_txB->SendPacket (p, txVector);
}

InterferenceExperiment::InterferenceExperiment ()





private:
  void Send (void);
  void Receive (Ptr<Packet> p, double snr, WifiTxVector txVector);
  Ptr<WifiPhy> m_tx;
  struct Input m_input;
  struct Output m_output;

  WifiTxVector txVector;
  txVector.SetTxPowerLevel (m_input.txPowerLevel);
  txVector.SetMode (mode);
  txVector.SetPreambleType (WIFI_PREAMBLE_LONG);
  m_tx->SendPacket (p, txVector);
}

void
PsrExperiment::Receive (Ptr<Packet> p, double snr, WifiTxVector txVector)
{
  m_output.received++;
}

private:
  void SendA (void) const;
  void SendB (void) const;
  void Receive (Ptr<Packet> p, double snr, WifiTxVector txVector);
  Ptr<WifiPhy> m_txA;
  Ptr<WifiPhy> m_txB;
  uint32_t m_flowIdA;

  WifiTxVector txVector;
  txVector.SetTxPowerLevel (m_input.txPowerLevelA);
  txVector.SetMode (WifiMode (m_input.txModeA));
  txVector.SetPreambleType (WIFI_PREAMBLE_LONG);
  m_txA->SendPacket (p, txVector);
}

void

  WifiTxVector txVector;
  txVector.SetTxPowerLevel (m_input.txPowerLevelB);
  txVector.SetMode (WifiMode (m_input.txModeB));
  txVector.SetPreambleType (WIFI_PREAMBLE_LONG);
  m_txB->SendPacket (p, txVector);
}

void
CollisionExperiment::Receive (Ptr<Packet> p, double snr, WifiTxVector txVector)
{
  FlowIdTag tag;
  if (p->FindFirstMatchingByteTag (tag))




  Ptr<const Packet>    packet,
  uint16_t             channelFreqMhz,
  uint16_t             channelNumber,
  uint32_t             rate,
  WifiPreamble         preamble,
  WifiTxVector         txVector,
  MpduInfo             aMpdu)
{
  uint32_t dlt = file->GetDataLinkType ();
  WifiPreamble preamble = txVector.GetPreambleType ();

  switch (dlt)
    {

          }

        header.SetFrameFlags (frameFlags);
        
        uint32_t rate;
        if (txVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_HT || txVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_VHT)
          {
            rate = 128 + txVector.GetMode ().GetMcsValue ();
          }
        else
          {
            rate = txVector.GetMode ().GetDataRate (txVector.GetChannelWidth (), txVector.IsShortGuardInterval (), 1) * txVector.GetNss () / 500000;
          }
        header.SetRate (rate);

        uint16_t channelFlags = 0;

  Ptr<const Packet>     packet,
  uint16_t              channelFreqMhz,
  uint16_t              channelNumber,
  uint32_t              rate,
  WifiPreamble          preamble,
  WifiTxVector          txVector,
  MpduInfo              aMpdu,
  SignalNoiseDbm        signalNoise)
{
  uint32_t dlt = file->GetDataLinkType ();
  WifiPreamble preamble = txVector.GetPreambleType ();

  switch (dlt)
    {

          }

        header.SetFrameFlags (frameFlags);
        
        uint32_t rate;
        if (txVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_HT || txVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_VHT)
          {
            rate = 128 + txVector.GetMode ().GetMcsValue ();
          }
        else
          {
            rate = txVector.GetMode ().GetDataRate (txVector.GetChannelWidth (), txVector.IsShortGuardInterval (), 1) * txVector.GetNss () / 500000;
          }
        header.SetRate (rate);

        uint16_t channelFlags = 0;




   * \param packet the packet
   * \param channelFreqMhz the channel frequency
   * \param channelNumber the channel number
   * \param rate the PHY bitrate
   * \param preamble the preamble type
   * \param txVector the TXVECTOR
   * \param aMpdu the A-MPDU information
   *

                                Ptr<const Packet> packet,
                                uint16_t channelFreqMhz,
                                uint16_t channelNumber,
                                uint32_t rate,
                                WifiPreamble preamble,
                                WifiTxVector txVector,
                                MpduInfo aMpdu);
  /**
   * \param file the pcap file wrapper
   * \param packet the packet
   * \param channelFreqMhz the channel frequency
   * \param channelNumber the channel number
   * \param rate the PHY bitrate
   * \param preamble the preamble type
   * \param txVector the TXVECTOR
   * \param aMpdu the A-MPDU information
   * \param signalNoise the rx signal and noise information

                                Ptr<const Packet> packet,
                                uint16_t channelFreqMhz,
                                uint16_t channelNumber,
                                uint32_t rate,
                                WifiPreamble preamble,
                                WifiTxVector txVector,
                                MpduInfo aMpdu,
                                SignalNoiseDbm signalNoise);
    
  ObjectFactory m_phy;
  ObjectFactory m_errorRateModel;




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

WifiTxVector

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





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

WifiTxVector

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





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

WifiTxVector

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





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

WifiTxVector

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





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

WifiTxVector

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






bool
BlockAckManager::ExistsAgreementInState (Mac48Address recipient, uint8_t tid,
                                         OriginatorBlockAckAgreement::State state) const
{
  NS_LOG_FUNCTION (this << recipient << static_cast<uint32_t> (tid) << state);
  AgreementsCI it;

}

bool
BlockAckManager::HasBar (Bar &bar)
{
  NS_LOG_FUNCTION (this << &bar);
  if (m_bars.size () > 0)

}

void
BlockAckManager::SetBlockAckType (BlockAckType bAckType)
{
  NS_LOG_FUNCTION (this << bAckType);
  m_blockAckType = bAckType;

}

void
BlockAckManager::NotifyMpduTransmission (Mac48Address recipient, uint8_t tid, uint16_t nextSeqNumber, WifiMacHeader::QosAckPolicy policy)
{
  NS_LOG_FUNCTION (this << recipient << static_cast<uint32_t> (tid) << nextSeqNumber);
  Ptr<Packet> bar = 0;




   * station addressed by <i>recipient</i> for tid <i>tid</i>.
   */
  bool ExistsAgreementInState (Mac48Address recipient, uint8_t tid,
                               OriginatorBlockAckAgreement::State state) const;
  /**
   * \param reqHdr Relative Add block ack request (action frame).
   * \param recipient Address of peer station involved in block ack mechanism.

   * corresponding block ack bitmap. This method doesn't remove the packet from this queue.
   */
  Ptr<const Packet> PeekNextPacket (WifiMacHeader &hdr);
  bool HasBar (Bar &bar);
  /**
   * Returns true if there are packets that need of retransmission or at least a
   * BAR is scheduled. Returns false otherwise.

   *
   * See ctrl-headers.h for more details.
   */
  void SetBlockAckType (BlockAckType bAckType);
  /**
   * \param recipient Address of station involved in block ack mechanism.
   * \param tid Traffic ID.

  std::list<Bar> m_bars;

  uint8_t m_blockAckThreshold;
  BlockAckType m_blockAckType;
  Time m_maxDelay;
  MacTxMiddle* m_txMiddle;
  Mac48Address m_address;




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

WifiTxVector

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





ConstantRateWifiManager::DoGetDataTxVector (WifiRemoteStation *st)
{
  NS_LOG_FUNCTION (this << st);
  return WifiTxVector (m_dataMode, GetDefaultTxPowerLevel (), GetLongRetryCount (st), GetPreambleForTransmission (m_dataMode, GetAddress (st)), GetShortGuardInterval (st), Min(GetNumberOfTransmitAntennas (), GetNumberOfSupportedRxAntennas (st)), 0, GetChannelWidth (st), GetAggregation (st), false);
}

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

bool

(-)a/src/wifi/model/ctrl-headers.cc (-2 / +2 lines)

Lines 195-201	Link Here

195

196

197

void

197

void

198

CtrlBAckRequestHeader::SetType (enum BlockAckType type)

198

CtrlBAckRequestHeader::SetType (BlockAckType type)

199

200

  NS_LOG_FUNCTION (this << type);

200

  NS_LOG_FUNCTION (this << type);

201

  switch (type)

201

  switch (type)

Lines 408-414	Link Here

408

409

410

void

410

void

411

CtrlBAckResponseHeader::SetType (enum BlockAckType type)

411

CtrlBAckResponseHeader::SetType (BlockAckType type)

412

413

  NS_LOG_FUNCTION (this << type);

413

  NS_LOG_FUNCTION (this << type);

414

  switch (type)

414

  switch (type)

(-)a/src/wifi/model/ctrl-headers.h (-2 / +2 lines)

Lines 70-76	Link Here

   * \param type

   * \param type

*/

*/

  void SetType (enum BlockAckType type);

  void SetType (BlockAckType type);

/**

/**

   * Set Traffic ID (TID).

   * Set Traffic ID (TID).

Lines 206-212	Link Here

206

207

   * \param type

207

   * \param type

208

*/

208

*/

209

  void SetType (enum BlockAckType type);

209

  void SetType (BlockAckType type);

210

/**

210

/**

211

   * Set Traffic ID (TID).

211

   * Set Traffic ID (TID).

212




}

void
EdcaTxopN::SetTypeOfStation (TypeOfStation type)
{
  NS_LOG_FUNCTION (this << static_cast<uint32_t> (type));
  m_typeOfStation = type;
}

TypeOfStation
EdcaTxopN::GetTypeOfStation (void) const
{
  NS_LOG_FUNCTION (this);

}

void
EdcaTxopN::SetAccessCategory (AcIndex ac)
{
  NS_LOG_FUNCTION (this << static_cast<uint32_t> (ac));
  m_ac = ac;

}

void
EdcaTxopN::SendBlockAckRequest (const Bar &bar)
{
  NS_LOG_FUNCTION (this << &bar);
  WifiMacHeader hdr;




   *
   * \param type
   */
  void SetTypeOfStation (TypeOfStation type);
  /**
   * Return type of station.
   *
   * \return type of station
   */
  TypeOfStation GetTypeOfStation (void) const;
  /**
   * Return the packet queue associated with this EdcaTxopN.
   *
   * \return WifiMacQueue
   */
  Ptr<WifiMacQueue> GetEdcaQueue () const;

  virtual void SetMinCw (uint32_t minCw);
  virtual void SetMaxCw (uint32_t maxCw);

   *
   * \param ac
   */
  void SetAccessCategory (AcIndex ac);

  /**
   * \param packet packet to send

   *
   * \param bar
   */
  void SendBlockAckRequest (const Bar &bar);
  /**
   * For now is typically invoked to complete transmission of a packets sent with ack policy
   * Block Ack: the packet is buffered and dcf is reset.

   * Represents the minimum number of packets for use of block ack.
   */
  uint8_t m_blockAckThreshold;
  BlockAckType m_blockAckType;
  Time m_currentPacketTimestamp;
  uint16_t m_blockAckInactivityTimeout;
  Bar m_currentBar;
  Time m_startTxop;
  bool m_isAccessRequestedForRts;
  TracedValue<uint32_t> m_backoffTrace;

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

Lines 370-376	Link Here

370

      NS_LOG_DEBUG ("New datarate: " << maxMode.GetDataRate (channelWidth, GetPhy ()->GetGuardInterval (), nss));

370

      NS_LOG_DEBUG ("New datarate: " << maxMode.GetDataRate (channelWidth, GetPhy ()->GetGuardInterval (), nss));

371

      m_currentRate = maxMode.GetDataRate (channelWidth, GetPhy ()->GetGuardInterval (), nss);

371

      m_currentRate = maxMode.GetDataRate (channelWidth, GetPhy ()->GetGuardInterval (), nss);

372

373

  return WifiTxVector (maxMode, GetDefaultTxPowerLevel (), GetLongRetryCount (station), false, nss, 0, channelWidth, GetAggregation (station), false);

373

  return WifiTxVector (maxMode, GetDefaultTxPowerLevel (), GetLongRetryCount (station), GetPreambleForTransmission (maxMode, GetAddress (station)), false, nss, 0, channelWidth, GetAggregation (station), false);

374

375

376

WifiTxVector

376

WifiTxVector

Lines 402-408	Link Here

402

          maxMode = mode;

402

          maxMode = mode;

403

404

405

  return WifiTxVector (maxMode, GetDefaultTxPowerLevel (), GetShortRetryCount (station), false, nss, 0, GetChannelWidthForMode (maxMode), GetAggregation (station), false);

405

  return WifiTxVector (maxMode, GetDefaultTxPowerLevel (), GetShortRetryCount (station), GetPreambleForTransmission (maxMode, GetAddress (station)), false, nss, 0, GetChannelWidthForMode (maxMode), GetAggregation (station), false);

406

407

408

bool

408

bool




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

InterferenceHelper::Event::Event (uint32_t size, WifiTxVector txVector, Time duration, double rxPower)
                                  enum WifiPreamble preamble,
                                  Time duration, double rxPower)
  : m_size (size),
    m_txVector (txVector),
    m_preamble (preamble),
    m_startTime (Simulator::Now ()),
    m_endTime (m_startTime + duration),
    m_rxPowerW (rxPower)

  return m_txVector.GetMode ();
}

enum WifiPreamble
InterferenceHelper::Event::GetPreambleType (void) const
{
  return m_preamble;
}


/****************************************************************
 *       Class which records SNIR change events for a

}

Ptr<InterferenceHelper::Event>
InterferenceHelper::Add (uint32_t size, WifiTxVector txVector, Time duration, double rxPowerW)
                         enum WifiPreamble preamble,
                         Time duration, double rxPowerW)
{
  Ptr<InterferenceHelper::Event> event;

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

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

void

  NiChanges::iterator j = ni->begin ();
  Time previous = (*j).GetTime ();
  WifiMode payloadMode = event->GetPayloadMode ();
  WifiPreamble preamble = event->GetTxVector ().GetPreambleType ();
  Time plcpHeaderStart = (*j).GetTime () + WifiPhy::GetPlcpPreambleDuration (event->GetTxVector ()); //packet start time + preamble
  Time plcpHsigHeaderStart = plcpHeaderStart + WifiPhy::GetPlcpHeaderDuration (event->GetTxVector ()); //packet start time + preamble + L-SIG
  Time plcpHtTrainingSymbolsStart = plcpHsigHeaderStart + WifiPhy::GetPlcpHtSigHeaderDuration (preamble) + WifiPhy::GetPlcpVhtSigA1Duration (preamble) + WifiPhy::GetPlcpVhtSigA2Duration (preamble); //packet start time + preamble + L-SIG + HT-SIG or VHT-SIG-A (A1 + A2)
  Time plcpPayloadStart = plcpHtTrainingSymbolsStart + WifiPhy::GetPlcpHtTrainingSymbolDuration (event->GetTxVector ()) + WifiPhy::GetPlcpVhtSigBDuration (preamble); //packet start time + preamble + L-SIG + HT-SIG or VHT-SIG-A (A1 + A2) + (V)HT Training + VHT-SIG-B
  double noiseInterferenceW = (*j).GetDelta ();
  double powerW = event->GetRxPowerW ();
  j++;

  NiChanges::iterator j = ni->begin ();
  Time previous = (*j).GetTime ();
  WifiMode payloadMode = event->GetPayloadMode ();
  WifiPreamble preamble = event->GetTxVector ().GetPreambleType ();
  WifiMode htHeaderMode;
  if (preamble == WIFI_PREAMBLE_HT_MF || preamble == WIFI_PREAMBLE_HT_GF)
    {

      //mode for PLCP header fields sent with VHT modulation
      htHeaderMode = WifiPhy::GetVhtPlcpHeaderMode (payloadMode);
    }
  WifiMode headerMode = WifiPhy::GetPlcpHeaderMode (event->GetTxVector ());
  Time plcpHeaderStart = (*j).GetTime () + WifiPhy::GetPlcpPreambleDuration (event->GetTxVector ()); //packet start time + preamble
  Time plcpHsigHeaderStart = plcpHeaderStart + WifiPhy::GetPlcpHeaderDuration (event->GetTxVector ()); //packet start time + preamble + L-SIG
  Time plcpHtTrainingSymbolsStart = plcpHsigHeaderStart + WifiPhy::GetPlcpHtSigHeaderDuration (preamble) + WifiPhy::GetPlcpVhtSigA1Duration (preamble) + WifiPhy::GetPlcpVhtSigA2Duration (preamble); //packet start time + preamble + L-SIG + HT-SIG or VHT-SIG-A (A1 + A2)
  Time plcpPayloadStart = plcpHtTrainingSymbolsStart + WifiPhy::GetPlcpHtTrainingSymbolDuration (event->GetTxVector ()) + WifiPhy::GetPlcpVhtSigBDuration (preamble); //packet start time + preamble + L-SIG + HT-SIG or VHT-SIG-A (A1 + A2) + (V)HT Training + VHT-SIG-B
  double noiseInterferenceW = (*j).GetDelta ();
  double powerW = event->GetRxPowerW ();
  j++;




#include <vector>
#include <list>
#include "wifi-mode.h"
#include "wifi-preamble.h"
#include "wifi-phy-standard.h"
#include "ns3/nstime.h"
#include "ns3/simple-ref-count.h"

     *
     * \param size packet size
     * \param txVector TXVECTOR of the packet
     * \param preamble preamble type
     * \param duration duration of the signal
     * \param rxPower the receive power (w)
     */
    Event (uint32_t size, WifiTxVector txVector, Time duration, double rxPower);
           enum WifiPreamble preamble,
           Time duration, double rxPower);
    ~Event ();

    /**

     * \return the Wi-Fi mode used for the payload
     */
    WifiMode GetPayloadMode (void) const;
    /**
     * Return the preamble type of the packet.
     *
     * \return the preamble type of the packet
     */
    enum WifiPreamble GetPreambleType (void) const;


private:
    uint32_t m_size;
    WifiTxVector m_txVector;
    enum WifiPreamble m_preamble;
    Time m_startTime;
    Time m_endTime;
    double m_rxPowerW;

   *
   * \param size packet size
   * \param txVector TXVECTOR of the packet
   * \param preamble Wi-Fi preamble for the packet
   * \param duration the duration of the signal
   * \param rxPower receive power (W)
   *
   * \return InterferenceHelper::Event
   */
  Ptr<InterferenceHelper::Event> Add (uint32_t size, WifiTxVector txVector, Time duration, double rxPower);
                                      enum WifiPreamble preamble,
                                      Time duration, double rxPower);

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




void
MacLow::ResetPhy (void)
{
  m_phy->SetReceiveOkCallback (MakeNullCallback<void, Ptr<Packet>, double, WifiTxVector> ());
  m_phy->SetReceiveErrorCallback (MakeNullCallback<void, Ptr<Packet>, double> ());
  RemovePhyMacLowListener (m_phy);
  m_phy = 0;

}

void
MacLow::ReceiveOk (Ptr<Packet> packet, double rxSnr, WifiTxVector txVector, bool ampduSubframe)
{
  NS_LOG_FUNCTION (this << packet << rxSnr << txVector.GetMode () << txVector.GetPreambleType ());
  /* A packet is received from the PHY.
   * When we have handled this packet,
   * we handle any packet present in the


  bool isPrevNavZero = IsNavZero ();
  NS_LOG_DEBUG ("duration/id=" << hdr.GetDuration ());
  NotifyNav (packet, hdr, txVector.GetPreambleType ());
  if (hdr.IsRts ())
    {
      /* see section 9.2.5.7 802.11-1999

}

uint32_t
MacLow::GetBlockAckSize (BlockAckType type) const
{
  WifiMacHeader hdr;
  hdr.SetType (WIFI_MAC_CTL_BACKRESP);

MacLow::GetAckDuration (WifiTxVector ackTxVector) const
{
  NS_ASSERT (ackTxVector.GetMode ().GetModulationClass () != WIFI_MOD_CLASS_HT); //ACK should always use non-HT PPDU (HT PPDU cases not supported yet)
  return m_phy->CalculateTxDuration (GetAckSize (), ackTxVector, m_phy->GetFrequency ());
  if (m_stationManager->GetShortPreambleEnabled ())
    {
      preamble = WIFI_PREAMBLE_SHORT;
    }
  else
    {
      preamble = WIFI_PREAMBLE_LONG;
    }
  return m_phy->CalculateTxDuration (GetAckSize (), ackTxVector, preamble, m_phy->GetFrequency ());
}

Time
MacLow::GetBlockAckDuration (Mac48Address to, WifiTxVector blockAckReqTxVector, BlockAckType type) const
{
  /*
   * For immediate Basic BlockAck we should transmit the frame with the same WifiMode
   * as the BlockAckReq.
   */
  return m_phy->CalculateTxDuration (GetBlockAckSize (type), blockAckReqTxVector, m_phy->GetFrequency ());
  if (blockAckReqTxVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_HT && type == BASIC_BLOCK_ACK)
    {
      preamble = WIFI_PREAMBLE_HT_MF;
    }
  else if (m_stationManager->GetShortPreambleEnabled ())
    {
      preamble = WIFI_PREAMBLE_SHORT;
    }
  else
    {
      preamble = WIFI_PREAMBLE_LONG;
    }
  return m_phy->CalculateTxDuration (GetBlockAckSize (type), blockAckReqTxVector, preamble, m_phy->GetFrequency ());
}

Time

MacLow::GetCtsDuration (WifiTxVector ctsTxVector) const
{
  NS_ASSERT (ctsTxVector.GetMode ().GetModulationClass () != WIFI_MOD_CLASS_HT); //CTS should always use non-HT PPDU (HT PPDU cases not supported yet)
  return m_phy->CalculateTxDuration (GetCtsSize (), ctsTxVector, m_phy->GetFrequency ());
  if (m_stationManager->GetShortPreambleEnabled ())
    {
      preamble = WIFI_PREAMBLE_SHORT;
    }
  else
    {
      preamble = WIFI_PREAMBLE_LONG;
    }
  return m_phy->CalculateTxDuration (GetCtsSize (), ctsTxVector, preamble, m_phy->GetFrequency ());
}

uint32_t

                                const WifiMacHeader* hdr,
                                const MacLowTransmissionParameters& params) const
{
  WifiPreamble preamble;
  Time txTime = Seconds (0);
  if (params.MustSendRts ())
    {
      WifiTxVector rtsTxVector = GetRtsTxVector (packet, hdr);
      txTime += m_phy->CalculateTxDuration (GetRtsSize (), rtsTxVector, m_phy->GetFrequency ());
        {
          preamble = WIFI_PREAMBLE_SHORT;
        }
      else
        {
          preamble = WIFI_PREAMBLE_LONG;
        }
      txTime += m_phy->CalculateTxDuration (GetRtsSize (), rtsTxVector, preamble, m_phy->GetFrequency ());
      txTime += GetCtsDuration (hdr->GetAddr1 (), rtsTxVector);
      txTime += Time (GetSifs () * 2);
    }
  WifiTxVector dataTxVector = GetDataTxVector (packet, hdr);
  if (dataTxVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_VHT)
    {
      preamble = WIFI_PREAMBLE_VHT;
    }
  else if (dataTxVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_HT && m_phy->GetGreenfield () && m_stationManager->GetGreenfieldSupported (m_currentHdr.GetAddr1 ()))
    {
      preamble = WIFI_PREAMBLE_HT_GF;
    }
  else if (dataTxVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_HT)
    {
      preamble = WIFI_PREAMBLE_HT_MF;
    }
  else if (m_stationManager->GetShortPreambleEnabled ())
    {
      preamble = WIFI_PREAMBLE_SHORT;
    }
  else
    {
      preamble = WIFI_PREAMBLE_LONG;
    }
  uint32_t dataSize = GetSize (packet, hdr);
  txTime += m_phy->CalculateTxDuration (dataSize, dataTxVector, m_phy->GetFrequency ());
  if (params.MustWaitAck ())
    {
      txTime += GetSifs ();

  if (params.HasNextPacket ())
    {
      WifiTxVector dataTxVector = GetDataTxVector (packet, hdr);
      WifiPreamble preamble;
      if (dataTxVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_HT)
        {
          preamble = WIFI_PREAMBLE_VHT;
        }
      if (dataTxVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_HT && m_phy->GetGreenfield () && m_stationManager->GetGreenfieldSupported (m_currentHdr.GetAddr1 ()))
        {
          preamble = WIFI_PREAMBLE_HT_GF;
        }
      else if (dataTxVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_HT)
        {
          preamble = WIFI_PREAMBLE_HT_MF;
        }
      else if (m_stationManager->GetShortPreambleEnabled ())
        {
          preamble = WIFI_PREAMBLE_SHORT;
        }
      else
        {
          preamble = WIFI_PREAMBLE_LONG;
        }
      txTime += GetSifs ();
      txTime += m_phy->CalculateTxDuration (params.GetNextPacketSize (), dataTxVector, m_phy->GetFrequency ());
    }
  return txTime;
}

          cts.SetType (WIFI_MAC_CTL_CTS);
          WifiTxVector txVector = GetRtsTxVector (packet, &hdr);
          Time navCounterResetCtsMissedDelay =
            m_phy->CalculateTxDuration (cts.GetSerializedSize (), txVector, m_phy->GetFrequency ()) +
            Time (2 * GetSifs ()) + Time (2 * GetSlotTime ());
          m_navCounterResetCtsMissed = Simulator::Schedule (navCounterResetCtsMissedDelay,
                                                            &MacLow::NavCounterResetCtsMissed, this,

}

void
MacLow::ForwardDown (Ptr<const Packet> packet, const WifiMacHeader* hdr, WifiTxVector txVector)
                     WifiTxVector txVector, WifiPreamble preamble)
{
  NS_LOG_FUNCTION (this << packet << hdr << txVector);
  NS_LOG_DEBUG ("send " << hdr->GetTypeString () <<
                ", to=" << hdr->GetAddr1 () <<
                ", size=" << packet->GetSize () <<
                ", mode=" << txVector.GetMode  () <<
                ", preamble=" << txVector.GetPreambleType () <<
                ", duration=" << hdr->GetDuration () <<
                ", seq=0x" << std::hex << m_currentHdr.GetSequenceControl () << std::dec);
  if (!m_ampdu || hdr->IsRts () || hdr->IsBlockAck ())
    {
      m_phy->SendPacket (packet, txVector);
    }
  else
    {

      uint32_t queueSize = m_aggregateQueue->GetSize ();
      bool vhtSingleMpdu = false;
      bool last = false;
      MpduType mpdutype = NORMAL_MPDU;
      
      uint8_t tid = GetTid (packet, *hdr);
      AcIndex ac = QosUtilsMapTidToAc (tid);

      AmpduTag ampdutag;
      ampdutag.SetAmpdu (true);
      Time delay = Seconds (0);
      Time remainingAmpduDuration = m_phy->CalculateTxDuration (packet->GetSize (), txVector, m_phy->GetFrequency ());
      if (queueSize > 1 || vhtSingleMpdu)
        {
          txVector.SetAggregation (true);

                }
            }
          
          Time mpduDuration = m_phy->CalculateTxDuration (newPacket->GetSize (), txVector, m_phy->GetFrequency (), mpdutype, 0);
          remainingAmpduDuration -= mpduDuration;

          ampdutag.SetRemainingNbOfMpdus (queueSize - 1);


          if (delay == Seconds (0))
            {
              m_phy->SendPacket (newPacket, txVector, mpdutype);
            }
          else
            {
              Simulator::Schedule (delay, &MacLow::SendMpdu, this, newPacket, txVector, mpdutype);
            }
          if (queueSize > 1)
            {

              delay = delay + mpduDuration;
            }

          txVector.SetPreambleType (WIFI_PREAMBLE_NONE);
        }
    }
}

void
MacLow::SendMpdu (Ptr<const Packet> packet, WifiTxVector txVector, MpduType mpdutype)
{
  NS_LOG_DEBUG ("Sending MPDU as part of A-MPDU");
  m_phy->SendPacket (packet, txVector, mpdutype);
}

void

  WifiTxVector rtsTxVector = GetRtsTxVector (m_currentPacket, &m_currentHdr);
  Time duration = Seconds (0);

  WifiPreamble preamble;
  if (m_stationManager->GetShortPreambleEnabled ())
    {
      preamble = WIFI_PREAMBLE_SHORT;
    }
  else
    {
      preamble = WIFI_PREAMBLE_LONG;
    }

  if (m_txParams.HasDurationId ())
    {
      duration += m_txParams.GetDurationId ();

      duration += GetCtsDuration (m_currentHdr.GetAddr1 (), rtsTxVector);
      duration += GetSifs ();
      duration += m_phy->CalculateTxDuration (GetSize (m_currentPacket, &m_currentHdr),
                                              m_currentTxVector, m_phy->GetFrequency ());
      duration += GetSifs ();
      if (m_txParams.MustWaitBasicBlockAck ())
        {

      if (m_txParams.HasNextPacket ())
        {
          duration += m_phy->CalculateTxDuration (m_txParams.GetNextPacketSize (),
                                                  m_currentTxVector, m_phy->GetFrequency ());
          if (m_txParams.MustWaitAck ())
            {
              duration += GetSifs ();

    }
  rts.SetDuration (duration);

  Time txDuration = m_phy->CalculateTxDuration (GetRtsSize (), rtsTxVector, m_phy->GetFrequency ());
  Time timerDelay = txDuration + GetCtsTimeout ();

  NS_ASSERT (m_ctsTimeoutEvent.IsExpired ());

  WifiMacTrailer fcs;
  packet->AddTrailer (fcs);

  ForwardDown (packet, &rts, rtsTxVector);
}

void
MacLow::StartDataTxTimers (WifiTxVector dataTxVector)
{
  Time txDuration = m_phy->CalculateTxDuration (GetSize (m_currentPacket, &m_currentHdr), dataTxVector, m_phy->GetFrequency ());

  if (dataTxVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_VHT)
    {
      preamble = WIFI_PREAMBLE_VHT;
    }
  //Since it is data then it can have format = GF
  else if (dataTxVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_HT && m_phy->GetGreenfield () && m_stationManager->GetGreenfieldSupported (m_currentHdr.GetAddr1 ()))
    {
      preamble = WIFI_PREAMBLE_HT_GF;
    }
  else if (dataTxVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_HT)
    {
      preamble = WIFI_PREAMBLE_HT_MF;
    }
  else if (m_stationManager->GetShortPreambleEnabled ())
    {
      preamble = WIFI_PREAMBLE_SHORT;
    }
  else
    {
      preamble = WIFI_PREAMBLE_LONG;
    }

  Time txDuration = m_phy->CalculateTxDuration (GetSize (m_currentPacket, &m_currentHdr), dataTxVector, preamble, m_phy->GetFrequency ());
  if (m_txParams.MustWaitNormalAck ())
    {
      Time timerDelay = txDuration + GetAckTimeout ();

{
  NS_LOG_FUNCTION (this);
  /* send this packet directly. No RTS is needed. */
  WifiPreamble preamble;
  if (m_currentTxVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_VHT)
    {
      preamble = WIFI_PREAMBLE_VHT;
    }
  else if (m_currentTxVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_HT && m_phy->GetGreenfield () && m_stationManager->GetGreenfieldSupported (m_currentHdr.GetAddr1 ()))
    {
      //In the future has to make sure that receiver has greenfield enabled
      preamble = WIFI_PREAMBLE_HT_GF;
    }
  else if (m_currentTxVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_HT)
    {
      preamble = WIFI_PREAMBLE_HT_MF;
    }
  else if (m_stationManager->GetShortPreambleEnabled ())
    {
      preamble = WIFI_PREAMBLE_SHORT;
    }
  else
    {
      preamble = WIFI_PREAMBLE_LONG;
    }

  StartDataTxTimers (m_currentTxVector);

  Time duration = Seconds (0.0);

        {
          duration += GetSifs ();
          duration += m_phy->CalculateTxDuration (m_txParams.GetNextPacketSize (),
                                                  m_currentTxVector, m_phy->GetFrequency ());
          if (m_txParams.MustWaitAck ())
            {
              duration += GetSifs ();

      m_currentPacket->AddTrailer (fcs);
    }

  ForwardDown (m_currentPacket, &m_currentHdr, m_currentTxVector);
  m_currentPacket = 0;
}


  cts.SetAddr1 (m_self);

  WifiTxVector ctsTxVector = GetRtsTxVector (m_currentPacket, &m_currentHdr);

  WifiPreamble preamble;
  if (ctsTxVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_HT)
    {
      preamble = WIFI_PREAMBLE_HT_MF;
    }
  else if (m_stationManager->GetShortPreambleEnabled ())
    {
      preamble = WIFI_PREAMBLE_SHORT;
    }
  else
    {
      preamble = WIFI_PREAMBLE_LONG;
    }

  Time duration = Seconds (0);

  if (m_txParams.HasDurationId ())

    {
      duration += GetSifs ();
      duration += m_phy->CalculateTxDuration (GetSize (m_currentPacket,&m_currentHdr),
                                              m_currentTxVector, m_phy->GetFrequency ());
      if (m_txParams.MustWaitBasicBlockAck ())
        {


        {
          duration += GetSifs ();
          duration += m_phy->CalculateTxDuration (m_txParams.GetNextPacketSize (),
                                                  m_currentTxVector, m_phy->GetFrequency ());
          if (m_txParams.MustWaitCompressedBlockAck ())
            {
              duration += GetSifs ();

  WifiMacTrailer fcs;
  packet->AddTrailer (fcs);

  ForwardDown (packet, &cts, ctsTxVector);

  Time txDuration = m_phy->CalculateTxDuration (GetCtsSize (), ctsTxVector, m_phy->GetFrequency ());
  txDuration += GetSifs ();
  NS_ASSERT (m_sendDataEvent.IsExpired ());


  SnrTag tag;
  tag.Set (rtsSnr);
  packet->AddPacketTag (tag);
  
  WifiPreamble preamble;
  if (m_stationManager->GetShortPreambleEnabled ())
    {
      preamble = WIFI_PREAMBLE_SHORT;
    }
  else
    {
      preamble = WIFI_PREAMBLE_LONG;
    }

  //CTS should always use non-HT PPDU (HT PPDU cases not supported yet)
  ForwardDown (packet, &cts, ctsTxVector);
}

void

      m_txPackets.clear ();
    }

  WifiPreamble preamble;
  if (m_currentTxVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_VHT)
    {
      preamble = WIFI_PREAMBLE_VHT;
    }
  else if (m_currentTxVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_HT && m_phy->GetGreenfield () && m_stationManager->GetGreenfieldSupported (m_currentHdr.GetAddr1 ()))
    {
      //In the future has to make sure that receiver has greenfield enabled
      preamble = WIFI_PREAMBLE_HT_GF;
    }
  else if (m_currentTxVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_HT)
    {
      preamble = WIFI_PREAMBLE_HT_MF;
    }
  else if (m_stationManager->GetShortPreambleEnabled ())
    {
      preamble = WIFI_PREAMBLE_SHORT;
    }
  else
    {
      preamble = WIFI_PREAMBLE_LONG;
    }

  StartDataTxTimers (m_currentTxVector);
  Time newDuration = Seconds (0);
  if (m_txParams.MustWaitBasicBlockAck ())

  if (m_txParams.HasNextPacket ())
    {
      newDuration += GetSifs ();
      newDuration += m_phy->CalculateTxDuration (m_txParams.GetNextPacketSize (), m_currentTxVector, m_phy->GetFrequency ());
      if (m_txParams.MustWaitCompressedBlockAck ())
        {
          newDuration += GetSifs ();

        }
    }

  Time txDuration = m_phy->CalculateTxDuration (GetSize (m_currentPacket, &m_currentHdr), m_currentTxVector, m_phy->GetFrequency ());
  duration -= txDuration;
  duration -= GetSifs ();


      m_currentPacket->AddTrailer (fcs);
    }

  ForwardDown (m_currentPacket, &m_currentHdr, m_currentTxVector);
  m_currentPacket = 0;
}


  SnrTag tag;
  tag.Set (dataSnr);
  packet->AddPacketTag (tag);
  
  WifiPreamble preamble;
  if (m_stationManager->GetShortPreambleEnabled ())
    {
      preamble = WIFI_PREAMBLE_SHORT;
    }
  else
    {
      preamble = WIFI_PREAMBLE_LONG;
    }

  //ACK should always use non-HT PPDU (HT PPDU cases not supported yet)
  ForwardDown (packet, &ack, ackTxVector);
}

bool

  packet->AddHeader (hdr);
  WifiMacTrailer fcs;
  packet->AddTrailer (fcs);
  WifiPreamble preamble;
  if (blockAckReqTxVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_HT)
    {
      preamble = WIFI_PREAMBLE_HT_MF;
    }
  else if (m_stationManager->GetShortPreambleEnabled ())
    {
      preamble = WIFI_PREAMBLE_SHORT;
    }
  else
    {
      preamble = WIFI_PREAMBLE_LONG;
    }
  SnrTag tag;
  tag.Set (rxSnr);
  packet->AddPacketTag (tag);
  ForwardDown (packet, &hdr, blockAckReqTxVector);
  m_currentPacket = 0;
}


}

void
MacLow::RegisterBlockAckListenerForAc (AcIndex ac, MacLowAggregationCapableTransmissionListener *listener)
{
  m_edcaListeners.insert (std::make_pair (ac, listener));
}

void
MacLow::DeaggregateAmpduAndReceive (Ptr<Packet> aggregatedPacket, double rxSnr, WifiTxVector txVector)
{
  NS_LOG_FUNCTION (this);
  AmpduTag ampdu;

      WifiMacHeader firsthdr;
      (*n).first->PeekHeader (firsthdr);
      NS_LOG_DEBUG ("duration/id=" << firsthdr.GetDuration ());
      WifiPreamble preamble = txVector.GetPreambleType ();
      NotifyNav ((*n).first, firsthdr, preamble);

      if (firsthdr.GetAddr1 () == m_self)


          if (firsthdr.IsAck () || firsthdr.IsBlockAck () || firsthdr.IsBlockAckReq ())
            {
              ReceiveOk ((*n).first, rxSnr, txVector, ampduSubframe);
            }
          else if (firsthdr.IsData () || firsthdr.IsQosData ())
            {
              NS_LOG_DEBUG ("Deaggregate packet from " << firsthdr.GetAddr2 () << " with sequence=" << firsthdr.GetSequenceNumber ());
              ReceiveOk ((*n).first, rxSnr, txVector, ampduSubframe);
              if (firsthdr.IsQosAck ())
                {
                  NS_LOG_DEBUG ("Normal Ack");

    }
  else
    {
      ReceiveOk (aggregatedPacket, rxSnr, txVector, ampduSubframe);
    }
}


      return true;
    }

  WifiPreamble preamble;
  Time aPPDUMaxTime = MilliSeconds (10);

  uint8_t tid = GetTid (peekedPacket, peekedHdr);
  AcIndex ac = QosUtilsMapTidToAc (tid);
  std::map<AcIndex, MacLowAggregationCapableTransmissionListener*>::const_iterator listenerIt = m_edcaListeners.find (ac);

  if (m_currentTxVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_VHT)
    {
      preamble = WIFI_PREAMBLE_VHT;
      aPPDUMaxTime = MicroSeconds (5484);
    }
  else if (m_currentTxVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_HT && m_phy->GetGreenfield () && m_stationManager->GetGreenfieldSupported (m_currentHdr.GetAddr1 ()))
    {
      preamble = WIFI_PREAMBLE_HT_GF;
    }
  else if (m_currentTxVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_HT)
    {
      preamble = WIFI_PREAMBLE_HT_MF;
    }
  else if (m_stationManager->GetShortPreambleEnabled ())
    {
      preamble = WIFI_PREAMBLE_SHORT;
    }
  else
    {
      preamble = WIFI_PREAMBLE_LONG;
    }

  //A STA shall not transmit a PPDU that has a duration that is greater than aPPDUMaxTime
  if (m_phy->CalculateTxDuration (aggregatedPacket->GetSize () + peekedPacket->GetSize () + peekedHdr.GetSize () + WIFI_MAC_FCS_LENGTH, m_currentTxVector, m_phy->GetFrequency ()) > aPPDUMaxTime)
    {
      NS_LOG_DEBUG ("no more packets can be aggregated to satisfy PPDU <= aPPDUMaxTime");
      return true;




#include "wifi-mac-header.h"
#include "wifi-mode.h"
#include "wifi-phy.h"
#include "wifi-preamble.h"
#include "wifi-remote-station-manager.h"
#include "ctrl-headers.h"
#include "mgt-headers.h"

   * \param packet packet received
   * \param rxSnr snr of packet received
   * \param txVector TXVECTOR of packet received
   * \param preamble type of preamble used for the packet received
   * \param ampduSubframe true if this MPDU is part of an A-MPDU
   *
   * This method is typically invoked by the lower PHY layer to notify
   * the MAC layer that a packet was successfully received.
   */
  void ReceiveOk (Ptr<Packet> packet, double rxSnr, WifiTxVector txVector, bool ampduSubframe);
  /**
   * \param packet packet received.
   * \param rxSnr snr of packet received.

   * The lifetime of the registered listener is typically equal to the lifetime of the queue
   * associated to this AC.
   */
  void RegisterBlockAckListenerForAc (AcIndex ac, MacLowAggregationCapableTransmissionListener *listener);
  /**
   * \param packet the packet to be aggregated. If the aggregation is succesfull, it corresponds either to the first data packet that will be aggregated or to the BAR that will be piggybacked at the end of the A-MPDU.
   * \param hdr the WifiMacHeader for the packet.

   * \param aggregatedPacket which is the current A-MPDU
   * \param rxSnr snr of packet received
   * \param txVector TXVECTOR of packet received
   * \param preamble type of preamble used for the packet received
   *
   * This function de-aggregates an A-MPDU and decide if each MPDU is received correctly or not
   *
   */
  void DeaggregateAmpduAndReceive (Ptr<Packet> aggregatedPacket, double rxSnr, WifiTxVector txVector);
  /**
   * \param peekedPacket the packet to be aggregated
   * \param peekedHdr the WifiMacHeader for the packet.

   * \param type the Block ACK type
   * \return the total Block ACK size
   */
  uint32_t GetBlockAckSize (BlockAckType type) const;
  /**
   * Return the total RTS size (including FCS trailer).
   *

   * \param packet
   * \param hdr
   * \param txVector
   * \param preamble
   */
  void ForwardDown (Ptr<const Packet> packet, const WifiMacHeader *hdr, WifiTxVector txVector);
                    WifiTxVector txVector, WifiPreamble preamble);
  /**
   * Forward the MPDU down to WifiPhy for transmission. This is called for each MPDU when MPDU aggregation is used.
   *
   * \param packet
   * \param hdr
   * \param txVector
   * \param preamble
   * \param mpdutype
   */
  void SendMpdu (Ptr<const Packet> packet, WifiTxVector txVector, MpduType mpdutype);
  /**
   * Return a TXVECTOR for the RTS frame given the destination.
   * The function consults WifiRemoteStationManager, which controls the rate

   * \param type the Block ACK type
   * \return the time required to transmit the Block ACK (including preamble and FCS)
   */
  Time GetBlockAckDuration (Mac48Address to, WifiTxVector blockAckReqTxVector, BlockAckType type) const;
  /**
   * Check if the current packet should be sent with a RTS protection.
   *




   */
  typedef union
  {
    MeshActionValue meshAction;
    MultihopActionValue multihopAction;
    SelfProtectedActionValue selfProtectedAction;
    BlockAckActionValue blockAck;
  } ActionValue;
  /**
   * Set action for this Action header.

   * \param type category
   * \param action action
   */
  void   SetAction (CategoryValue type, ActionValue action);

  /**
   * Return the category value.




      std::vector<std::vector<uint32_t> > ().swap (m_sampleTable);
      for (uint8_t j = 0; j < m_groupsTable.size (); j++)
        {
          std::vector<HtRateInfo> ().swap (m_groupsTable[j].m_ratesTable);
        }
      std::vector<GroupInfo> ().swap (m_groupsTable);
      m_statsFile.close ();
    }
}

  txvector.SetNess (0);
  txvector.SetStbc (phy->GetStbc ());
  txvector.SetMode (mode);
  txvector.SetPreambleType (WIFI_PREAMBLE_HT_MF);
  return phy->CalculateTxDuration (m_frameLength, txvector, phy->GetFrequency (), MPDU_IN_AGGREGATE, 0);
}

Time

  txvector.SetNess (0);
  txvector.SetStbc (phy->GetStbc ());
  txvector.SetMode (mode);
  txvector.SetPreambleType (WIFI_PREAMBLE_NONE);
  return phy->CalculateTxDuration (m_frameLength, txvector, phy->GetFrequency (), MPDU_IN_AGGREGATE, 0);
}

Time

        {
          m_rateChange (dataRate, station->m_state->m_address);
        }
      WifiMode mode = GetMcsSupported (station, mcsIndex);
      return WifiTxVector (mode, GetDefaultTxPowerLevel (), GetLongRetryCount (station), GetPreambleForTransmission (mode, GetAddress (station)),
                           group.sgi, group.streams, GetNess (station), group.chWidth, GetAggregation (station) && !station->m_isSampling, GetStbc (station));
    }
}


      NS_ASSERT (rateFound);

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

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

Lines 67-73	Link Here

 * Data structure for a table of group definitions.

 * Data structure for a table of group definitions.

 * A vector of McsGroups.

 * A vector of McsGroups.

*/

*/

typedef std::vector<struct McsGroup> MinstrelMcsGroups;

typedef std::vector<McsGroup> MinstrelMcsGroups;

struct MinstrelHtWifiRemoteStation;

struct MinstrelHtWifiRemoteStation;

/**

/**

Lines 114-120	Link Here

114

 * Data structure for a Minstrel Rate table.

114

 * Data structure for a Minstrel Rate table.

115

 * A vector of a struct HtRateInfo.

115

 * A vector of a struct HtRateInfo.

116

*/

116

*/

117

typedef std::vector<struct HtRateInfo> HtMinstrelRate;

117

typedef std::vector<HtRateInfo> HtMinstrelRate;

118

119

/**

119

/**

120

 * A struct to contain information of a group.

120

 * A struct to contain information of a group.




      WifiMode mode = phy->GetMode (i);
      WifiTxVector txVector;
      txVector.SetMode (mode);
      txVector.SetPreambleType (WIFI_PREAMBLE_LONG);
      AddCalcTxTime (mode, phy->CalculateTxDuration (m_pktLen, txVector, phy->GetFrequency ()));
    }
  WifiRemoteStationManager::SetupPhy (phy);
}

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

WifiTxVector

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


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

Lines 66-72	Link Here

 * Data structure for a Minstrel Rate table

 * Data structure for a Minstrel Rate table

 * A vector of a struct RateInfo

 * A vector of a struct RateInfo

*/

*/

typedef std::vector<struct RateInfo> MinstrelRate;

typedef std::vector<RateInfo> MinstrelRate;

/**

/**

 * Data structure for a Sample Rate table

 * Data structure for a Sample Rate table

 * A vector of a vector uint32_t

 * A vector of a vector uint32_t




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

WifiTxVector

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


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

Lines 44-50	Link Here

void

void

OriginatorBlockAckAgreement::SetState (enum State state)

OriginatorBlockAckAgreement::SetState (State state)

  m_state = state;

  m_state = state;

  if (state == INACTIVE)

  if (state == INACTIVE)

(-)a/src/wifi/model/originator-block-ack-agreement.h (-2 / +2 lines)

Lines 95-101	Link Here

    INACTIVE,

    INACTIVE,

    UNSUCCESSFUL

    UNSUCCESSFUL

};

};

  void SetState (enum State state);

  void SetState (State state);

/**

/**

100

   * Check if the current state of this agreement is PENDING.

100

   * Check if the current state of this agreement is PENDING.

101

Lines 142-148	Link Here

142

143

144

private:

144

private:

145

  enum State m_state;

145

  State m_state;

146

  uint16_t m_sentMpdus;

146

  uint16_t m_sentMpdus;

147

  bool m_needBlockAckReq;

147

  bool m_needBlockAckReq;

148

};

148

};




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

WifiTxVector

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


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

Lines 344-350	Link Here

344

345

346

void

346

void

347

RegularWifiMac::SetupEdcaQueue (enum AcIndex ac)

347

RegularWifiMac::SetupEdcaQueue (AcIndex ac)

348

349

  NS_LOG_FUNCTION (this << ac);

349

  NS_LOG_FUNCTION (this << ac);

350

Lines 1099-1105	Link Here

1099

1100

1101

void

1101

void

1102

RegularWifiMac::FinishConfigureStandard (enum WifiPhyStandard standard)

1102

RegularWifiMac::FinishConfigureStandard (WifiPhyStandard standard)

1103

1104

  NS_LOG_FUNCTION (this << standard);

1104

  NS_LOG_FUNCTION (this << standard);

1105

  uint32_t cwmin = 0;

1105

  uint32_t cwmin = 0;

(-)a/src/wifi/model/regular-wifi-mac.h (-2 / +2 lines)

Lines 339-345	Link Here

339

   * deal with certain values in the WifiPhyStandard enumeration, and

339

   * deal with certain values in the WifiPhyStandard enumeration, and

340

   * chain up to this implementation to deal with the remainder.

340

   * chain up to this implementation to deal with the remainder.

341

*/

341

*/

342

  virtual void FinishConfigureStandard (enum WifiPhyStandard standard);

342

  virtual void FinishConfigureStandard (WifiPhyStandard standard);

343

344

/**

344

/**

345

   * \param cwMin the minimum congestion window size

345

   * \param cwMin the minimum congestion window size

Lines 539-545	Link Here

539

540

   * \param ac the Access Category index of the queue to initialise.

540

   * \param ac the Access Category index of the queue to initialise.

541

*/

541

*/

542

  void SetupEdcaQueue (enum AcIndex ac);

542

  void SetupEdcaQueue (AcIndex ac);

543

544

  void SetVoMaxAmsduSize (uint32_t size);

544

  void SetVoMaxAmsduSize (uint32_t size);

545

  void SetViMaxAmsduSize (uint32_t size);

545

  void SetViMaxAmsduSize (uint32_t size);




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

WifiTxVector

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


    }
}

RraaWifiManager::ThresholdsItem
RraaWifiManager::GetThresholds (RraaWifiRemoteStation *station,
                                uint32_t rate) const
{

  return GetThresholds (mode, station);
}

RraaWifiManager::ThresholdsItem
RraaWifiManager::GetThresholds (WifiMode mode, RraaWifiRemoteStation *station) const
{
  uint8_t nss = 1;  // This RAA only supports 1 spatial stream

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

Lines 131-137	Link Here

131

132

   * \return threshold

132

   * \return threshold

133

*/

133

*/

134

  struct ThresholdsItem GetThresholds (WifiMode mode, RraaWifiRemoteStation *station) const;

134

  ThresholdsItem GetThresholds (WifiMode mode, RraaWifiRemoteStation *station) const;

135

/**

135

/**

136

   * Get a threshold for the given station and mode index.

136

   * Get a threshold for the given station and mode index.

137

Lines 140-146	Link Here

140

141

   * \return threshold

141

   * \return threshold

142

*/

142

*/

143

  struct ThresholdsItem GetThresholds (RraaWifiRemoteStation *station, uint32_t rate) const;

143

  ThresholdsItem GetThresholds (RraaWifiRemoteStation *station, uint32_t rate) const;

144

145

  bool m_basic;

145

  bool m_basic;

146

  Time m_timeout;

146

  Time m_timeout;




      return;
    }

  WifiPreamble preamble = txVector.GetPreambleType ();
  MpduType mpdutype = tag.GetMpduType ();

  // At this point forward, processing parallels that of
  // YansWifiPhy::StartReceivePreambleAndHeader ()

  AmpduTag ampduTag;
  Time endRx = Simulator::Now () + rxDuration;
  Time preambleAndHeaderDuration = CalculatePlcpPreambleAndHeaderDuration (txVector);

  Ptr<InterferenceHelper::Event> event;
  event = m_interference.Add (packet->GetSize (),
                              txVector,
                              preamble,
                              rxDuration,
                              rxPowerW);


            {
              NS_ASSERT (m_endPlcpRxEvent.IsExpired ());
              m_endPlcpRxEvent = Simulator::Schedule (preambleAndHeaderDuration, &SpectrumWifiPhy::StartReceivePacket, this,
                                                      packet, txVector, mpdutype, event);
            }

          NS_ASSERT (m_endRxEvent.IsExpired ());

void
SpectrumWifiPhy::StartReceivePacket (Ptr<Packet> packet,
                                     WifiTxVector txVector,
                                     MpduType mpdutype,
                                     enum mpduType mpdutype,
                                     Ptr<InterferenceHelper::Event> event)
{
  NS_LOG_FUNCTION (this << packet << txVector.GetMode () << txVector.GetPreambleType () << (uint32_t)mpdutype);
  NS_ASSERT (IsStateRx ());
  NS_ASSERT (m_endPlcpRxEvent.IsExpired ());
  AmpduTag ampduTag;
  WifiMode txMode = txVector.GetMode ();

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

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

  m_wifiSpectrumPhyInterface->SetDevice (device);
}

void
SpectrumWifiPhy::SendPacket (Ptr<const Packet> packet, WifiTxVector txVector, WifiPreamble preamble)
{
  SendPacket (packet, txVector, preamble, NORMAL_MPDU);
}

Ptr<SpectrumValue>
SpectrumWifiPhy::GetTxPowerSpectralDensity (uint32_t centerFrequency, uint32_t channelWidth, double txPowerW) const
{

}

void
SpectrumWifiPhy::SendPacket (Ptr<const Packet> packet, WifiTxVector txVector, MpduType mpdutype)
{
  NS_LOG_FUNCTION (this << packet << txVector.GetMode ()
                        << txVector.GetMode ().GetDataRate (txVector)
                        << txVector.GetPreambleType ()
                        << (uint32_t)txVector.GetTxPowerLevel ()
                        << (uint32_t)mpdutype);
  /* Transmission can happen if:
   *  - we are syncing on a packet. It is the responsability of the
   *    MAC layer to avoid doing this but the PHY does nothing to

      return;
    }

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

  if (m_state->IsStateRx ())

      m_interference.NotifyRxEnd ();
    }
  NotifyTxBegin (packet);
  if ((mpdutype == MPDU_IN_AGGREGATE) && (txVector.GetPreambleType () != WIFI_PREAMBLE_NONE))
  if (txVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_HT || txVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_VHT)
    {
      dataRate500KbpsUnits = 128 + txVector.GetMode ().GetMcsValue ();
    }
  else
    {
      dataRate500KbpsUnits = txVector.GetMode ().GetDataRate (txVector.GetChannelWidth (), txVector.IsShortGuardInterval (), 1) * txVector.GetNss () / 500000;
    }
  if (mpdutype == MPDU_IN_AGGREGATE && preamble != WIFI_PREAMBLE_NONE)
    {
      //send the first MPDU in an MPDU
      m_txMpduReferenceNumber++;
    }
  MpduInfo aMpdu;
  aMpdu.type = mpdutype;
  aMpdu.mpduRefNumber = m_txMpduReferenceNumber;
  NotifyMonitorSniffTx (packet, (uint16_t) GetFrequency (), GetChannelNumber (), txVector, aMpdu);
  m_state->SwitchToTx (txDuration, packet, GetPowerDbm (txVector.GetTxPowerLevel ()), txVector);
  //
  // Spectrum elements added here
  //
  Ptr<Packet> newPacket = packet->Copy (); // obtain non-const Packet
  WifiPhyTag oldtag;
  newPacket->RemovePacketTag (oldtag);
  WifiPhyTag tag (txVector, mpdutype);
  newPacket->AddPacketTag (tag);

  NS_LOG_DEBUG ("Transmission signal power before antenna gain: " << GetPowerDbm (txVector.GetTxPowerLevel ()) << " dBm");

}

void
SpectrumWifiPhy::EndReceive (Ptr<Packet> packet, WifiPreamble preamble, MpduType mpdutype, Ptr<InterferenceHelper::Event> event)
{
  NS_LOG_FUNCTION (this << packet << event);
  NS_ASSERT (IsStateRx ());
  NS_ASSERT (event->GetEndTime () == Simulator::Now ());

  InterferenceHelper::SnrPer snrPer;
  snrPer = m_interference.CalculatePlcpPayloadSnrPer (event);
  m_interference.NotifyRxEnd ();
  bool rxSucceeded;

      if (m_random->GetValue () > snrPer.per)
        {
          NotifyRxEnd (packet);
          SignalNoiseDbm signalNoise;
          if ((event->GetPayloadMode ().GetModulationClass () == WIFI_MOD_CLASS_HT) || (event->GetPayloadMode ().GetModulationClass () == WIFI_MOD_CLASS_VHT))
            {
              dataRate500KbpsUnits = 128 + event->GetPayloadMode ().GetMcsValue ();
            }
          else
            {
              dataRate500KbpsUnits = event->GetPayloadMode ().GetDataRate (event->GetTxVector ().GetChannelWidth (), event->GetTxVector ().IsShortGuardInterval (), 1) * event->GetTxVector ().GetNss () / 500000;
            }
          struct signalNoiseDbm signalNoise;
          signalNoise.signal = RatioToDb (event->GetRxPowerW ()) + 30;
          signalNoise.noise = RatioToDb (event->GetRxPowerW () / snrPer.snr) - GetRxNoiseFigure () + 30;
          MpduInfo aMpdu;
          aMpdu.type = mpdutype;
          aMpdu.mpduRefNumber = m_rxMpduReferenceNumber;
          NotifyMonitorSniffRx (packet, (uint16_t) GetFrequency (), GetChannelNumber (), event->GetTxVector (), aMpdu, signalNoise);
          m_state->SwitchFromRxEndOk (packet, snrPer.snr, event->GetTxVector ());
          rxSucceeded = true;
        }
      else




   *
   * \param packet the arriving packet
   * \param txVector the TXVECTOR of the arriving packet
   * \param mpdutype the type of the MPDU as defined in WifiPhy::MpduType.
   * \param mpdutype the type of the MPDU as defined in WifiPhy::mpduType.
   * \param event the corresponding event of the first time the packet arrives
   */
  void StartReceivePacket (Ptr<Packet> packet,
                           WifiTxVector txVector,
                           MpduType mpdutype,
                           enum mpduType mpdutype,
                           Ptr<InterferenceHelper::Event> event);

  /**


  virtual void SetReceiveOkCallback (WifiPhy::RxOkCallback callback);
  virtual void SetReceiveErrorCallback (WifiPhy::RxErrorCallback callback);
  virtual void SendPacket (Ptr<const Packet> packet, WifiTxVector txVector, MpduType mpdutype = NORMAL_MPDU);
  virtual void SendPacket (Ptr<const Packet> packet, WifiTxVector txVector, enum WifiPreamble preamble, enum mpduType mpdutype);
  virtual void RegisterListener (WifiPhyListener *listener);
  virtual void UnregisterListener (WifiPhyListener *listener);
  virtual void SetSleepMode (void);

   *
   * \param packet the packet that the last bit has arrived
   * \param preamble the preamble of the arriving packet
   * \param mpdutype the type of the MPDU as defined in WifiPhy::MpduType.
   * \param event the corresponding event of the first time the packet arrives
   */
  void EndReceive (Ptr<Packet> packet, WifiPreamble preamble, MpduType mpdutype, Ptr<InterferenceHelper::Event> event);

  /**
   * \param centerFrequency center frequency (MHz)

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

Lines 170-176	Link Here

170

171

   * \param value the new state

171

   * \param value the new state

172

*/

172

*/

173

  void SetState (enum MacState value);

173

  void SetState (MacState value);

174

/**

174

/**

175

   * Set the EDCA parameters.

175

   * Set the EDCA parameters.

176

Lines 188-194	Link Here

188

*/

188

*/

189

  CapabilityInformation GetCapabilities (void) const;

189

  CapabilityInformation GetCapabilities (void) const;

190

191

  enum MacState m_state;

191

  MacState m_state;

192

  Time m_probeRequestTimeout;

192

  Time m_probeRequestTimeout;

193

  Time m_assocRequestTimeout;

193

  Time m_assocRequestTimeout;

194

  EventId m_probeRequestEvent;

194

  EventId m_probeRequestEvent;




}

void
WifiMacHeader::SetType (WifiMacType type)
{
  switch (type)
    {

  m_qosEosp = 0;
}

void WifiMacHeader::SetQosAckPolicy (QosAckPolicy policy)
{
  switch (policy)
    {

  return m_addr4;
}

WifiMacType
WifiMacHeader::GetType (void) const
{
  switch (m_ctrlType)

    }
  // NOTREACHED
  NS_ASSERT (false);
  return (WifiMacType) - 1;
}

bool

  return m_qosTid;
}

WifiMacHeader::QosAckPolicy
WifiMacHeader::GetQosAckPolicy (void) const
{
  switch (m_qosAckPolicy)

    }
  // NOTREACHED
  NS_ASSERT (false);
  return (QosAckPolicy) - 1;
}

uint8_t




   *
   * \param type the WifiMacType for the header
   */
  void SetType (WifiMacType type);
  /**
   * Set the Duration/ID field with the given raw uint16_t value.
   *

   *
   * \param policy
   */
  void SetQosAckPolicy (QosAckPolicy policy);
  /**
   * Set the QoS ACK policy in the QoS control field to normal ACK.
   */

   *
   * \return the type (enum WifiMacType)
   */
  WifiMacType GetType (void) const;
  /**
   * \return true if From DS bit is set, false otherwise
   */

   *
   * \return the QoS ACK Policy of a QoS header
   */
  QosAckPolicy GetQosAckPolicy (void) const;
  /**
   * Return the TXOP limit.
   *

(-)a/src/wifi/model/wifi-mac-queue.cc (-1 / +1 lines)

Lines 247-253	Link Here

247

248

249

Mac48Address

249

Mac48Address

250

WifiMacQueue::GetAddressForPacket (enum WifiMacHeader::AddressType type, PacketQueueI it)

250

WifiMacQueue::GetAddressForPacket (WifiMacHeader::AddressType type, PacketQueueI it)

251

252

  if (type == WifiMacHeader::ADDR1)

252

  if (type == WifiMacHeader::ADDR1)

253




  /**
   * typedef for packet (struct Item) queue.
   */
  typedef std::list<Item> PacketQueue;
  /**
   * typedef for packet (struct Item) queue reverse iterator.
   */
  typedef std::list<Item>::reverse_iterator PacketQueueRI;
  /**
   * typedef for packet (struct Item) queue iterator.
   */
  typedef std::list<Item>::iterator PacketQueueI;
  /**
   * Return the appropriate address for the given packet (given by PacketQueue iterator).
   *

   *
   * \return the address
   */
  Mac48Address GetAddressForPacket (WifiMacHeader::AddressType type, PacketQueueI it);

  PacketQueue m_queue; //!< Packet (struct Item) queue
  uint32_t m_size;     //!< Current queue size
  uint32_t m_maxSize;  //!< Queue capacity
  Time m_maxDelay;     //!< Time to live for packets in the queue
  DropPolicy m_dropPolicy; //!< Drop behavior of queue
};

} //namespace ns3

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

Lines 287-293	Link Here

287

288

289

void

289

void

290

WifiMac::ConfigureStandard (enum WifiPhyStandard standard)

290

WifiMac::ConfigureStandard (WifiPhyStandard standard)

291

292

  switch (standard)

292

  switch (standard)

293

Lines 408-414	Link Here

408

409

410

void

410

void

411

WifiMac::ConfigureDcf (Ptr<Dcf> dcf, uint32_t cwmin, uint32_t cwmax, bool isDsss, enum AcIndex ac)

411

WifiMac::ConfigureDcf (Ptr<Dcf> dcf, uint32_t cwmin, uint32_t cwmax, bool isDsss, AcIndex ac)

412

413

  /* see IEE802.11 section 7.3.2.29 */

413

  /* see IEE802.11 section 7.3.2.29 */

414

  switch (ac)

414

  switch (ac)




   * \sa WifiMac::Configure80211n_5Ghz
   * \sa WifiMac::Configure80211ac
   */
  void ConfigureStandard (WifiPhyStandard standard);


protected:

   *
   * Configure the DCF with appropriate values depending on the given access category.
   */
  void ConfigureDcf (Ptr<Dcf> dcf, uint32_t cwmin, uint32_t cwmax, bool isDsss, AcIndex ac);


private:

   * implement this method to configure their dcf queues according to the
   * requested standard.
   */
  virtual void FinishConfigureStandard (WifiPhyStandard standard) = 0;

  Time m_maxPropagationDelay;





{
  //TODO: nss > 4 not supported yet
  NS_ASSERT (nss <= 4);
  WifiModeFactory::WifiModeItem *item = WifiModeFactory::GetFactory ()->Get (m_uid);
  uint64_t dataRate = 0;
  uint32_t usableSubCarriers = 0;
  double symbolRate = 0;

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

WifiCodeRate
WifiMode::GetCodeRate (void) const
{
  WifiModeFactory::WifiModeItem *item = WifiModeFactory::GetFactory ()->Get (m_uid);
  if (item->modClass == WIFI_MOD_CLASS_HT)
    {
      switch (item->mcsValue % 8)

uint16_t
WifiMode::GetConstellationSize (void) const
{
  WifiModeFactory::WifiModeItem *item = WifiModeFactory::GetFactory ()->Get (m_uid);
  if (item->modClass == WIFI_MOD_CLASS_HT)
    {
      switch (item->mcsValue % 8)

WifiMode::GetUniqueName (void) const
{
  //needed for ostream printing of the invalid mode
  WifiModeFactory::WifiModeItem *item = WifiModeFactory::GetFactory ()->Get (m_uid);
  return item->uniqueUid;
}

bool
WifiMode::IsMandatory (void) const
{
  WifiModeFactory::WifiModeItem *item = WifiModeFactory::GetFactory ()->Get (m_uid);
  return item->isMandatory;
}

uint8_t
WifiMode::GetMcsValue (void) const
{
  WifiModeFactory::WifiModeItem *item = WifiModeFactory::GetFactory ()->Get (m_uid);
  if (item->modClass == WIFI_MOD_CLASS_HT || item->modClass == WIFI_MOD_CLASS_VHT)
    {
      return item->mcsValue;

  return m_uid;
}

WifiModulationClass
WifiMode::GetModulationClass () const
{
  WifiModeFactory::WifiModeItem *item = WifiModeFactory::GetFactory ()->Get (m_uid);
  return item->modClass;
}


WifiMode::GetNonHtReferenceRate (void) const
{
  uint64_t dataRate;
  WifiModeFactory::WifiModeItem *item = WifiModeFactory::GetFactory ()->Get (m_uid);
  if (item->modClass == WIFI_MOD_CLASS_HT || item->modClass == WIFI_MOD_CLASS_VHT)
    {
      WifiCodeRate codeRate = GetCodeRate();

bool
WifiMode::IsHigherDataRate (WifiMode mode) const
{
  WifiModeFactory::WifiModeItem *item = WifiModeFactory::GetFactory ()->Get (m_uid);
  switch(item->modClass)
    {
    case WIFI_MOD_CLASS_DSSS:


WifiMode
WifiModeFactory::CreateWifiMode (std::string uniqueName,
                                 WifiModulationClass modClass,
                                 bool isMandatory,
                                 WifiCodeRate codingRate,
                                 uint16_t constellationSize)
{
  WifiModeFactory *factory = GetFactory ();

WifiMode
WifiModeFactory::CreateWifiMcs (std::string uniqueName,
                                uint8_t mcsValue,
                                WifiModulationClass modClass)
{
  WifiModeFactory *factory = GetFactory ();
  uint32_t uid = factory->AllocateUid (uniqueName);

  return uid;
}

WifiModeFactory::WifiModeItem *
WifiModeFactory::Get (uint32_t uid)
{
  NS_ASSERT (uid < m_itemList.size ());




  /**
   * \returns the coding rate of this transmission mode
   */
  WifiCodeRate GetCodeRate (void) const;
  /**
   * \returns the size of the modulation constellation.
   */

   * \returns the Modulation Class (Section 9.7.8 "Modulation classes"; IEEE 802.11-2012)
   * to which this WifiMode belongs.
   */
  WifiModulationClass GetModulationClass () const;
  /**
   * \returns the rate (in bps) of the non-HT Reference Rate
   * which corresponds to the HT MCS of this WifiMode.

   * Create a WifiMode (not used for HT or VHT).
   */
  static WifiMode CreateWifiMode (std::string uniqueName,
                                  WifiModulationClass modClass,
                                  bool isMandatory,
                                  WifiCodeRate codingRate,
                                  uint16_t constellationSize);

  /**

   */
  static WifiMode CreateWifiMcs (std::string uniqueName,
                                 uint8_t mcsValue,
                                 WifiModulationClass modClass);


private:

  struct WifiModeItem
  {
    std::string uniqueUid;
    WifiModulationClass modClass;
    uint16_t constellationSize;
    WifiCodeRate codingRate;
    bool isMandatory;
    uint8_t mcsValue;
  };

  /**
   * typedef for a vector of WifiModeItem.
   */
  typedef std::vector<WifiModeItem> WifiModeItemList;
  WifiModeItemList m_itemList;
};


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

Lines 358-364	Link Here

358

359

  NS_LOG_FUNCTION (this << packet << from << to);

359

  NS_LOG_FUNCTION (this << packet << from << to);

360

  LlcSnapHeader llc;

360

  LlcSnapHeader llc;

361

  enum NetDevice::PacketType type;

361

  NetDevice::PacketType type;

362

  if (to.IsBroadcast ())

362

  if (to.IsBroadcast ())

363

364

      type = NetDevice::PACKET_BROADCAST;

364

      type = NetDevice::PACKET_BROADCAST;




  return m_startRx;
}

WifiPhy::State
WifiPhyStateHelper::GetState (void)
{
  if (m_sleeping)


void
WifiPhyStateHelper::SwitchToTx (Time txDuration, Ptr<const Packet> packet, double txPowerDbm,
                                WifiTxVector txVector)
{
  m_txTrace (packet, txVector.GetMode (), txVector.GetPreambleType (), txVector.GetTxPowerLevel ());
  Time now = Simulator::Now ();
  switch (GetState ())
    {

}

void
WifiPhyStateHelper::SwitchFromRxEndOk (Ptr<Packet> packet, double snr, WifiTxVector txVector)
{
  m_rxOkTrace (packet, snr, txVector.GetMode (), txVector.GetPreambleType ());
  NotifyRxEndOk ();
  DoSwitchFromRx ();
  if (!m_rxOkCallback.IsNull ())
    {
      m_rxOkCallback (packet, snr, txVector);
    }

}




   *
   * \return the current state of WifiPhy
   */
  WifiPhy::State GetState (void);
  /**
   * Check whether the current state is CCA busy.
   *

   * \param packet the packet
   * \param txPowerDbm the nominal tx power in dBm
   * \param txVector the tx vector of the packet
   * \param preamble the preamble of the packet
   */
  void SwitchToTx (Time txDuration, Ptr<const Packet> packet, double txPowerDbm, WifiTxVector txVector);
  /**
   * Switch state to RX for the given duration.
   *

   * \param packet the successfully received packet
   * \param snr the SNR of the received packet
   * \param txVector TXVECTOR of the packet
   * \param preamble the preamble of the received packet
   */
  void SwitchFromRxEndOk (Ptr<Packet> packet, double snr, WifiTxVector txVector);
  /**
   * Switch from RX after the reception failed.
   *

  void SwitchFromSleep (Time duration);

  /** \todo Why is this public? */
  TracedCallback<Time, Time, WifiPhy::State> m_stateLogger;

  /**
   * TracedCallback signature for state changes.

  Time m_previousStateChangeTime;

  Listeners m_listeners;
  TracedCallback<Ptr<const Packet>, double, WifiMode, WifiPreamble> m_rxOkTrace;
  TracedCallback<Ptr<const Packet>, double> m_rxErrorTrace;
  TracedCallback<Ptr<const Packet>, WifiMode, WifiPreamble, uint8_t> m_txTrace;
  WifiPhy::RxOkCallback m_rxOkCallback;
  WifiPhy::RxErrorCallback m_rxErrorCallback;
};




uint32_t
WifiPhyTag::GetSerializedSize (void) const
{
  return (sizeof (WifiTxVector) + 2);
}

void
WifiPhyTag::Serialize (TagBuffer i) const
{
  i.Write ((uint8_t *)&m_wifiTxVector, sizeof (WifiTxVector));
  i.WriteU8 (m_wifiTxVector.GetTxPowerLevel ());
  i.WriteU8 (m_wifiTxVector.GetRetries ());
  i.WriteU8 (m_wifiTxVector.IsShortGuardInterval ());
  i.WriteU8 (m_wifiTxVector.GetNss ());
  i.WriteU8 (m_wifiTxVector.GetNess ());
  i.WriteU8 (m_wifiTxVector.IsStbc ());
  i.WriteU32 (m_wifiPreamble);
  i.WriteU16 (m_mpduType);
}

void
WifiPhyTag::Deserialize (TagBuffer i)
{
  i.Read ((uint8_t *)&m_wifiTxVector, sizeof (WifiTxVector));
  m_mpduType = static_cast<MpduType> (i.ReadU16 ());
  m_wifiTxVector.SetRetries (i.ReadU8 ());
  m_wifiTxVector.SetShortGuardInterval (i.ReadU8 ());
  m_wifiTxVector.SetNss (i.ReadU8 ());
  m_wifiTxVector.SetNess (i.ReadU8 ());
  m_wifiTxVector.SetStbc (i.ReadU8 ());
  m_wifiPreamble = i.ReadU32 ();
  m_mpduType = static_cast<enum mpduType> (i.ReadU16 ());
}
void
WifiPhyTag::Print (std::ostream &os) const
{
  os << m_wifiTxVector << " " << m_mpduType;
}

WifiPhyTag::WifiPhyTag ()
{
}

WifiPhyTag::WifiPhyTag (WifiTxVector txVector, MpduType mpdutype)
  : m_wifiTxVector (txVector),
    m_wifiPreamble (preamble),
    m_mpduType (mpdutype)
{
}

  return m_wifiTxVector;
}

MpduType
WifiPhyTag::GetWifiPreamble (void) const
{
  return ((enum WifiPreamble) m_wifiPreamble);
}

enum mpduType
WifiPhyTag::GetMpduType (void) const
{
  return m_mpduType;





#include <ns3/tag.h>
#include <ns3/wifi-tx-vector.h>
#include <ns3/wifi-preamble.h>
#include <ns3/wifi-phy.h>

namespace ns3 {

  /**
   * Constructor
   * \param txVector the WifiTxVector
   * \param preamble the WifiPreamble
   * \param mpduType the mpduType
   */
  WifiPhyTag (WifiTxVector txVector, MpduType mpdutype);
  /**
   * Getter for WifiTxVector parameter
   * \return the WifiTxVector
   */
  WifiTxVector GetWifiTxVector (void) const;
  /**
   * Getter for WifiPreamble parameter
   * \return preamble the WifiPreamble
   */
  WifiPreamble GetWifiPreamble (void) const;
  /**
   * Getter for mpduType parameter
   * \return mpduType the mpduType
   */
  MpduType GetMpduType (void) const;

  // From class Tag
  virtual uint32_t GetSerializedSize (void) const;


private:
  WifiTxVector m_wifiTxVector;
  MpduType m_mpduType;
  enum mpduType m_mpduType;
};

} // namespace ns3




}

void
WifiPhy::ConfigureDefaultsForStandard (WifiPhyStandard standard)
{
  NS_LOG_FUNCTION (this << standard);
  switch (standard)

}

bool 
WifiPhy::DefineChannelNumber (uint16_t channelNumber, WifiPhyStandard standard, uint32_t frequency, uint32_t channelWidth)
{
  NS_LOG_FUNCTION (this << channelNumber << standard << frequency << channelWidth);
  ChannelNumberStandardPair p = std::make_pair (channelNumber, standard);

}

void
WifiPhy::ConfigureChannelForStandard (WifiPhyStandard standard)
{
  NS_LOG_FUNCTION (this << standard);
  // If the user has configured both Frequency and ChannelNumber, Frequency

}

void
WifiPhy::ConfigureStandard (WifiPhyStandard standard)
{
  NS_LOG_FUNCTION (this << standard);
  m_standard = standard;

    }
}

WifiPhyStandard
WifiPhy::GetStandard (void) const
{
  return m_standard;

}

WifiPhy::FrequencyWidthPair
WifiPhy::GetFrequencyWidthForChannelNumberStandard (uint16_t channelNumber, WifiPhyStandard standard) const
{
  ChannelNumberStandardPair p = std::make_pair (channelNumber, standard);
  FrequencyWidthPair f = m_channelToFrequencyWidth[p];

}

Time
WifiPhy::GetPlcpHtTrainingSymbolDuration (WifiTxVector txVector)
{
  uint8_t Ndltf, Neltf;
  //We suppose here that STBC = 0.

      Neltf = 4;
    }

  switch (txVector.GetPreambleType ())
    {
    case WIFI_PREAMBLE_HT_MF:
      return MicroSeconds (4 + (4 * Ndltf) + (4 * Neltf));

}

WifiMode
WifiPhy::GetPlcpHeaderMode (WifiTxVector txVector)
{
  switch (txVector.GetMode ().GetModulationClass ())
    {
    case WIFI_MOD_CLASS_OFDM:
    case WIFI_MOD_CLASS_HT:

      return WifiPhy::GetErpOfdmRate6Mbps ();
    case WIFI_MOD_CLASS_DSSS:
    case WIFI_MOD_CLASS_HR_DSSS:
      if (txVector.GetPreambleType () == WIFI_PREAMBLE_LONG || txVector.GetMode () == WifiPhy::GetDsssRate1Mbps ())
        {
          //(Section 16.2.3 "PLCP field definitions" and Section 17.2.2.2 "Long PPDU format"; IEEE Std 802.11-2012)
          return WifiPhy::GetDsssRate1Mbps ();

}

Time
WifiPhy::GetPlcpHeaderDuration (WifiTxVector txVector)
{
  WifiPreamble preamble = txVector.GetPreambleType ();
  if (preamble == WIFI_PREAMBLE_NONE)
    {
      return MicroSeconds (0);

}

Time
WifiPhy::GetPlcpPreambleDuration (WifiTxVector txVector)
{
  WifiPreamble preamble = txVector.GetPreambleType ();
  if (preamble == WIFI_PREAMBLE_NONE)
    {
      return MicroSeconds (0);

}

Time
WifiPhy::GetPayloadDuration (uint32_t size, WifiTxVector txVector, double frequency)
{
  return GetPayloadDuration (size, txVector, frequency, NORMAL_MPDU, 0);
}

Time
WifiPhy::GetPayloadDuration (uint32_t size, WifiTxVector txVector, double frequency, MpduType mpdutype, uint8_t incFlag)
{
  WifiMode payloadMode = txVector.GetMode ();
  WifiPreamble preamble = txVector.GetPreambleType ();
  NS_LOG_FUNCTION (size << payloadMode);

  switch (payloadMode.GetModulationClass ())

          }
        else
          {
            NS_FATAL_ERROR ("Wrong combination of preamble and packet type: preamble=" << preamble << ", packet type=" << mpdutype);
          }

        //Add signal extension for ERP PHY

}

Time
WifiPhy::CalculatePlcpPreambleAndHeaderDuration (WifiTxVector txVector)
{
  WifiPreamble preamble = txVector.GetPreambleType();
  Time duration = GetPlcpPreambleDuration (txVector)
    + GetPlcpHeaderDuration (txVector)
    + GetPlcpHtSigHeaderDuration (preamble)
    + GetPlcpVhtSigA1Duration (preamble)
    + GetPlcpVhtSigA2Duration (preamble)
    + GetPlcpHtTrainingSymbolDuration (txVector)
    + GetPlcpVhtSigBDuration (preamble);
  return duration;
}

Time
WifiPhy::CalculateTxDuration (uint32_t size, WifiTxVector txVector, double frequency, MpduType mpdutype, uint8_t incFlag)
{
  Time duration = CalculatePlcpPreambleAndHeaderDuration (txVector)
    + GetPayloadDuration (size, txVector, frequency, mpdutype, incFlag);
  return duration;
}

Time
WifiPhy::CalculateTxDuration (uint32_t size, WifiTxVector txVector, double frequency)
{
  return CalculateTxDuration (size, txVector, frequency, NORMAL_MPDU, 0);
}

void

}

void
WifiPhy::NotifyMonitorSniffRx (Ptr<const Packet> packet, uint16_t channelFreqMhz, uint16_t channelNumber, WifiTxVector txVector, MpduInfo aMpdu, SignalNoiseDbm signalNoise)
{
  m_phyMonitorSniffRxTrace (packet, channelFreqMhz, channelNumber, txVector, aMpdu, signalNoise);
}

void
WifiPhy::NotifyMonitorSniffTx (Ptr<const Packet> packet, uint16_t channelFreqMhz, uint16_t channelNumber, WifiTxVector txVector, MpduInfo aMpdu)
{
  m_phyMonitorSniffTxTrace (packet, channelFreqMhz, channelNumber, txVector, aMpdu);
}



  return 1;
}

std::ostream& operator<< (std::ostream& os, WifiPhy::State state)
{
  switch (state)
    {




/**
 * This enumeration defines the type of an MPDU.
 */
enum MpduType
{
  /** The MPDU is not part of an A-MPDU */
  NORMAL_MPDU = 0,

  LAST_MPDU_IN_AGGREGATE
};

struct SignalNoiseDbm
{
  double signal; //in dBm
  double noise; //in dBm
};

struct MpduInfo
{
  MpduType type;
  uint32_t mpduRefNumber;
};


   * arg3: TXVECTOR of packet
   * arg4: type of preamble used for packet.
   */
  typedef Callback<void, Ptr<Packet>, double, WifiTxVector> RxOkCallback;
  /**
   * arg1: packet received unsuccessfully
   * arg2: snr of packet

   * \param txVector the TXVECTOR that has tx parameters such as mode, the transmission mode to use to send
   *        this packet, and txPowerLevel, a power level to use to send this packet. The real transmission
   *        power is calculated as txPowerMin + txPowerLevel * (txPowerMax - txPowerMin) / nTxLevels
   * \param mpdutype the type of the MPDU as defined in WifiPhy::MpduType.
   */
  virtual void SendPacket (Ptr<const Packet> packet, WifiTxVector txVector, MpduType mpdutype = NORMAL_MPDU) = 0;
  /**
   * \param packet the packet to send
   * \param txVector the TXVECTOR that has tx parameters such as mode, the transmission mode to use to send
   *        this packet, and txPowerLevel, a power level to use to send this packet. The real transmission
   *        power is calculated as txPowerMin + txPowerLevel * (txPowerMax - txPowerMin) / nTxLevels
   * \param preamble the type of preamble to use to send this packet.
   * \param mpdutype the type of the MPDU as defined in WifiPhy::mpduType.
   */
  virtual void SendPacket (Ptr<const Packet> packet, WifiTxVector txVector, enum WifiPreamble preamble, enum mpduType mpdutype) = 0;

  /**
   * \param listener the new listener

  /**
   * \param size the number of bytes in the packet to send
   * \param txVector the TXVECTOR used for the transmission of this packet
   * \param preamble the type of preamble to use for this packet.
   * \param frequency the channel center frequency (MHz)
   *
   * \return the total amount of time this PHY will stay busy for the transmission of these bytes.
   */
  Time CalculateTxDuration (uint32_t size, WifiTxVector txVector, double frequency);
  /**
   * \param size the number of bytes in the packet to send
   * \param txVector the TXVECTOR used for the transmission of this packet
   * \param preamble the type of preamble to use for this packet.
   * \param frequency the channel center frequency (MHz)
   * \param mpdutype the type of the MPDU as defined in WifiPhy::MpduType.
   * \param incFlag this flag is used to indicate that the static variables need to be update or not. This function is called a couple of times for the same packet so static variables should not be increased each time.
   *
   * \return the total amount of time this PHY will stay busy for the transmission of these bytes.
   */
  Time CalculateTxDuration (uint32_t size, WifiTxVector txVector, double frequency, MpduType mpdutype, uint8_t incFlag);

  /**
   * \param txVector the transmission parameters used for this packet
   * \param preamble the type of preamble to use for this packet.
   *
   * \return the total amount of time this PHY will stay busy for the transmission of the PLCP preamble and PLCP header.
   */
  Time CalculatePlcpPreambleAndHeaderDuration (WifiTxVector txVector);

  /**
   * \param preamble the type of preamble
   * \param txVector the transmission parameters used for this packet
   *
   * \return the training symbol duration
   */
  static Time GetPlcpHtTrainingSymbolDuration (WifiTxVector txVector);
  /**
   * \param payloadMode the WifiMode use for the transmission of the payload
   *

   */
  static Time GetPlcpVhtSigBDuration (WifiPreamble preamble);
  /**
   * \param payloadMode the WifiMode use for the transmission of the payload
   * \param preamble the type of preamble
   * \param txVector the transmission parameters used for this packet
   *
   * \return the WifiMode used for the transmission of the PLCP header
   */
  static WifiMode GetPlcpHeaderMode (WifiTxVector txVector);
  /**
   * \param txVector the transmission parameters used for this packet
   * \param preamble the type of preamble
   *
   * \return the duration of the PLCP header
   */
  static Time GetPlcpHeaderDuration (WifiTxVector txVector);
  /**
   * \param txVector the transmission parameters used for this packet
   * \param preamble the type of preamble
   *
   * \return the duration of the PLCP preamble
   */
  static Time GetPlcpPreambleDuration (WifiTxVector txVector);
  /**
   * \param size the number of bytes in the packet to send
   * \param txVector the TXVECTOR used for the transmission of this packet
   * \param preamble the type of preamble to use for this packet
   * \param frequency the channel center frequency (MHz)
   *
   * \return the duration of the payload
   */
  Time GetPayloadDuration (uint32_t size, WifiTxVector txVector, double frequency);
  /**
   * \param size the number of bytes in the packet to send
   * \param txVector the TXVECTOR used for the transmission of this packet
   * \param preamble the type of preamble to use for this packet
   * \param frequency the channel center frequency (MHz)
   * \param mpdutype the type of the MPDU as defined in WifiPhy::MpduType.
   * \param incFlag this flag is used to indicate that the static variables need to be update or not. This function is called a couple of times for the same packet so static variables should not be increased each time
   *
   * \return the duration of the payload
   */
  Time GetPayloadDuration (uint32_t size, WifiTxVector txVector, double frequency, MpduType mpdutype, uint8_t incFlag);

  /**
   * The WifiPhy::GetNModes() and WifiPhy::GetMode() methods are used

   *
   * \param standard the Wi-Fi standard
   */
  virtual void ConfigureStandard (WifiPhyStandard standard);

  /**
   * Get the configured Wi-Fi standard
   *
   * \return the Wi-Fi standard that has been configured
   */
  virtual WifiPhyStandard GetStandard (void) const;

  /**
   * Add a channel definition to the WifiPhy.  The pair (channelNumber,

   *
   * \return true if the channel definition succeeded
   */
  bool DefineChannelNumber (uint16_t channelNumber, WifiPhyStandard standard, uint32_t frequency, uint32_t channelWidth);

  /**
   * A pair of a ChannelNumber and WifiPhyStandard
   */
  typedef std::pair<uint16_t, WifiPhyStandard> ChannelNumberStandardPair;
  /**
   * A pair of a center Frequency and a ChannelWidth
   */

   *        tuned on a given channel and still to be able to receive packets
   *        on a nearby channel.
   * \param channelNumber the channel on which the packet is received
   * \param rate the PHY data rate in units of 500kbps (i.e., the same
   *        units used both for the radiotap and for the prism header)
   * \param preamble the preamble of the packet
   * \param txVector the TXVECTOR that holds rx parameters
   * \param aMpdu the type of the packet (0 is not A-MPDU, 1 is a MPDU that is part of an A-MPDU and 2 is the last MPDU in an A-MPDU)
   *        and the A-MPDU reference number (must be a different value for each A-MPDU but the same for each subframe within one A-MPDU)
   * \param signalNoise signal power and noise power in dBm
   */
  void NotifyMonitorSniffRx (Ptr<const Packet> packet,
                             uint16_t channelFreqMhz,
                             uint16_t channelNumber,
                             WifiTxVector txVector,
                             MpduInfo aMpdu,
                             SignalNoiseDbm signalNoise);

  /**
   * TracedCallback signature for monitor mode receive events.

   *        tuned on a given channel and still to be able to receive packets
   *        on a nearby channel.
   * \param channelNumber the channel on which the packet is received
   * \param rate the PHY data rate in units of 500kbps (i.e., the same
   *        units used both for the radiotap and for the prism header)
   * \param preamble the preamble of the packet
   * \param txVector the TXVECTOR that holds rx parameters
   * \param aMpdu the type of the packet (0 is not A-MPDU, 1 is a MPDU that is part of an A-MPDU and 2 is the last MPDU in an A-MPDU)
   *        and the A-MPDU reference number (must be a different value for each A-MPDU but the same for each subframe within one A-MPDU)

   * \todo WifiTxVector should be passed by const reference because
   * of its size.
   */
  typedef void (* MonitorSnifferRxCallback)(Ptr<const Packet> packet,
                                            uint16_t channelFreqMhz,
                                            uint16_t channelNumber,
                                            WifiTxVector txVector,
                                            MpduInfo aMpdu,
                                            SignalNoiseDbm signalNoise);

  /**
   * Public method used to fire a MonitorSniffer trace for a wifi packet being transmitted.

   * \param channelFreqMhz the frequency in MHz at which the packet is
   *        transmitted.
   * \param channelNumber the channel on which the packet is transmitted
   * \param rate the PHY data rate in units of 500kbps (i.e., the same
   *        units used both for the radiotap and for the prism header)
   * \param preamble the preamble of the packet
   * \param txVector the TXVECTOR that holds tx parameters
   * \param aMpdu the type of the packet (0 is not A-MPDU, 1 is a MPDU that is part of an A-MPDU and 2 is the last MPDU in an A-MPDU)
   *        and the A-MPDU reference number (must be a different value for each A-MPDU but the same for each subframe within one A-MPDU)
   */
  void NotifyMonitorSniffTx (Ptr<const Packet> packet,
                             uint16_t channelFreqMhz,
                             uint16_t channelNumber,
                             WifiTxVector txVector,
                             MpduInfo aMpdu);

  /**
   * TracedCallback signature for monitor mode transmit events.

   * \param channelFreqMhz the frequency in MHz at which the packet is
   *        transmitted.
   * \param channelNumber the channel on which the packet is transmitted
   * \param rate the PHY data rate in units of 500kbps (i.e., the same
   *        units used both for the radiotap and for the prism header)
   * \param preamble the preamble of the packet
   * \param txVector the TXVECTOR that holds tx parameters
   * \param aMpdu the type of the packet (0 is not A-MPDU, 1 is a MPDU that is part of an A-MPDU and 2 is the last MPDU in an A-MPDU)
   *        and the A-MPDU reference number (must be a different value for each A-MPDU but the same for each subframe within one A-MPDU)
   * \todo WifiTxVector should be passed by const reference because
   * of its size.
   */
  typedef void (* MonitorSnifferTxCallback)(const Ptr<const Packet> packet,
                                            uint16_t channelFreqMhz,
                                            uint16_t channelNumber,
                                            WifiTxVector txVector,
                                            MpduInfo aMpdu);

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

   *
   * \param standard the Wi-Fi standard
   */
  virtual void ConfigureDefaultsForStandard (WifiPhyStandard standard);
  /**
   * Configure the PHY-level parameters for different Wi-Fi standard.
   * This method is called when the Frequency or ChannelNumber attributes

   *
   * \param standard the Wi-Fi standard
   */
  virtual void ConfigureChannelForStandard (WifiPhyStandard standard);

  /**
   * Look for channel number matching the frequency and width

   * \param standard The WifiPhyStandard to check
   * \return the FrequencyWidthPair found
   */
  FrequencyWidthPair GetFrequencyWidthForChannelNumberStandard (uint16_t channelNumber, WifiPhyStandard standard) const;

  /**
   * The trace source fired when a packet begins the transmission process on

   * \todo WifiTxVector and signalNoiseDbm should be be passed as
   * const  references because of their sizes.
   */
  TracedCallback<Ptr<const Packet>, uint16_t, uint16_t, WifiTxVector, MpduInfo, SignalNoiseDbm> m_phyMonitorSniffRxTrace;
                 WifiPreamble, WifiTxVector, struct mpduInfo, struct signalNoiseDbm> m_phyMonitorSniffRxTrace;

  /**
   * A trace source that emulates a wifi device in monitor mode

   * \todo WifiTxVector should be passed by const reference because
   * of its size.
   */
  TracedCallback<Ptr<const Packet>, uint16_t, uint16_t, WifiTxVector, MpduInfo> m_phyMonitorSniffTxTrace;
                 WifiPreamble, WifiTxVector, struct mpduInfo> m_phyMonitorSniffTxTrace;
    
  /**
   * This vector holds the set of transmission modes that this


  std::vector<uint32_t> m_bssMembershipSelectorSet;

  WifiPhyStandard m_standard;     //!< WifiPhyStandard
  bool m_isConstructed;                //!< true when ready to set frequency
  uint32_t m_channelCenterFrequency;   //!< Center frequency in MHz
  uint32_t m_initialFrequency;         //!< Store frequency until initialization

 * \param state       wifi state to stringify
 * \return output stream
 */
std::ostream& operator<< (std::ostream& os, WifiPhy::State state);

} //namespace ns3





    {
      WifiTxVector v;
      v.SetMode (GetNonUnicastMode ());
      v.SetPreambleType (GetPreambleForTransmission (GetNonUnicastMode (), address));
      v.SetTxPowerLevel (m_defaultTxPowerLevel);
      v.SetChannelWidth (m_wifiPhy->GetChannelWidth ());
      v.SetShortGuardInterval (m_wifiPhy->GetGuardInterval ());

WifiTxVector
WifiRemoteStationManager::DoGetCtsToSelfTxVector (void)
{
  WifiMode defaultMode = GetDefaultMode ();
  WifiPreamble defaultPreamble;
  if (defaultMode.GetModulationClass () == WIFI_MOD_CLASS_VHT)
    {
      defaultPreamble = WIFI_PREAMBLE_VHT;
    }
  else if (defaultMode.GetModulationClass () == WIFI_MOD_CLASS_HT)
    {
      defaultPreamble = WIFI_PREAMBLE_HT_MF;
    }
  else
    {
      defaultPreamble = WIFI_PREAMBLE_LONG;
    }

  return WifiTxVector (defaultMode,
                       GetDefaultTxPowerLevel (),
                       0,
                       defaultPreamble,
                       m_wifiPhy->GetChannelWidth (),
                       m_wifiPhy->GetGuardInterval (),
                       GetNumberOfTransmitAntennas (),

}

bool
WifiRemoteStationManager::IsAllowedControlAnswerModulationClass (WifiModulationClass modClassReq, WifiModulationClass modClassAnswer) const
{
  switch (modClassReq)
    {

WifiRemoteStationManager::GetCtsTxVector (Mac48Address address, WifiMode rtsMode)
{
  NS_ASSERT (!address.IsGroup ());
  WifiMode ctsMode = GetControlAnswerMode (address, rtsMode);
  WifiTxVector v;
  v.SetMode (ctsMode);
  v.SetPreambleType (GetPreambleForTransmission (ctsMode, address));
  v.SetTxPowerLevel (DoGetCtsTxPowerLevel (address, ctsMode));
  v.SetChannelWidth (DoGetCtsTxChannelWidth (address, ctsMode));
  v.SetShortGuardInterval (DoGetCtsTxGuardInterval (address, ctsMode));
  v.SetNss (DoGetCtsTxNss (address, ctsMode));
  v.SetNess (DoGetCtsTxNess (address, ctsMode));
  v.SetStbc (DoGetCtsTxStbc (address, ctsMode));
  return v;
}


WifiRemoteStationManager::GetAckTxVector (Mac48Address address, WifiMode dataMode)
{
  NS_ASSERT (!address.IsGroup ());
  WifiMode ackMode = GetControlAnswerMode (address, dataMode);
  WifiTxVector v;
  v.SetMode (ackMode);
  v.SetPreambleType (GetPreambleForTransmission (ackMode, address));
  v.SetTxPowerLevel (DoGetAckTxPowerLevel (address, ackMode));
  v.SetChannelWidth (DoGetAckTxChannelWidth (address, ackMode));
  v.SetShortGuardInterval (DoGetAckTxGuardInterval (address, ackMode));
  v.SetNss (DoGetAckTxNss (address, ackMode));
  v.SetNess (DoGetAckTxNess (address, ackMode));
  v.SetStbc (DoGetAckTxStbc (address, ackMode));
  return v;
}


WifiRemoteStationManager::GetBlockAckTxVector (Mac48Address address, WifiMode blockAckReqMode)
{
  NS_ASSERT (!address.IsGroup ());
  WifiMode blockAckMode = GetControlAnswerMode (address, blockAckReqMode);
  WifiTxVector v;
  v.SetMode (blockAckMode);
  v.SetPreambleType (GetPreambleForTransmission (blockAckMode, address));
  v.SetTxPowerLevel (DoGetBlockAckTxPowerLevel (address, blockAckMode));
  v.SetChannelWidth (DoGetBlockAckTxChannelWidth (address, blockAckMode));
  v.SetShortGuardInterval (DoGetBlockAckTxGuardInterval (address, blockAckMode));
  v.SetNss (DoGetBlockAckTxNss (address, blockAckMode));
  v.SetNess (DoGetBlockAckTxNess (address, blockAckMode));
  v.SetStbc (DoGetBlockAckTxStbc (address, blockAckMode));
  return v;
}


  return station->m_state->m_operationalRateSet[index];
}

Mac48Address
WifiRemoteStationManager::GetAddress (const WifiRemoteStation *station) const
{
  return station->m_state->m_address;
}

uint32_t
WifiRemoteStationManager::GetChannelWidth (const WifiRemoteStation *station) const
{

  return m_wifiPhy->GetNumberOfTransmitAntennas ();
}

WifiPreamble
WifiRemoteStationManager::GetPreambleForTransmission (WifiMode mode, Mac48Address dest)
{
  NS_LOG_FUNCTION (this << mode << dest);
  WifiPreamble preamble;
  if (mode.GetModulationClass () == WIFI_MOD_CLASS_VHT)
    {
      preamble = WIFI_PREAMBLE_VHT;
    }
  else if (mode.GetModulationClass () == WIFI_MOD_CLASS_HT && m_wifiPhy->GetGreenfield () && GetGreenfieldSupported (dest))
    {
      preamble = WIFI_PREAMBLE_HT_GF;
    }
  else if (mode.GetModulationClass () == WIFI_MOD_CLASS_HT)
    {
      preamble = WIFI_PREAMBLE_HT_MF;
    }
  else if (GetShortPreambleEnabled ())
    {
      preamble = WIFI_PREAMBLE_SHORT;
    }
  else
    {
      preamble = WIFI_PREAMBLE_LONG;
    }
  NS_LOG_FUNCTION ("selected preamble=" << preamble);
  return preamble;
}

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

WifiRemoteStationInfo::WifiRemoteStationInfo ()
  : m_memoryTime (Seconds (1.0)),
    m_lastUpdate (Seconds (0.0)),

  return m_failAvg;
}

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

} //namespace ns3




  typedef void (*RateChangeTracedCallback)(uint32_t rate, Mac48Address remoteAddress);



protected:
  virtual void DoDispose (void);
  /**

   */
  uint32_t GetNNonErpSupported (const WifiRemoteStation *station) const;
  /**
   * Return the address of the station.
   *
   * \param station the station being queried
   *
   * \return the address of the station
   */
  Mac48Address GetAddress (const WifiRemoteStation *station) const;
  /**
   * Return the channel width supported by the station.
   *
   * \param station the station being queried

   * \return the short retry limit of the the station
   */
  uint32_t GetShortRetryCount (const WifiRemoteStation *station) const;
  /**
   * Return the preamble to be used for the transmission.
   *
   * \param mode the mode selected for the transmission
   * \param dest address of the recipient
   *
   * \return the preamble to be used for the transmission
   */
  WifiPreamble GetPreambleForTransmission (WifiMode mode, Mac48Address dest);

  /**
   * Return the WifiPhy.

   * \return true if the modulation class of the selected mode for the 
   * control answer frame is allowed, false otherwise
   */
  bool IsAllowedControlAnswerModulationClass (WifiModulationClass modClassReq, WifiModulationClass modClassAnswer) const;

  WifiMode GetControlAnswerMode (Mac48Address address, WifiMode reqMode);






WifiTxVector::WifiTxVector ()
  : m_retries (0),
    m_preamble (WIFI_PREAMBLE_NONE),
    m_channelWidth (20),
    m_shortGuardInterval (false),
    m_nss (1),

{
}

WifiTxVector::WifiTxVector (WifiMode mode,
                            uint8_t powerLevel,
                            uint8_t retries,
                            WifiPreamble preamble,
                            bool shortGuardInterval,
                            uint8_t nss,
                            uint8_t ness,
                            uint32_t channelWidth,
                            bool aggregation,
                            bool stbc)
  : m_mode (mode),
    m_txPowerLevel (powerLevel),
    m_retries (retries),
    m_preamble (preamble),
    m_channelWidth (channelWidth),
    m_shortGuardInterval (shortGuardInterval),
    m_nss (nss),

  return m_retries;
}

WifiPreamble
WifiTxVector::GetPreambleType (void) const
{
  return m_preamble;
}

uint32_t
WifiTxVector::GetChannelWidth (void) const
{

}

void
WifiTxVector::SetPreambleType (WifiPreamble preamble)
{
  m_preamble = preamble;
}

void
WifiTxVector::SetChannelWidth (uint32_t channelWidth)
{
  m_channelWidth = channelWidth;

  os << "mode: " << v.GetMode () <<
    " txpwrlvl: " << (uint32_t)v.GetTxPowerLevel () <<
    " retries: " << (uint32_t)v.GetRetries () <<
    " preamble: " << v.GetPreambleType () <<
    " channel width: " << v.GetChannelWidth () <<
    " Short GI: " << v.IsShortGuardInterval () <<
    " Nss: " << (uint32_t)v.GetNss () <<




#define WIFI_TX_VECTOR_H

#include <ns3/wifi-mode.h>
#include <ns3/wifi-preamble.h>
#include <ostream>

namespace ns3 {

   * \param mode WifiMode
   * \param powerLevel transmission power level
   * \param retries retries
   * \param preamble preamble type   
   * \param shortGuardInterval enable or disable short guard interval
   * \param nss the number of spatial STBC streams (NSS)
   * \param ness the number of extension spatial streams (NESS)

  WifiTxVector (WifiMode mode,
                uint8_t powerLevel,
                uint8_t retries,
                WifiPreamble preamble,
                bool shortGuardInterval,
                uint8_t nss,
                uint8_t ness,

   */
  void SetRetries (uint8_t retries);
  /**
   * \returns the preamble type
   */
  WifiPreamble GetPreambleType (void) const;
  /**
   * Sets the preamble type
   *
   * \param preamble
   */
  void SetPreambleType (WifiPreamble preamble);
  /**
   * \returns the channel width (in MHz)
   */
  uint32_t GetChannelWidth (void) const;

                                 to PMD_TXPWRLVL.request */
  uint8_t  m_retries;            /**< The DATA_RETRIES/RTS_RETRIES parameter
                                 for Click radiotap information */
  WifiPreamble m_preamble;       /** preamble */
  uint32_t m_channelWidth;       /**< channel width in MHz */
  bool     m_shortGuardInterval; /**< true if short GI is going to be used */
  uint8_t  m_nss;                /**< number of streams */




      return;
    }

  WifiPreamble preamble = txVector.GetPreambleType ();
  MpduType mpdutype = tag.GetMpduType ();
  Time preambleAndHeaderDuration = CalculatePlcpPreambleAndHeaderDuration (txVector);

  Ptr<InterferenceHelper::Event> event;
  event = m_interference.Add (packet->GetSize (),
                              txVector,
                              preamble,
                              rxDuration,
                              rxPowerW);


            {
              NS_ASSERT (m_endPlcpRxEvent.IsExpired ());
              m_endPlcpRxEvent = Simulator::Schedule (preambleAndHeaderDuration, &YansWifiPhy::StartReceivePacket, this,
                                                      packet, txVector, mpdutype, event);
            }

          NS_ASSERT (m_endRxEvent.IsExpired ());

void
YansWifiPhy::StartReceivePacket (Ptr<Packet> packet,
                                 WifiTxVector txVector,
                                 MpduType mpdutype,
                                 enum mpduType mpdutype,
                                 Ptr<InterferenceHelper::Event> event)
{
  NS_LOG_FUNCTION (this << packet << txVector.GetMode () << txVector.GetPreambleType () << (uint32_t)mpdutype);
  NS_ASSERT (IsStateRx ());
  NS_ASSERT (m_endPlcpRxEvent.IsExpired ());
  WifiMode txMode = txVector.GetMode ();

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

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

}

void
YansWifiPhy::SendPacket (Ptr<const Packet> packet, WifiTxVector txVector, MpduType mpdutype)
{
  SendPacket (packet, txVector, preamble, NORMAL_MPDU);
}

void
YansWifiPhy::SendPacket (Ptr<const Packet> packet, WifiTxVector txVector, WifiPreamble preamble, enum mpduType mpdutype)
{
  NS_LOG_FUNCTION (this << packet << txVector.GetMode () 
    << txVector.GetMode ().GetDataRate (txVector) << txVector.GetPreambleType ()
    << (uint32_t)txVector.GetTxPowerLevel () << (uint32_t)mpdutype);
  /* Transmission can happen if:
   *  - we are syncing on a packet. It is the responsability of the
   *    MAC layer to avoid doing this but the PHY does nothing to

      return;
    }

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

  if (m_state->IsStateRx ())

      m_interference.NotifyRxEnd ();
    }
  NotifyTxBegin (packet);
  if ((mpdutype == MPDU_IN_AGGREGATE) && (txVector.GetPreambleType () != WIFI_PREAMBLE_NONE))
  if (txVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_HT || txVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_VHT)
    {
      dataRate500KbpsUnits = 128 + txVector.GetMode ().GetMcsValue ();
    }
  else
    {
      dataRate500KbpsUnits = txVector.GetMode ().GetDataRate (txVector.GetChannelWidth (), txVector.IsShortGuardInterval (), 1) * txVector.GetNss () / 500000;
    }
  if (mpdutype == MPDU_IN_AGGREGATE && preamble != WIFI_PREAMBLE_NONE)
    {
      //send the first MPDU in an MPDU
      m_txMpduReferenceNumber++;
    }
  MpduInfo aMpdu;
  aMpdu.type = mpdutype;
  aMpdu.mpduRefNumber = m_txMpduReferenceNumber;
  NotifyMonitorSniffTx (packet, (uint16_t)GetFrequency (), GetChannelNumber (), txVector, aMpdu);
  m_state->SwitchToTx (txDuration, packet, GetPowerDbm (txVector.GetTxPowerLevel ()), txVector);
  
  Ptr<Packet> newPacket = packet->Copy (); // obtain non-const Packet
  WifiPhyTag oldtag;
  newPacket->RemovePacketTag (oldtag);
  WifiPhyTag tag (txVector, mpdutype);
  newPacket->AddPacketTag (tag);
  m_channel->Send (this, newPacket, GetPowerDbm (txVector.GetTxPowerLevel ()) + GetTxGain (), txDuration);
}

}

void
YansWifiPhy::EndReceive (Ptr<Packet> packet, WifiPreamble preamble, MpduType mpdutype, Ptr<InterferenceHelper::Event> event)
{
  NS_LOG_FUNCTION (this << packet << event);
  NS_ASSERT (IsStateRx ());
  NS_ASSERT (event->GetEndTime () == Simulator::Now ());

  InterferenceHelper::SnrPer snrPer;
  snrPer = m_interference.CalculatePlcpPayloadSnrPer (event);
  m_interference.NotifyRxEnd ();


      if (m_random->GetValue () > snrPer.per)
        {
          NotifyRxEnd (packet);
          SignalNoiseDbm signalNoise;
          if ((event->GetPayloadMode ().GetModulationClass () == WIFI_MOD_CLASS_HT) || (event->GetPayloadMode ().GetModulationClass () == WIFI_MOD_CLASS_VHT))
            {
              dataRate500KbpsUnits = 128 + event->GetPayloadMode ().GetMcsValue ();
            }
          else
            {
              dataRate500KbpsUnits = event->GetPayloadMode ().GetDataRate (event->GetTxVector ().GetChannelWidth (), event->GetTxVector ().IsShortGuardInterval (), 1) * event->GetTxVector ().GetNss () / 500000;
            }
          struct signalNoiseDbm signalNoise;
          signalNoise.signal = RatioToDb (event->GetRxPowerW ()) + 30;
          signalNoise.noise = RatioToDb (event->GetRxPowerW () / snrPer.snr) - GetRxNoiseFigure () + 30;
          MpduInfo aMpdu;
          aMpdu.type = mpdutype;
          aMpdu.mpduRefNumber = m_rxMpduReferenceNumber;
          NotifyMonitorSniffRx (packet, (uint16_t)GetFrequency (), GetChannelNumber (), event->GetTxVector (), aMpdu, signalNoise);
          m_state->SwitchFromRxEndOk (packet, snrPer.snr, event->GetTxVector ());
        }
      else
        {




   *
   * \param packet the arriving packet
   * \param txVector the TXVECTOR of the arriving packet
   * \param mpdutype the type of the MPDU as defined in WifiPhy::MpduType.
   * \param mpdutype the type of the MPDU as defined in WifiPhy::mpduType.
   * \param event the corresponding event of the first time the packet arrives
   */
  void StartReceivePacket (Ptr<Packet> packet,
                           WifiTxVector txVector,
                           MpduType mpdutype,
                           enum mpduType mpdutype,
                           Ptr<InterferenceHelper::Event> event);

  virtual void SetReceiveOkCallback (WifiPhy::RxOkCallback callback);
  virtual void SetReceiveErrorCallback (WifiPhy::RxErrorCallback callback);
  virtual void SendPacket (Ptr<const Packet> packet, WifiTxVector txVector, MpduType mpdutype = NORMAL_MPDU);
  virtual void SendPacket (Ptr<const Packet> packet, WifiTxVector txVector, enum WifiPreamble preamble, enum mpduType mpdutype);
  virtual void RegisterListener (WifiPhyListener *listener);
  virtual void UnregisterListener (WifiPhyListener *listener);
  virtual void SetSleepMode (void);

   *
   * \param packet the packet that the last bit has arrived
   * \param preamble the preamble of the arriving packet
   * \param mpdutype the type of the MPDU as defined in WifiPhy::MpduType.
   * \param event the corresponding event of the first time the packet arrives
   */
  void EndReceive (Ptr<Packet> packet, WifiPreamble preamble, MpduType mpdutype, Ptr<InterferenceHelper::Event> event);

  Ptr<YansWifiChannel> m_channel; //!< YansWifiChannel that this YansWifiPhy is connected to
};

} //namespace ns3




Ptr<SpectrumSignalParameters> 
SpectrumWifiPhyBasicTest::MakeSignal (double txPowerWatts)
{
  WifiTxVector txVector = WifiTxVector (WifiPhy::GetOfdmRate6Mbps (), 0, 0, WIFI_PREAMBLE_LONG, false, 1, 0, 20000000, false, false);
  MpduType mpdutype = NORMAL_MPDU;
  WifiMode mode = WifiPhy::GetOfdmRate6Mbps ();
  WifiTxVector txVector = WifiTxVector (mode, 0, 0, false, 1, 0, 20000000, false, false);
  enum mpduType mpdutype = NORMAL_MPDU;

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

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

  pkt->AddHeader (hdr);
  pkt->AddTrailer (trailer);
  WifiPhyTag tag (txVector, mpdutype);
  pkt->AddPacketTag (tag);
  Ptr<SpectrumValue> txPowerSpectrum = WifiSpectrumValueHelper::CreateOfdmTxPowerSpectralDensity (FREQUENCY, CHANNEL_WIDTH, txPowerWatts);
  Ptr<WifiSpectrumSignalParameters> txParams = Create<WifiSpectrumSignalParameters> ();




{
  WifiTxVector txVector;
  txVector.SetMode (payloadMode);
  txVector.SetPreambleType (preamble);
  txVector.SetChannelWidth (channelWidth);
  txVector.SetShortGuardInterval (isShortGuardInterval);
  txVector.SetNss (1);

    {
      testedFrequency = CHANNEL_36_MHZ;
    }
  double calculatedDurationMicroSeconds = (double)phy->GetPayloadDuration (size, txVector, testedFrequency).GetMicroSeconds  ();
  if (calculatedDurationMicroSeconds != knownDurationMicroSeconds)
    {
      std::cerr << " size=" << size

    {
      //Durations vary depending on frequency; test also 2.4 GHz (bug 1971)
      testedFrequency = CHANNEL_1_MHZ;
      calculatedDurationMicroSeconds = (double)phy->GetPayloadDuration (size, txVector, testedFrequency).GetMicroSeconds ();
      if (calculatedDurationMicroSeconds != knownDurationMicroSeconds + 6)
        {
          std::cerr << " size=" << size

{
  WifiTxVector txVector;
  txVector.SetMode (payloadMode);
  txVector.SetPreambleType (preamble);
  txVector.SetChannelWidth (channelWidth);
  txVector.SetShortGuardInterval (isShortGuardInterval);
  txVector.SetNss (1);

    {
      testedFrequency = CHANNEL_36_MHZ;
    }
  double calculatedDurationMicroSeconds = ((double)phy->CalculateTxDuration (size, txVector, testedFrequency).GetNanoSeconds ()) / 1000;
  if (calculatedDurationMicroSeconds != knownDurationMicroSeconds)
    {
      std::cerr << " size=" << size

    {
      //Durations vary depending on frequency; test also 2.4 GHz (bug 1971)
      testedFrequency = CHANNEL_1_MHZ;
      calculatedDurationMicroSeconds = ((double)phy->CalculateTxDuration (size, txVector, testedFrequency).GetNanoSeconds ()) / 1000;
      if (calculatedDurationMicroSeconds != knownDurationMicroSeconds + 6)
        {
          std::cerr << " size=" << size

Return to bug 2551