Attachment #2033 for bug #2097

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





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

}

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

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

}

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

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

Lines 314-319	Link Here

314

315

      WifiMode mode = m_phy->GetMode (i);

315

      WifiMode mode = m_phy->GetMode (i);

316

      rates.AddSupportedRate (mode.GetDataRate ());

316

      rates.AddSupportedRate (mode.GetDataRate ());

317

      if(mode.IsBssBasic())

318

319

        m_stationManager->AddBasicMode (mode);

320

317

321

318

  // set the basic rates

322

  // set the basic rates

319

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

323

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

(-)a/src/wifi/model/constant-rate-wifi-manager.cc (-1 / +1 lines)

Lines 43-49	Link Here

                   StringValue ("OfdmRate6Mbps"),

                   StringValue ("OfdmRate6Mbps"),

                   MakeWifiModeAccessor (&ConstantRateWifiManager::m_dataMode),

                   MakeWifiModeAccessor (&ConstantRateWifiManager::m_dataMode),

                   MakeWifiModeChecker ())

                   MakeWifiModeChecker ())

    .AddAttribute ("ControlMode", "The transmission mode to use for every control packet transmission.",

    .AddAttribute ("ControlMode", "The transmission mode to use for every RTS packet transmission.",

                   StringValue ("OfdmRate6Mbps"),

                   StringValue ("OfdmRate6Mbps"),

                   MakeWifiModeAccessor (&ConstantRateWifiManager::m_ctlMode),

                   MakeWifiModeAccessor (&ConstantRateWifiManager::m_ctlMode),

                   MakeWifiModeChecker ())

                   MakeWifiModeChecker ())

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

Lines 28-34	Link Here

/**

/**

 * \ingroup wifi

 * \ingroup wifi

 * \brief use constant rates for data and control transmissions

 * \brief use constant rates for data and RTS transmissions

 * This class uses always the same transmission rate for every

 * This class uses always the same transmission rate for every

 * packet sent.

 * packet sent.

Lines 58-64	Link Here

  virtual bool IsLowLatency (void) const;

  virtual bool IsLowLatency (void) const;

  WifiMode m_dataMode; //!< Wifi mode for unicast DATA frames

  WifiMode m_dataMode; //!< Wifi mode for unicast DATA frames

  WifiMode m_ctlMode; //!< Wifi mode for request control frames

  WifiMode m_ctlMode; //!< Wifi mode for RTS frames

};

};

} // namespace ns3

} // namespace ns3




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

InterferenceHelper::Event::Event (uint32_t size, WifiTxVector txVector,
                                  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)
    m_txVector (txVector)
{
}
InterferenceHelper::Event::~Event ()

{
  return m_size;
}
WifiTxVector
InterferenceHelper::Event::GetTxVector (void) const
{
  return m_txVector;
}
WifiMode
InterferenceHelper::Event::GetPayloadMode (void) const
{
  return m_txVector.GetMode();
}
enum WifiPreamble
InterferenceHelper::Event::GetPreambleType (void) const

  return m_preamble;
}

WifiTxVector
InterferenceHelper::Event::GetTxVector (void) const
{
  return m_txVector;
}


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

}

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

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




     * Create an Event with the given parameters.
     *
     * \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)
     * \param txvector TXVECTOR of the packet
     */
    Event (uint32_t size, WifiTxVector txvector,
           enum WifiPreamble preamble,
           Time duration, double rxPower);
    ~Event ();

    /**

     */
    uint32_t GetSize (void) const;
    /**
     * Return the TXVECTOR of the packet.
     *
     * \return the TXVECTOR of the packet
     */
    WifiTxVector GetTxVector (void) const;
    /**
     * Return the Wi-Fi mode used for the payload.
     *
     * \return the Wi-Fi mode used for the payload

     * \return the preamble type of the packet
     */
    enum WifiPreamble GetPreambleType (void) const;

     * Return the TXVECTOR of the packet.
     *
     * \return the TXVECTOR of the packet
     */
    WifiTxVector GetTxVector (void) const;
