Attachment #2037 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 (+8 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

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

318

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

319

      // exept for 802.11b where we assume that only the two lowest mandatory rates are part of the BSSBasicRateSet

320

      if (mode.IsMandatory() &&

321

         ((mode.GetModulationClass () != WIFI_MOD_CLASS_DSSS) || mode == WifiPhy::GetDsssRate1Mbps () || mode == WifiPhy::GetDsssRate2Mbps ()))

322

323

        m_stationManager->AddBasicMode (mode);

324

317

325

318

  // set the basic rates

326

  // set the basic rates

319

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

327

  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
};





}

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

(-)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

        }
    }
  if(HasHtSupported())
    {
      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); 

                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





  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