WifiMode

WifiRemoteStationManager::GetControlAnswerMode (WifiMode reqMode)

{

  /**

   * The standard has relatively unambiguous rules for selecting a

   * control response rate (the below is quoted from IEEE 802.11-2012,

   * Section 9.7):

   *

   * To allow the transmitting STA to calculate the contents of the

   * Duration/ID field, a STA responding to a received frame shall

   * transmit its Control Response frame (either CTS or ACK), other

   * than the BlockAck control frame, at the highest rate in the

   * BSSBasicRateSet parameter that is less than or equal to the

   * rate of the immediately previous frame in the frame exchange

   * sequence (as defined in Annex G) and that is of the same

   * modulation class (see Section 9.7.8) as the received frame...

   */

  NS_LOG_FUNCTION (this << reqMode);

  WifiMode mode = GetDefaultMode ();

  bool found = false;

  //First, search the BSS Basic Rate set

  for (WifiModeListIterator i = m_bssBasicRateSet.begin (); i != m_bssBasicRateSet.end (); i++)

    {

      if ((!found || i->IsHigherDataRate (mode))

          && (!i->IsHigherDataRate (reqMode))

          && (IsAllowedControlAnswerModulationClass (reqMode.GetModulationClass (), i->GetModulationClass ())))

        {

          mode = *i;

          //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 (GetHtSupported () || GetVhtSupported () || GetHeSupported ())

    {

      if (!found)

        {

          mode = GetDefaultMcs ();

          for (WifiModeListIterator i = m_bssBasicMcsSet.begin (); i != m_bssBasicMcsSet.end (); i++)

            {

              if ((!found || i->IsHigherDataRate (mode))

                  && (!i->IsHigherDataRate (reqMode))

                  && (i->GetModulationClass () == reqMode.GetModulationClass ()))

                {

                  mode = *i;

                  //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 no suitable basic rate was found, we search the mandatory

   * rates. The standard (IEEE 802.11-2007, Section 9.6) says:

   *

   *   ...If no rate contained in the BSSBasicRateSet parameter meets

   *   these conditions, then the control frame sent in response to a

   *   received frame shall be transmitted at the highest mandatory

   *   rate of the PHY that is less than or equal to the rate of the

   *   received frame, and that is of the same modulation class as the

   *   received frame. In addition, the Control Response frame shall

   *   be sent using the same PHY options as the received frame,

   *   unless they conflict with the requirement to use the

   *   BSSBasicRateSet parameter.

   *

   * \todo Note that we're ignoring the last sentence for now, because

   * there is not yet any manipulation here of PHY options.

   */

  for (uint8_t idx = 0; idx < m_wifiPhy->GetNModes (); idx++)

    {

      WifiMode thismode = m_wifiPhy->GetMode (idx);

      /* If the rate:

       *

       *  - is a mandatory rate for the PHY, and

       *  - is equal to or faster than our current best choice, and

       *  - is less than or equal to the rate of the received frame, and

       *  - is of the same modulation class as the received frame

       *

       * ...then it's our best choice so far.

       */

      if (thismode.IsMandatory ()

          && (!found || thismode.IsHigherDataRate (mode))

          && (!thismode.IsHigherDataRate (reqMode))

          && (IsAllowedControlAnswerModulationClass (reqMode.GetModulationClass (), thismode.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 (GetHtSupported () || GetVhtSupported () || GetHeSupported ())

    {

      for (uint8_t idx = 0; idx < m_wifiPhy->GetNMcs (); idx++)

        {

          WifiMode thismode = m_wifiPhy->GetMcs (idx);

          if (thismode.IsMandatory ()

              && (!found || thismode.IsHigherDataRate (mode))

              && (!thismode.IsHigherCodeRate (reqMode))

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

   * someone has messed up the simulation config. This probably means

   * that the WifiPhyStandard is not set correctly, or that a rate that

   * is not supported by the PHY has been explicitly requested in a

   * WifiRemoteStationManager (or descendant) configuration.

   *

   * Either way, it is serious - we can either disobey the standard or

   * fail, and I have chosen to do the latter...

   */

  if (!found)

    {

      NS_FATAL_ERROR ("Can't find response rate for " << reqMode);

    }

  NS_LOG_DEBUG ("WifiRemoteStationManager::GetControlAnswerMode returning " << mode);

  return mode;

}

WifiTxVector

WifiRemoteStationManager::GetCtsTxVector (Mac48Address address, WifiMode rtsMode)

{

  NS_ASSERT (!address.IsGroup ());

  WifiMode ctsMode = GetControlAnswerMode (rtsMode);

  WifiTxVector v;

  v.SetMode (ctsMode);

  v.SetPreambleType (GetPreambleForTransmission (ctsMode.GetModulationClass (), GetShortPreambleEnabled (), UseGreenfieldForDestination (address)));

  v.SetTxPowerLevel (DoGetCtsTxPowerLevel (address, ctsMode));

  v.SetChannelWidth (GetChannelWidthForTransmission (ctsMode, DoGetCtsTxChannelWidth (address, ctsMode)));

  v.SetGuardInterval (DoGetCtsTxGuardInterval (address, ctsMode));

  v.SetNss (DoGetCtsTxNss (address, ctsMode));

  v.SetNess (DoGetCtsTxNess (address, ctsMode));

  v.SetStbc (0);

  return v;

}

WifiTxVector

WifiRemoteStationManager::GetAckTxVector (Mac48Address address, WifiMode dataMode)

{

  NS_ASSERT (!address.IsGroup ());

  WifiMode ackMode = GetControlAnswerMode (dataMode);

  WifiTxVector v;

  v.SetMode (ackMode);

  v.SetPreambleType (GetPreambleForTransmission (ackMode.GetModulationClass (), GetShortPreambleEnabled (), UseGreenfieldForDestination (address)));

  v.SetTxPowerLevel (DoGetAckTxPowerLevel (address, ackMode));

  v.SetChannelWidth (GetChannelWidthForTransmission (ackMode, DoGetAckTxChannelWidth (address, ackMode)));

  v.SetGuardInterval (DoGetAckTxGuardInterval (address, ackMode));

  v.SetNss (DoGetAckTxNss (address, ackMode));

  v.SetNess (DoGetAckTxNess (address, ackMode));

  v.SetStbc (0);

  return v;

}

WifiTxVector

WifiRemoteStationManager::GetBlockAckTxVector (Mac48Address address, WifiMode blockAckReqMode)

{

  NS_ASSERT (!address.IsGroup ());

  WifiMode blockAckMode = GetControlAnswerMode (blockAckReqMode);

  WifiTxVector v;

  v.SetMode (blockAckMode);

  v.SetPreambleType (GetPreambleForTransmission (blockAckMode.GetModulationClass (), GetShortPreambleEnabled (), UseGreenfieldForDestination (address)));

  v.SetTxPowerLevel (DoGetBlockAckTxPowerLevel (address, blockAckMode));

  v.SetChannelWidth (GetChannelWidthForTransmission (blockAckMode, DoGetBlockAckTxChannelWidth (address, blockAckMode)));

  v.SetGuardInterval (DoGetBlockAckTxGuardInterval (address, blockAckMode));

  v.SetNss (DoGetBlockAckTxNss (address, blockAckMode));

  v.SetNess (DoGetBlockAckTxNess (address, blockAckMode));

  v.SetStbc (0);

  return v;

}

uint8_t

WifiRemoteStationManager::DoGetCtsTxPowerLevel (Mac48Address address, WifiMode ctsMode)

{

  return m_defaultTxPowerLevel;

}

uint16_t

WifiRemoteStationManager::DoGetCtsTxChannelWidth (Mac48Address address, WifiMode ctsMode)

{

  return m_wifiPhy->GetChannelWidth ();

}

uint16_t

WifiRemoteStationManager::DoGetCtsTxGuardInterval (Mac48Address address, WifiMode ctsMode)

{

  return ConvertGuardIntervalToNanoSeconds (ctsMode, DynamicCast<WifiNetDevice> (m_wifiPhy->GetDevice ()));

}

uint8_t

WifiRemoteStationManager::DoGetCtsTxNss (Mac48Address address, WifiMode ctsMode)

{

  return 1;

}

uint8_t

WifiRemoteStationManager::DoGetCtsTxNess (Mac48Address address, WifiMode ctsMode)

{

  return 0;

}

uint8_t

WifiRemoteStationManager::DoGetAckTxPowerLevel (Mac48Address address, WifiMode ackMode)

{

  return m_defaultTxPowerLevel;

}

uint16_t

WifiRemoteStationManager::DoGetAckTxChannelWidth (Mac48Address address, WifiMode ctsMode)

{

  return m_wifiPhy->GetChannelWidth ();

}

uint16_t

WifiRemoteStationManager::DoGetAckTxGuardInterval (Mac48Address address, WifiMode ackMode)

{

  return ConvertGuardIntervalToNanoSeconds (ackMode, DynamicCast<WifiNetDevice> (m_wifiPhy->GetDevice ()));

}

uint8_t

WifiRemoteStationManager::DoGetAckTxNss (Mac48Address address, WifiMode ackMode)

{

  return 1;

}

uint8_t

WifiRemoteStationManager::DoGetAckTxNess (Mac48Address address, WifiMode ackMode)

{

  return 0;

}

uint8_t

WifiRemoteStationManager::DoGetBlockAckTxPowerLevel (Mac48Address address, WifiMode blockAckMode)

{

  return m_defaultTxPowerLevel;

}

uint16_t

WifiRemoteStationManager::DoGetBlockAckTxChannelWidth (Mac48Address address, WifiMode ctsMode)

{

  return m_wifiPhy->GetChannelWidth ();

}

uint16_t

WifiRemoteStationManager::DoGetBlockAckTxGuardInterval (Mac48Address address, WifiMode blockAckMode)

{

  return ConvertGuardIntervalToNanoSeconds (blockAckMode, DynamicCast<WifiNetDevice> (m_wifiPhy->GetDevice ()));

}

uint8_t

WifiRemoteStationManager::DoGetBlockAckTxNss (Mac48Address address, WifiMode blockAckMode)

{

  return 1;

}

uint8_t

WifiRemoteStationManager::DoGetBlockAckTxNess (Mac48Address address, WifiMode blockAckMode)

{

  return 0;

}

   * \param address remote address

   * \param rtsMode the transmission mode used to send an RTS we just received

   *

   * \return the transmission mode to use for the CTS to complete the RTS/CTS handshake.

   */

  WifiTxVector GetCtsTxVector (Mac48Address address, WifiMode rtsMode);

  /**

   * \param address

   * \param dataMode the transmission mode used to send an ACK we just received

   *

   * \return the transmission mode to use for the ACK to complete the data/ACK handshake.

   */

  WifiTxVector GetAckTxVector (Mac48Address address, WifiMode dataMode);

  /**

   * \param address

   * \param dataMode the transmission mode used to send an ACK we just received

   *

   * \return the transmission mode to use for the ACK to complete the data/ACK handshake.

   */

  WifiTxVector GetBlockAckTxVector (Mac48Address address, WifiMode dataMode);

  /**

  /**

   * \returns whether HT greenfield should be used for a given destination address.

   *

   * \param dest the destination address

   *

   * \return whether HT greenfield should be used for a given destination address

   */

  bool UseGreenfieldForDestination (Mac48Address dest) const;

  /**

   * \param address the address of the recipient of the CTS

   * \param ctsMode the mode to be used for the CTS

   *

   * \return the power level to be used to send the CTS

   */

  virtual uint8_t DoGetCtsTxPowerLevel (Mac48Address address, WifiMode ctsMode);

  /**

   * \param address the address of the recipient of the ACK

   * \param ackMode the mode to be used for the ACK

   *

   * \return the power level to be used to send the ACK

   */

  virtual uint8_t DoGetAckTxPowerLevel (Mac48Address address, WifiMode ackMode);

  /**

   * \param address the address of the recipient of the Block ACK

   * \param blockAckMode the mode to be used for the Block ACK

   *

   * \return the power level to be used to send the Block ACK

   */

  virtual uint8_t DoGetBlockAckTxPowerLevel (Mac48Address address, WifiMode blockAckMode);

  /**

   * \param address the address of the recipient

   * \param ctsMode the mode to be used

   *

   * \return the CTS transmit channel width

   */

  virtual uint16_t DoGetCtsTxChannelWidth (Mac48Address address, WifiMode ctsMode);

  /**

   * \param address the address of the recipient

   * \param ctsMode the mode to be used

   *

   * \return the CTS transmit guard interval

   */

  virtual uint16_t DoGetCtsTxGuardInterval (Mac48Address address, WifiMode ctsMode);

  /**

   * \param address the address of the recipient

   * \param ctsMode the mode to be used

   *

   * \return the CTS transmit NSS

   */

  virtual uint8_t DoGetCtsTxNss (Mac48Address address, WifiMode ctsMode);

  /**

   * \param address the address of the recipient

   * \param ctsMode the mode to be used

   *

   * \return the CTS transmit NESS

   */

  virtual uint8_t DoGetCtsTxNess (Mac48Address address, WifiMode ctsMode);

  /**

   * \param address the address of the recipient

   * \param ctsMode the mode to be used

   *

   * \return the ack transmit channel width

   */

  virtual uint16_t DoGetAckTxChannelWidth (Mac48Address address, WifiMode ctsMode);

  /**

   * \param address the address of the recipient

   * \param ackMode the mode to be used

   *

   * \return the ack transmit guard interval

   */

  virtual uint16_t DoGetAckTxGuardInterval (Mac48Address address, WifiMode ackMode);

  /**

   * \param address the address of the recipient

   * \param ackMode the mode to be used

   *

   * \return the ack transmit NSS

   */

  virtual uint8_t DoGetAckTxNss (Mac48Address address, WifiMode ackMode);

  /**

   * \param address the address of the recipient

   * \param ackMode the mode to be used

   *

   * \return the ack transmit NESS

   */

  virtual uint8_t DoGetAckTxNess (Mac48Address address, WifiMode ackMode);

  /**

   * \param address the address of the recipient

   * \param ctsMode the mode to be used

   *

   * \return the block ack transmit channel width

   */

  virtual uint16_t DoGetBlockAckTxChannelWidth (Mac48Address address, WifiMode ctsMode);

  /**

   * \param address the address of the recipient

   * \param blockAckMode the mode to be used

   *

   * \return the block ack transmit guard interval

   */

  virtual uint16_t DoGetBlockAckTxGuardInterval (Mac48Address address, WifiMode blockAckMode);

  /**

   * \param address the address of the recipient

   * \param blockAckMode the mode to be used

   *

   * \return the block ack transmit NSS

   */

  virtual uint8_t DoGetBlockAckTxNss (Mac48Address address, WifiMode blockAckMode);

  /**

   * \param address the address of the recipient

   * \param blockAckMode the mode to be used

   *

   * \return the block ack transmit NESS

   */

  virtual uint8_t DoGetBlockAckTxNess (Mac48Address address, WifiMode blockAckMode);

   * Get control answer mode function.

   *

   * \param reqMode request mode

   *

   * \return control answer mode

   */

  WifiMode GetControlAnswerMode (WifiMode reqMode);

  /**