private:
    uint32_t m_size;
    WifiTxVector m_txVector;
    enum WifiPreamble m_preamble;
    Time m_startTime;
    Time m_endTime;
    double m_rxPowerW;
    WifiTxVector m_txVector;
  };
  /**
   * A struct for both SNR and PER

   * Add the packet-related signal to interference helper.
   *
   * \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)
   * \param txvector TXVECTOR of the packet
   * \return InterferenceHelper::Event
   */
  Ptr<InterferenceHelper::Event> Add (uint32_t size, WifiTxVector txvector,
                                      enum WifiPreamble preamble,
                                      Time duration, double rxPower);

  /**
   * Calculate the SNIR at the start of the packet and accumulate




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

                                                hdr.GetQosTid(),
                                                hdr.GetAddr2 (),
                                                hdr.GetDuration (),
                                                m_currentTxVector);
        }
      else if (hdr.IsBlockAckReq())
        {

}

void
MacLow::ReceiveOk (Ptr<Packet> packet, double rxSnr, WifiTxVector txVector, WifiPreamble preamble, bool ampduSubframe)
{
  NS_LOG_FUNCTION (this << packet << rxSnr << txVector.GetMode  () << preamble);
  /* 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, preamble);
  if (hdr.IsRts ())
    {
      /* see section 9.2.5.7 802.11-1999

              NS_LOG_DEBUG ("rx RTS from=" << hdr.GetAddr2 () << ", schedule CTS");
              NS_ASSERT (m_sendCtsEvent.IsExpired ());
              m_stationManager->ReportRxOk (hdr.GetAddr2 (), &hdr,
                                            rxSnr, txVector.GetMode  ());
              m_sendCtsEvent = Simulator::Schedule (GetSifs (),
                                                    &MacLow::SendCtsAfterRts, this,
                                                    hdr.GetAddr2 (),
                                                    hdr.GetDuration (),
                                                    txVector,
                                                    rxSnr);
            }
          else

      SnrTag tag;
      packet->RemovePacketTag (tag);
      m_stationManager->ReportRxOk (m_currentHdr.GetAddr1 (), &m_currentHdr,
                                    rxSnr, txVector.GetMode  ());
      m_stationManager->ReportRtsOk (m_currentHdr.GetAddr1 (), &m_currentHdr,
                                     rxSnr, txVector.GetMode  (), tag.Get ());

      m_ctsTimeoutEvent.Cancel ();
      NotifyCtsTimeoutResetNow ();
      m_listener->GotCts (rxSnr, txVector.GetMode  ());
      NS_ASSERT (m_sendDataEvent.IsExpired ());
      m_sendDataEvent = Simulator::Schedule (GetSifs (),
                                             &MacLow::SendDataAfterCts, this,
                                             hdr.GetAddr1 (),
                                             hdr.GetDuration ());
                                             txMode);
    }
  else if (hdr.IsAck ()
           && hdr.GetAddr1 () == m_self

      SnrTag tag;
      packet->RemovePacketTag (tag);
      m_stationManager->ReportRxOk (m_currentHdr.GetAddr1 (), &m_currentHdr,
                                    rxSnr, txVector.GetMode  ());
      m_stationManager->ReportDataOk (m_currentHdr.GetAddr1 (), &m_currentHdr,
                                      rxSnr, txVector.GetMode  (), tag.Get ());
        
      bool gotAck = false;
      if (m_txParams.MustWaitNormalAck ()

        }
      if (gotAck)
        {
          m_listener->GotAck (rxSnr, txVector.GetMode  ());
        }
      if (m_txParams.HasNextPacket ())
        {

      packet->RemoveHeader (blockAck);
      m_blockAckTimeoutEvent.Cancel ();
      NotifyAckTimeoutResetNow ();
      m_listener->GotBlockAck (&blockAck, hdr.GetAddr2 (),txVector.GetMode  ());
      m_sentMpdus = 0;
      m_ampdu = false;
    }

                                                        blockAckReq,
                                                        hdr.GetAddr2 (),
                                                        hdr.GetDuration (),
                                                        txVector.GetMode ());
                }
              else
                {

  else if (hdr.GetAddr1 () == m_self)
    {
      m_stationManager->ReportRxOk (hdr.GetAddr2 (), &hdr,
                                    rxSnr, txVector.GetMode  ());
      if (hdr.IsQosData () && ReceiveMpdu (packet, hdr))
        {
          /* From section 9.10.4 in IEEE 802.11:

                                                    &MacLow::SendAckAfterData, this,
                                                    hdr.GetAddr2 (),
                                                    hdr.GetDuration (),
                                                    txVector.GetMode  (),
                                                    rxSnr);
              m_receivedAtLeastOneMpdu = false;
            }

                                                    &MacLow::SendAckAfterData, this,
                                                    hdr.GetAddr2 (),
                                                    hdr.GetDuration (),
                                                    txVector.GetMode (),
                                                    rxSnr);
            }
        }

Time
MacLow::GetAckDuration (Mac48Address to, WifiTxVector dataTxVector) const
{
  WifiTxVector ackTxVector = GetAckTxVectorForData (to, dataTxVector.GetMode ());
  return GetAckDuration (ackTxVector);
}
Time
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, WIFI_PREAMBLE_LONG, m_phy->GetFrequency(), 0, 0);
    preamble= WIFI_PREAMBLE_HT_MF;
  else
    preamble=WIFI_PREAMBLE_LONG;
  return m_phy->CalculateTxDuration (GetAckSize (), ackTxVector, preamble, m_phy->GetFrequency(), 0, 0);
}
Time
MacLow::GetBlockAckDuration (Mac48Address to, WifiTxVector blockAckReqTxVector, enum BlockAckType type) const
{
  /*
   * For immediate Basic BlockAck we should transmit the frame with the same WifiMode
   * as the BlockAckReq.
   *
   * from section 9.6 in IEEE 802.11e:
   * The BlockAck control frame shall be sent at the same rate and modulation class as
   * the BlockAckReq frame if it is sent in response to a BlockAckReq frame.
   */
  WifiPreamble preamble;
  if (blockAckReqTxVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_HT && type == BASIC_BLOCK_ACK)
    preamble= WIFI_PREAMBLE_HT_MF;
  else
    preamble=WIFI_PREAMBLE_LONG;

Time
MacLow::GetCtsDuration (Mac48Address to, WifiTxVector rtsTxVector) const
{
  WifiTxVector ctsTxVector = GetCtsTxVectorForRts (to, rtsTxVector.GetMode ());
  return GetCtsDuration (ctsTxVector);
}

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, WIFI_PREAMBLE_LONG, m_phy->GetFrequency(), 0, 0);
    preamble= WIFI_PREAMBLE_HT_MF;
  else
    preamble=WIFI_PREAMBLE_LONG;
  return m_phy->CalculateTxDuration (GetCtsSize (), ctsTxVector, preamble, m_phy->GetFrequency(), 0, 0);
}
uint32_t
MacLow::GetCtsSize (void) const

        {
          preamble = WIFI_PREAMBLE_HT_GF;
        }
      else if (rtsTxVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_HT)
        {
          preamble = WIFI_PREAMBLE_HT_MF;
        }
      else
        {
          //Otherwise, RTS should always use non-HT PPDU (HT PPDU cases not supported yet)
          preamble = WIFI_PREAMBLE_LONG;
        }
      txTime += m_phy->CalculateTxDuration (GetRtsSize (), rtsTxVector, preamble, m_phy->GetFrequency(), 0, 0);

      txTime += Time (GetSifs () * 2);
    }
  WifiTxVector dataTxVector = GetDataTxVector (packet, hdr);
  //standard says RTS packets can have GF format sec 9.6.0e.1 page 110 bullet b 2
  if ( 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
    preamble=WIFI_PREAMBLE_LONG;

    {
      WifiTxVector dataTxVector = GetDataTxVector (packet, hdr);
      WifiPreamble preamble;
      //standard says RTS packets can have GF format sec 9.6.0e.1 page 110 bullet b 2
      if ( m_phy->GetGreenfield()&& m_stationManager->GetGreenfieldSupported (m_currentHdr.GetAddr1 ()))
         preamble= WIFI_PREAMBLE_HT_GF;
      else //Otherwise, RTS should always use non-HT PPDU (HT PPDU cases not supported yet)
         preamble = WIFI_PREAMBLE_LONG;
      else
        preamble=WIFI_PREAMBLE_LONG;
      txTime += GetSifs ();
      txTime += m_phy->CalculateTxDuration (params.GetNextPacketSize (), dataTxVector, preamble, m_phy->GetFrequency(), 0, 0);
    }

}

void
MacLow::NotifyNav (Ptr<const Packet> packet,const WifiMacHeader &hdr, WifiPreamble preamble)
{
  NS_ASSERT (m_lastNavStart <= Simulator::Now ());
  Time duration = hdr.GetDuration ();

  NS_LOG_DEBUG ("send " << hdr->GetTypeString () <<
                ", to=" << hdr->GetAddr1 () <<
                ", size=" << packet->GetSize () <<
                ", mode=" << txVector.GetMode  () <<
                ", duration=" << hdr->GetDuration () <<
                ", seq=0x" << std::hex << m_currentHdr.GetSequenceControl () << std::dec);
  if (!m_ampdu || hdr->IsRts ())


  WifiPreamble preamble;
  //standard says RTS packets can have GF format sec 9.6.0e.1 page 110 bullet b 2
  if (m_phy->GetGreenfield()&& m_stationManager->GetGreenfieldSupported (m_currentHdr.GetAddr1 ()))
    preamble= WIFI_PREAMBLE_HT_GF;
  else //Otherwise, RTS should always use non-HT PPDU (HT PPDU cases not supported yet)
    preamble = WIFI_PREAMBLE_LONG;
  else
    preamble=WIFI_PREAMBLE_LONG;

  if (m_txParams.HasDurationId ())
    {

      duration += GetSifs ();
      if (m_txParams.MustWaitBasicBlockAck ())
        {
          WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2(), dataTxVector.GetMode  ());
          duration += GetBlockAckDuration (m_currentHdr.GetAddr1 (), blockAckReqTxVector, BASIC_BLOCK_ACK);
        }
      else if (m_txParams.MustWaitCompressedBlockAck ())
        {
          WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2(), dataTxVector.GetMode  ());
          duration += GetBlockAckDuration (m_currentHdr.GetAddr1 (), blockAckReqTxVector, COMPRESSED_BLOCK_ACK);
        }
      else if (m_txParams.MustWaitAck ())

  //Since it is data then it can have format = GF
  if (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
    preamble=WIFI_PREAMBLE_LONG;

  if (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 (dataTxVector.GetMode  ().GetModulationClass () == WIFI_MOD_CLASS_HT)
    preamble= WIFI_PREAMBLE_HT_MF;
  else
     preamble=WIFI_PREAMBLE_LONG;

      if (m_txParams.MustWaitBasicBlockAck ())
        {
          duration += GetSifs ();
          WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), dataTxVector.GetMode  ());
          duration += GetBlockAckDuration (m_currentHdr.GetAddr1 (), blockAckReqTxVector, BASIC_BLOCK_ACK);
        }
      else if (m_txParams.MustWaitCompressedBlockAck ())
        {
          duration += GetSifs ();
          WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), dataTxVector.GetMode  ());
          duration += GetBlockAckDuration (m_currentHdr.GetAddr1 (), blockAckReqTxVector, COMPRESSED_BLOCK_ACK);
        }
      else if (m_txParams.MustWaitAck ())

      m_currentPacket->AddTrailer (fcs);
    }

  ForwardDown (m_currentPacket, &m_currentHdr, dataTxVector, preamble);
  m_currentPacket = 0;
}


  WifiTxVector ctsTxVector = GetCtsToSelfTxVector (m_currentPacket, &m_currentHdr);

  WifiPreamble preamble;
  if (ctsTxVector.GetMode  ().GetModulationClass () == WIFI_MOD_CLASS_HT)
    preamble= WIFI_PREAMBLE_HT_MF;
  else
    preamble=WIFI_PREAMBLE_LONG;

        {
          
          duration += GetSifs ();
          WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), dataTxVector.GetMode  ());
          duration += GetBlockAckDuration (m_currentHdr.GetAddr1 (), blockAckReqTxVector, BASIC_BLOCK_ACK);
        }
      else if (m_txParams.MustWaitCompressedBlockAck ())
        {
          duration += GetSifs ();
          WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), dataTxVector.GetMode  ());
          duration += GetBlockAckDuration (m_currentHdr.GetAddr1 (), blockAckReqTxVector, COMPRESSED_BLOCK_ACK);
        }
      else if (m_txParams.MustWaitAck ())

          if (m_txParams.MustWaitCompressedBlockAck ())
            {
              duration += GetSifs ();
              WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), dataTxVector.GetMode  ());
              duration += GetBlockAckDuration (m_currentHdr.GetAddr1 (), blockAckReqTxVector, COMPRESSED_BLOCK_ACK);
            }
          else if (m_txParams.MustWaitAck ())

  m_sendDataEvent = Simulator::Schedule (txDuration,
                                         &MacLow::SendDataAfterCts, this,
                                         cts.GetAddr1 (),
                                         duration);
                                         ctsTxVector.GetMode());
}
void
MacLow::SendCtsAfterRts (Mac48Address source, Time duration, WifiTxVector rtsTxVector, double rtsSnr)
{
  NS_LOG_FUNCTION (this << source << duration << rtsTxVector.GetMode () << rtsSnr);
  /* send a CTS when you receive a RTS
   * right after SIFS.
   */
  WifiTxVector ctsTxVector = GetCtsTxVector (source, rtsTxVector.GetMode ());
  WifiMacHeader cts;
  cts.SetType (WIFI_MAC_CTL_CTS);
  cts.SetDsNotFrom ();

  cts.SetNoMoreFragments ();
  cts.SetNoRetry ();
  cts.SetAddr1 (source);
  duration -= GetCtsDuration (source, rtsTxVector);
  duration -= GetSifs ();
  NS_ASSERT (duration >= MicroSeconds (0));
  cts.SetDuration (duration);

  tag.Set (rtsSnr);
  packet->AddPacketTag (tag);

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

void
MacLow::SendDataAfterCts (Mac48Address source, Time duration)
{
  NS_LOG_FUNCTION (this);
  /* send the third step in a

  if (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 (dataTxVector.GetMode  ().GetModulationClass () == WIFI_MOD_CLASS_HT)
    preamble= WIFI_PREAMBLE_HT_MF;
  else
     preamble=WIFI_PREAMBLE_LONG;

  if (m_txParams.MustWaitBasicBlockAck ())
    {
      newDuration += GetSifs ();
      WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), dataTxVector.GetMode  ());
      newDuration += GetBlockAckDuration (m_currentHdr.GetAddr1 (), blockAckReqTxVector, BASIC_BLOCK_ACK);
    }
  else if (m_txParams.MustWaitCompressedBlockAck ())
    {
      newDuration += GetSifs ();
      WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), dataTxVector.GetMode  ());
      newDuration += GetBlockAckDuration (m_currentHdr.GetAddr1 (), blockAckReqTxVector, COMPRESSED_BLOCK_ACK);
    }
  else if (m_txParams.MustWaitAck ())

      if (m_txParams.MustWaitCompressedBlockAck ())
        {
           newDuration += GetSifs ();
           WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), dataTxVector.GetMode  ());
           newDuration += GetBlockAckDuration (m_currentHdr.GetAddr1 (), blockAckReqTxVector, COMPRESSED_BLOCK_ACK);
        }
      else if (m_txParams.MustWaitAck ())

  tag.Set (dataSnr);
  packet->AddPacketTag (tag);

  //ACK should always use non-HT PPDU (HT PPDU cases not supported yet)
  ForwardDown (packet, &ack, ackTxVector, WIFI_PREAMBLE_LONG);
  if (ackTxVector.GetMode().GetModulationClass () == WIFI_MOD_CLASS_HT)
    preamble= WIFI_PREAMBLE_HT_MF;
  else
    preamble=WIFI_PREAMBLE_LONG;
  ForwardDown (packet, &ack, ackTxVector, preamble);
}

bool

  WifiMacTrailer fcs;
  packet->AddTrailer (fcs);
  WifiPreamble preamble;
  if (blockAckReqTxVector.GetMode  ().GetModulationClass () == WIFI_MOD_CLASS_HT)
    preamble= WIFI_PREAMBLE_HT_MF;
  else
    preamble=WIFI_PREAMBLE_LONG;

  m_currentPacket = 0;
}
void 
MacLow::SendBlockAckAfterAmpdu (uint8_t tid, Mac48Address originator, Time duration, WifiTxVector blockAckReqTxVector)
{
  NS_LOG_FUNCTION (this);
  CtrlBAckResponseHeader blockAck;

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

  SendBlockAckResponse (&blockAck, originator, immediate, duration, blockAckReqTxVector.GetMode  ());
}

void

}

void
MacLow::DeaggregateAmpduAndReceive (Ptr<Packet> aggregatedPacket, double rxSnr, WifiTxVector txVector, WifiPreamble preamble)
{
  m_currentTxVector = txVector;
  AmpduTag ampdu;
  bool normalAck = false;
  bool ampduSubframe = false;

      WifiMacHeader firsthdr;
      (*n).first->PeekHeader(firsthdr);
      NS_LOG_DEBUG ("duration/id=" << firsthdr.GetDuration ());
      NotifyNav ((*n).first,firsthdr, preamble);
      if (firsthdr.GetAddr1 () == m_self)
        {
          m_receivedAtLeastOneMpdu = true;
          if (firsthdr.IsAck () || firsthdr.IsBlockAck () || firsthdr.IsBlockAckReq ())
              ReceiveOk ((*n).first, rxSnr, txVector, preamble, ampduSubframe);
          else if (firsthdr.IsData () || firsthdr.IsQosData ())
            {
              NS_LOG_DEBUG ("Deaagregate packet with sequence=" << firsthdr.GetSequenceNumber ());
              ReceiveOk ((*n).first, rxSnr, txVector, preamble, ampduSubframe);
              if (firsthdr.IsQosAck ())
                {
                  NS_LOG_DEBUG ("Normal Ack");

                                                    firsthdr.GetQosTid(),
                                                    firsthdr.GetAddr2 (),
                                                    firsthdr.GetDuration (),
                                                    txVector);
            } 
          else
            { 

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


    WifiTxVector dataTxVector = GetDataTxVector (m_currentPacket, &m_currentHdr);
    if (m_phy->GetGreenfield () && m_stationManager->GetGreenfieldSupported (m_currentHdr.GetAddr1 ()))
        preamble = WIFI_PREAMBLE_HT_GF;
    else //Block ACK following implicit BAR always use non-HT PPDU
        preamble = WIFI_PREAMBLE_LONG;
    
    if (peekedPacket == 0)
        return true;
    
    //An HT STA shall not transmit a PPDU that has a duration that is greater than aPPDUMaxTime (10 milliseconds)
    if(m_phy->CalculateTxDuration (aggregatedPacket->GetSize () + peekedPacket->GetSize () + peekedHdr.GetSize () + WIFI_MAC_FCS_LENGTH, dataTxVector, preamble, m_phy->GetFrequency(), 0, 0) > MilliSeconds(10))
        return true;
    
    if (!m_mpduAggregator->CanBeAggregated (peekedPacket->GetSize () + peekedHdr.GetSize () + WIFI_MAC_FCS_LENGTH, aggregatedPacket, size))




  /**
   * \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, WifiPreamble preamble, bool ampduSubframe);
  /**
   * \param packet packet received.
   * \param rxSnr snr of packet received.

  /**
   * \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, WifiPreamble preamble);
  /**
   * \param peekedPacket the packet to be aggregated
   * \param peekedHdr the WifiMacHeader for the packet.

  Time CalculateOverallTxTime (Ptr<const Packet> packet,
                               const WifiMacHeader* hdr,
                               const MacLowTransmissionParameters &params) const;
  void NotifyNav (Ptr<const Packet> packet,const WifiMacHeader &hdr, WifiPreamble preamble);
  /**
   * Reset NAV with the given duration.
   *

   *
   * \param source
   * \param duration
   * \param rtsTxVector
   * \param rtsSnr
   */
  void SendCtsAfterRts (Mac48Address source, Time duration, WifiTxVector rtsTxVector, double rtsSnr);
  /**
   * Send ACK after receiving DATA.
   *

   *
   * \param source
   * \param duration
   * \param txMode
   */
  void SendDataAfterCts (Mac48Address source, Time duration);
  /**
   * Event handler that is usually scheduled to fired at the appropriate time
   * after completing transmissions.

   * block ack agreement and creates block ack bitmap on a received packets basis.
   */
  void SendBlockAckAfterAmpdu (uint8_t tid, Mac48Address originator,
                                          Time duration, WifiTxVector blockAckReqTxVector);
  /**
   * This method creates block ack frame with header equals to <i>blockAck</i> and start its transmission.
   *

  bool m_ctsToSelfSupported;          //!< Flag whether CTS-to-self is supported
  uint8_t m_sentMpdus;                //!< Number of transmitted MPDUs in an A-MPDU that have not been acknowledged yet
  Ptr<WifiMacQueue> m_aggregateQueue; //!< Queue used for MPDU aggregation
  WifiTxVector m_currentTxVector;     //!< TXVECTOR used for the current packet transmission
  bool m_receivedAtLeastOneMpdu;      //!< Flag whether an MPDU has already been successfully received while receiving an A-MPDU
};


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

Lines 106-111	Link Here

106

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

106

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

107

  return item->isMandatory;

107

  return item->isMandatory;

108

109

bool

110

WifiMode::IsBssBasic (void) const

111

112

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

113

  return item->isBssBasic;

114

109

uint32_t

115

uint32_t

110

WifiMode::GetUid (void) const

116

WifiMode::GetUid (void) const

111

117

Lines 141-146	Link Here

141

WifiModeFactory::CreateWifiMode (std::string uniqueName,

147

WifiModeFactory::CreateWifiMode (std::string uniqueName,

142

                                 enum WifiModulationClass modClass,

148

                                 enum WifiModulationClass modClass,

143

                                 bool isMandatory,

149

                                 bool isMandatory,

150

                                 bool isBssBasic,

144

                                 uint32_t bandwidth,

151

                                 uint32_t bandwidth,

145

                                 uint32_t dataRate,

152

                                 uint32_t dataRate,

146

                                 enum WifiCodeRate codingRate,

153

                                 enum WifiCodeRate codingRate,

Lines 193-198	Link Here

193

200

194

  item->constellationSize = constellationSize;

201

  item->constellationSize = constellationSize;

195

  item->isMandatory = isMandatory;

202

  item->isMandatory = isMandatory;

203

  item->isBssBasic = isBssBasic;

196

204

197

  return WifiMode (uid);

205

  return WifiMode (uid);

198

206

Lines 274-279	Link Here

274

      item->constellationSize = 0;

282

      item->constellationSize = 0;

275

      item->codingRate = WIFI_CODE_RATE_UNDEFINED;

283

      item->codingRate = WIFI_CODE_RATE_UNDEFINED;

276

      item->isMandatory = false;

284

      item->isMandatory = false;

285

      item->isBssBasic = false;

277

      isFirstTime = false;

286

      isFirstTime = false;

278

287

279

  return &factory;

288

  return &factory;

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

Lines 128-133	Link Here

128

   *          otherwise.

128

   *          otherwise.

129

*/

129

*/

130

  bool IsMandatory (void) const;

130

  bool IsMandatory (void) const;

131

132

/**

133

   * \returns true if this mode belongs to the BSSBasicRateSet or to the BSSBasicMCSSet (IEEE 802.11n),

134

   *          false otherwise.

135

*/

136

  bool IsBssBasic (void) const;

131

137

132

/**

138

/**

133

   * \returns the uid associated to this wireless mode.

139

   * \returns the uid associated to this wireless mode.

Lines 211-216	Link Here

211

   *        must be unique accross _all_ instances.

217

   *        must be unique accross _all_ instances.

212

   * \param modClass the class of modulation

218

   * \param modClass the class of modulation

213

   * \param isMandatory true if this WifiMode is mandatory, false otherwise.

219

   * \param isMandatory true if this WifiMode is mandatory, false otherwise.

220

   * \param isBssBasic true if this WifiMode belongs to the BSSBasicRateSet or to the BSSBasicMCSSet (IEEE 802.11n), false otherwise.

214

   * \param bandwidth the bandwidth (Hz) of the signal generated when the

221

   * \param bandwidth the bandwidth (Hz) of the signal generated when the

215

   *        associated WifiMode is used.

222

   *        associated WifiMode is used.

216

   * \param dataRate the rate (bits/second) at which the user data is transmitted

223

   * \param dataRate the rate (bits/second) at which the user data is transmitted

Lines 227-232	Link Here

227

  static WifiMode CreateWifiMode (std::string uniqueName,

234

  static WifiMode CreateWifiMode (std::string uniqueName,

228

                                  enum WifiModulationClass modClass,

235

                                  enum WifiModulationClass modClass,

229

                                  bool isMandatory,

236

                                  bool isMandatory,

237

                                  bool isBssBasic,

230

                                  uint32_t bandwidth,

238

                                  uint32_t bandwidth,

231

                                  uint32_t dataRate,

239

                                  uint32_t dataRate,

232

                                  enum WifiCodeRate codingRate,

240

                                  enum WifiCodeRate codingRate,

Lines 259-264	Link Here

259

    uint8_t constellationSize;

267

    uint8_t constellationSize;

260

    enum WifiCodeRate codingRate;

268

    enum WifiCodeRate codingRate;

261

    bool isMandatory;

269

    bool isMandatory;

270

    bool isBssBasic;

262

};

271

};

263

272

264

/**

273

/**




}

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

}

(-)a/src/wifi/model/wifi-phy-state-helper.h (-2 / +2 lines)

Lines 157-166	Link Here

157

158

   * \param packet the successfully received packet

158

   * \param packet the successfully received packet

159

   * \param snr the SNR of the received packet

159

   * \param snr the SNR of the received packet

160

   * \param mode the transmission mode of the packet

160

   * \param txVector TXVECTOR of the packet

161

   * \param preamble the preamble of the received packet

161

   * \param preamble the preamble of the received packet

162

*/

162

*/

163

  void SwitchFromRxEndOk (Ptr<Packet> packet, double snr, WifiMode mode, enum WifiPreamble preamble);

163

  void SwitchFromRxEndOk (Ptr<Packet> packet, double snr, WifiTxVector txVector, enum WifiPreamble preamble);

164

/**

164

/**

165

   * Switch from RX after the reception failed.

165

   * Switch from RX after the reception failed.

166




  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("DsssRate1Mbps",
                                     WIFI_MOD_CLASS_DSSS,
                                     true, true,
                                     22000000, 1000000,
                                     WIFI_CODE_RATE_UNDEFINED,
                                     2);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("DsssRate2Mbps",
                                     WIFI_MOD_CLASS_DSSS,
                                     true, false,
                                     22000000, 2000000,
                                     WIFI_CODE_RATE_UNDEFINED,
                                     4);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("DsssRate5_5Mbps",
                                     WIFI_MOD_CLASS_DSSS,
                                     true, false,
                                     22000000, 5500000,
                                     WIFI_CODE_RATE_UNDEFINED,
                                     4);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("DsssRate11Mbps",
                                     WIFI_MOD_CLASS_DSSS,
                                     true, false,
                                     22000000, 11000000,
                                     WIFI_CODE_RATE_UNDEFINED,
                                     4);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("ErpOfdmRate6Mbps",
                                     WIFI_MOD_CLASS_ERP_OFDM,
                                     true, true,
                                     20000000, 6000000,
                                     WIFI_CODE_RATE_1_2,
                                     2);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("ErpOfdmRate9Mbps",
                                     WIFI_MOD_CLASS_ERP_OFDM,
                                     false, false,
                                     20000000, 9000000,
                                     WIFI_CODE_RATE_3_4,
                                     2);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("ErpOfdmRate12Mbps",
                                     WIFI_MOD_CLASS_ERP_OFDM,
                                     true, true,
                                     20000000, 12000000,
                                     WIFI_CODE_RATE_1_2,
                                     4);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("ErpOfdmRate18Mbps",
                                     WIFI_MOD_CLASS_ERP_OFDM,
                                     false, false,
                                     20000000, 18000000,
                                     WIFI_CODE_RATE_3_4,
                                     4);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("ErpOfdmRate24Mbps",
                                     WIFI_MOD_CLASS_ERP_OFDM,
                                     true, true,
                                     20000000, 24000000,
                                     WIFI_CODE_RATE_1_2,
                                     16);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("ErpOfdmRate36Mbps",
                                     WIFI_MOD_CLASS_ERP_OFDM,
                                     false, false,
                                     20000000, 36000000,
                                     WIFI_CODE_RATE_3_4,
                                     16);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("ErpOfdmRate48Mbps",
                                     WIFI_MOD_CLASS_ERP_OFDM,
                                     false, false,
                                     20000000, 48000000,
                                     WIFI_CODE_RATE_2_3,
                                     64);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("ErpOfdmRate54Mbps",
                                     WIFI_MOD_CLASS_ERP_OFDM,
                                     false, false,
                                     20000000, 54000000,
                                     WIFI_CODE_RATE_3_4,
                                     64);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate6Mbps",
                                     WIFI_MOD_CLASS_OFDM,
                                     true, false,
                                     20000000, 6000000,
                                     WIFI_CODE_RATE_1_2,
                                     2);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate9Mbps",
                                     WIFI_MOD_CLASS_OFDM,
                                     false, false,
                                     20000000, 9000000,
                                     WIFI_CODE_RATE_3_4,
                                     2);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate12Mbps",
                                     WIFI_MOD_CLASS_OFDM,
                                     true, true,
                                     20000000, 12000000,
                                     WIFI_CODE_RATE_1_2,
                                     4);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate18Mbps",
                                     WIFI_MOD_CLASS_OFDM,
                                     false, false,
                                     20000000, 18000000,
                                     WIFI_CODE_RATE_3_4,
                                     4);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate24Mbps",
                                     WIFI_MOD_CLASS_OFDM,
                                     true, true,
                                     20000000, 24000000,
                                     WIFI_CODE_RATE_1_2,
                                     16);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate36Mbps",
                                     WIFI_MOD_CLASS_OFDM,
                                     false, false,
                                     20000000, 36000000,
                                     WIFI_CODE_RATE_3_4,
                                     16);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate48Mbps",
                                     WIFI_MOD_CLASS_OFDM,
                                     false, false,
                                     20000000, 48000000,
                                     WIFI_CODE_RATE_2_3,
                                     64);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate54Mbps",
                                     WIFI_MOD_CLASS_OFDM,
                                     false, false,
                                     20000000, 54000000,
                                     WIFI_CODE_RATE_3_4,
                                     64);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate3MbpsBW10MHz",
                                     WIFI_MOD_CLASS_OFDM,
                                     true, true,
                                     10000000, 3000000,
                                     WIFI_CODE_RATE_1_2,
                                     2);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate4_5MbpsBW10MHz",
                                     WIFI_MOD_CLASS_OFDM,
                                     false, false,
                                     10000000, 4500000,
                                     WIFI_CODE_RATE_3_4,
                                     2);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate6MbpsBW10MHz",
                                     WIFI_MOD_CLASS_OFDM,
                                     true, true,
                                     10000000, 6000000,
                                     WIFI_CODE_RATE_1_2,
                                     4);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate9MbpsBW10MHz",
                                     WIFI_MOD_CLASS_OFDM,
                                     false, false,
                                     10000000, 9000000,
                                     WIFI_CODE_RATE_3_4,
                                     4);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate12MbpsBW10MHz",
                                     WIFI_MOD_CLASS_OFDM,
                                     true, true,
                                     10000000, 12000000,
                                     WIFI_CODE_RATE_1_2,
                                     16);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate18MbpsBW10MHz",
                                     WIFI_MOD_CLASS_OFDM,
                                     false, false,
                                     10000000, 18000000,
                                     WIFI_CODE_RATE_3_4,
                                     16);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate24MbpsBW10MHz",
                                     WIFI_MOD_CLASS_OFDM,
                                     false, false,
                                     10000000, 24000000,
                                     WIFI_CODE_RATE_2_3,
                                     64);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate27MbpsBW10MHz",
                                     WIFI_MOD_CLASS_OFDM,
                                     false, false,
                                     10000000, 27000000,
                                     WIFI_CODE_RATE_3_4,
                                     64);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate1_5MbpsBW5MHz",
                                     WIFI_MOD_CLASS_OFDM,
                                     true, true,
                                     5000000, 1500000,
                                     WIFI_CODE_RATE_1_2,
                                     2);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate2_25MbpsBW5MHz",
                                     WIFI_MOD_CLASS_OFDM,
                                     false, false,
                                     5000000, 2250000,
                                     WIFI_CODE_RATE_3_4,
                                     2);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate3MbpsBW5MHz",
                                     WIFI_MOD_CLASS_OFDM,
                                     true, true,
                                     5000000, 3000000,
                                     WIFI_CODE_RATE_1_2,
                                     4);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate4_5MbpsBW5MHz",
                                     WIFI_MOD_CLASS_OFDM,
                                     false, false,
                                     5000000, 4500000,
                                     WIFI_CODE_RATE_3_4,
                                     4);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate6MbpsBW5MHz",
                                     WIFI_MOD_CLASS_OFDM,
                                     true, true,
                                     5000000, 6000000,
                                     WIFI_CODE_RATE_1_2,
                                     16);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate9MbpsBW5MHz",
                                     WIFI_MOD_CLASS_OFDM,
                                     false, false,
                                     5000000, 9000000,
                                     WIFI_CODE_RATE_3_4,
                                     16);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate12MbpsBW5MHz",
                                     WIFI_MOD_CLASS_OFDM,
                                     false, false,
                                     5000000, 12000000,
                                     WIFI_CODE_RATE_2_3,
                                     64);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate13_5MbpsBW5MHz",
                                     WIFI_MOD_CLASS_OFDM,
                                     false, false,
                                     5000000, 13500000,
                                     WIFI_CODE_RATE_3_4,
                                     64);

  static WifiMode mode =
  WifiModeFactory::CreateWifiMode ("OfdmRate6_5MbpsBW20MHz",
                                    WIFI_MOD_CLASS_HT,
                                    true, true,
                                    20000000, 6500000,
                                    WIFI_CODE_RATE_1_2,
                                    2);

  static WifiMode mode =
  WifiModeFactory::CreateWifiMode ("OfdmRate7_2MbpsBW20MHz",
                                    WIFI_MOD_CLASS_HT,
                                    false, false,
                                    20000000, 7200000,
                                    WIFI_CODE_RATE_1_2,
                                    2);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate13MbpsBW20MHz",
                                     WIFI_MOD_CLASS_HT,
                                     true, true,
                                     20000000, 13000000,
                                     WIFI_CODE_RATE_1_2,
                                     4);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate14_4MbpsBW20MHz",
                                     WIFI_MOD_CLASS_HT,
                                     false, false,
                                     20000000, 14400000,
                                     WIFI_CODE_RATE_1_2,
                                     4);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate19_5MbpsBW20MHz",
                                     WIFI_MOD_CLASS_HT,
                                     true, true,
                                     20000000, 19500000,
                                     WIFI_CODE_RATE_3_4,
                                     4);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate21_7MbpsBW20MHz",
                                     WIFI_MOD_CLASS_HT,
                                     false, false,
                                     20000000, 21700000,
                                     WIFI_CODE_RATE_3_4,
                                     4);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate26MbpsBW20MHz",
                                     WIFI_MOD_CLASS_HT,
                                     true, true,
                                     20000000, 26000000,
                                     WIFI_CODE_RATE_1_2,
                                     16);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate28_9MbpsBW20MHz",
                                     WIFI_MOD_CLASS_HT,
                                     false, false,
                                     20000000, 28900000,
                                     WIFI_CODE_RATE_1_2,
                                     16);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate39MbpsBW20MHz",
                                     WIFI_MOD_CLASS_HT,
                                     true, true,
                                     20000000, 39000000,
                                     WIFI_CODE_RATE_3_4,
                                     16);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate43_3MbpsBW20MHz",
                                     WIFI_MOD_CLASS_HT,
                                     false, false,
                                     20000000, 43300000,
                                     WIFI_CODE_RATE_3_4,
                                     16);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate52MbpsBW20MHz",
                                     WIFI_MOD_CLASS_HT,
                                     true, true,
                                     20000000, 52000000,
                                     WIFI_CODE_RATE_2_3,
                                     64);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate57_8MbpsBW20MHz",
                                     WIFI_MOD_CLASS_HT,
                                     false, false,
                                     20000000, 57800000,
                                     WIFI_CODE_RATE_2_3,
                                     64);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate58_5MbpsBW20MHz",
                                     WIFI_MOD_CLASS_HT,
                                     true, true,
                                     20000000, 58500000,
                                     WIFI_CODE_RATE_3_4,
                                     64);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate65MbpsBW20MHzShGi",
                                     WIFI_MOD_CLASS_HT,
                                     false, false,
                                     20000000, 65000000,
                                     WIFI_CODE_RATE_3_4,
                                     64);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate65MbpsBW20MHz",
                                     WIFI_MOD_CLASS_HT,
                                     true, true,
                                     20000000, 65000000,
                                     WIFI_CODE_RATE_5_6,
                                     64);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate72_2MbpsBW20MHz",
                                     WIFI_MOD_CLASS_HT,
                                     false, false,
                                     20000000, 72200000,
                                     WIFI_CODE_RATE_5_6,
                                     64);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate13_5MbpsBW40MHz",
                                     WIFI_MOD_CLASS_HT,
                                     false, false,
                                     40000000, 13500000,
                                     WIFI_CODE_RATE_1_2,
                                     2);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate15MbpsBW40MHz",
                                     WIFI_MOD_CLASS_HT,
                                     false, false,
                                     40000000, 15000000,
                                     WIFI_CODE_RATE_1_2,
                                     2);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate27MbpsBW40MHz",
                                     WIFI_MOD_CLASS_HT,
                                     false, false,
                                     40000000, 27000000,
                                     WIFI_CODE_RATE_1_2,
                                     4);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate30MbpsBW40MHz",
                                     WIFI_MOD_CLASS_HT,
                                     false, false,
                                     40000000, 30000000,
                                     WIFI_CODE_RATE_1_2,
                                     4);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate40_5MbpsBW40MHz",
                                     WIFI_MOD_CLASS_HT,
                                     false, false,
                                     40000000, 40500000,
                                     WIFI_CODE_RATE_3_4,
                                     4);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate45MbpsBW40MHz",
                                     WIFI_MOD_CLASS_HT,
                                     false, false,
                                     40000000, 45000000,
                                     WIFI_CODE_RATE_3_4,
                                     4);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate54MbpsBW40MHz",
                                     WIFI_MOD_CLASS_HT,
                                     false, false,
                                     40000000, 54000000,
                                     WIFI_CODE_RATE_1_2,
                                     16);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate60MbpsBW40MHz",
                                     WIFI_MOD_CLASS_HT,
                                     false, false,
                                     40000000, 60000000,
                                     WIFI_CODE_RATE_1_2,
                                     16);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate81MbpsBW40MHz",
                                     WIFI_MOD_CLASS_HT,
                                     false, false,
                                     40000000, 81000000,
                                     WIFI_CODE_RATE_3_4,
                                     16);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate90MbpsBW40MHz",
                                     WIFI_MOD_CLASS_HT,
                                     false, false,
                                     40000000, 90000000,
                                     WIFI_CODE_RATE_3_4,
                                     16);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate108MbpsBW40MHz",
                                     WIFI_MOD_CLASS_HT,
                                     false, false,
                                     40000000, 108000000,
                                     WIFI_CODE_RATE_2_3,
                                     64);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate120MbpsBW40MHz",
                                     WIFI_MOD_CLASS_HT,
                                     false, false,
                                     40000000, 120000000,
                                     WIFI_CODE_RATE_2_3,
                                     64);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate121_5MbpsBW40MHz",
                                     WIFI_MOD_CLASS_HT,
                                     false, false,
                                     40000000, 121500000,
                                     WIFI_CODE_RATE_3_4,
                                     64);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate135MbpsBW40MHzShGi",
                                     WIFI_MOD_CLASS_HT,
                                     false, false,
                                     40000000, 135000000,
                                     WIFI_CODE_RATE_3_4,
                                     64);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate135MbpsBW40MHz",
                                     WIFI_MOD_CLASS_HT,
                                     false, false,
                                     40000000, 135000000,
                                     WIFI_CODE_RATE_5_6,
                                     64);

  static WifiMode mode =
    WifiModeFactory::CreateWifiMode ("OfdmRate150MbpsBW40MHz",
                                     WIFI_MOD_CLASS_HT,
                                     false, false,
                                     40000000, 150000000,
                                     WIFI_CODE_RATE_5_6,
                                     64);

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

Lines 160-169	Link Here

160

/**

160

/**

161

   * arg1: packet received successfully

161

   * arg1: packet received successfully

162

   * arg2: snr of packet

162

   * arg2: snr of packet

163

   * arg3: mode of packet

163

   * arg3: TXVECTOR of packet

164

   * arg4: type of preamble used for packet.

164

   * arg4: type of preamble used for packet.

165

*/

165

*/

166

  typedef Callback<void,Ptr<Packet>, double, WifiMode, enum WifiPreamble> RxOkCallback;

166

  typedef Callback<void,Ptr<Packet>, double, WifiTxVector, enum WifiPreamble> RxOkCallback;

167

/**

167

/**

168

   * arg1: packet received unsuccessfully

168

   * arg1: packet received unsuccessfully

169

   * arg2: snr of packet

169

   * arg2: snr of packet




       i != m_bssBasicRateSet.end (); i++)
    {
      if ((!found || i->GetPhyRate () > mode.GetPhyRate ())
          && (i->GetPhyRate () <= reqMode.GetPhyRate ())
          && ((i->GetModulationClass () == reqMode.GetModulationClass ())
              || (reqMode.GetModulationClass () == WIFI_MOD_CLASS_HT)))
        {
          mode = *i;
          // We've found a potentially-suitable transmit rate, but we

          found = true;
        }
    }

      {
        if (!found)
          {
            uint8_t mcs = GetDefaultMcs (); 
            mode=  m_wifiPhy->McsToWifiMode (mcs); 
          }
        for (WifiMcsListIterator i = m_bssBasicMcsSet.begin ();
             i != m_bssBasicMcsSet.end (); i++)
          {
            WifiMode thismode=  m_wifiPhy->McsToWifiMode (*i); 
            if ((!found || thismode.GetPhyRate () > mode.GetPhyRate ())
                && thismode.GetPhyRate () <= reqMode.GetPhyRate ()
                && thismode.GetModulationClass () == reqMode.GetModulationClass ())
              {
                mode = thismode;
                // We've found a potentially-suitable transmit rate, but we
                // need to continue and consider all the basic rates before
                // we can be sure we've got the right one.
                found = true;
              }
          }
      }
  // If we found a suitable rate in the BSSBasicRateSet, then we are
  // done and can return that mode.
  if (found)
    {
      NS_LOG_DEBUG ("WifiRemoteStationManager::GetControlAnswerMode returning " << mode);
      return mode;
    }


       */
      if (thismode.IsMandatory ()
          && (!found || thismode.GetPhyRate () > mode.GetPhyRate ())
          && (thismode.GetPhyRate () <= reqMode.GetPhyRate ())
          && ((thismode.GetModulationClass () == reqMode.GetModulationClass ()) ||
             (reqMode.GetModulationClass () == WIFI_MOD_CLASS_HT)))
        {
          mode = thismode;
          // As above; we've found a potentially-suitable transmit

          found = true;
        }
    }
  if(HasHtSupported())
    {
      for (uint32_t idx = 0; idx < m_wifiPhy->GetNMcs (); idx++)
        {
          uint8_t thismcs = m_wifiPhy->GetMcs (idx);
          WifiMode thismode=  m_wifiPhy->McsToWifiMode (thismcs);
          if (thismode.IsMandatory ()
              && (!found || thismode.GetPhyRate () > mode.GetPhyRate ())
              && thismode.GetPhyRate () <= reqMode.GetPhyRate ()
              && thismode.GetModulationClass () == reqMode.GetModulationClass ())
            {
              mode = thismode;
              // As above; we've found a potentially-suitable transmit
              // rate, but we need to continue and consider all the
              // mandatory rates before we can be sure we've got the right
              // one.
              found = true;
            }
            
        }
    }

  /**
   * If we still haven't found a suitable rate for the response then





  Ptr<InterferenceHelper::Event> event;
  event = m_interference.Add (packet->GetSize (),
                              txVector,
                              preamble,
                              rxDuration,
                              rxPowerW);
		          txVector);  // we need it to calculate duration of HT training symbols

  switch (m_state->GetState ())
    {

      double signalDbm = RatioToDb (event->GetRxPowerW ()) + 30;
      double noiseDbm = RatioToDb (event->GetRxPowerW () / snrPer.snr) - GetRxNoiseFigure () + 30;
      NotifyMonitorSniffRx (packet, (uint16_t)GetChannelFrequencyMhz (), GetChannelNumber (), dataRate500KbpsUnits, isShortPreamble, signalDbm, noiseDbm);
      m_state->SwitchFromRxEndOk (packet, snrPer.snr, event->GetTxVector (), event->GetPreambleType ());
    }
  else
    {

Return to bug 2097