F5/unison
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

wifi: Move GetControlAnswerMode to MacLow

Browse Source
This commit is contained in:
Sébastien Deronne
2018-11-18 09:17:14 +01:00
parent e05d210f67
commit f557381d8b
4 changed files with 191 additions and 429 deletions
Download Patch File Download Diff File Expand all files Collapse all files

178
src/wifi/model/mac-low.cc
View File

@@ -1145,22 +1145,194 @@ MacLow::GetDataTxVector (Ptr<const Packet> packet, const WifiMacHeader *hdr) con
return m_stationManager->GetDataTxVector (to, hdr, packet);
}
WifiMode
MacLow::GetControlAnswerMode (WifiMode reqMode) const
{
/**
* 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 = m_stationManager->GetDefaultMode ();
bool found = false;
//First, search the BSS Basic Rate set
for (uint8_t i = 0; i < m_stationManager->GetNBasicModes (); i++)
{
WifiMode testMode = m_stationManager->GetBasicMode (i);
if ((!found || testMode.IsHigherDataRate (mode))
&& (!testMode.IsHigherDataRate (reqMode))
&& (IsAllowedControlAnswerModulationClass (reqMode.GetModulationClass (), testMode.GetModulationClass ())))
{
mode = testMode;
//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 (m_stationManager->GetHtSupported () || m_stationManager->GetVhtSupported () || m_stationManager->GetHeSupported ())
{
if (!found)
{
mode = m_stationManager->GetDefaultMcs ();
for (uint8_t i = 0; i != m_stationManager->GetNBasicMcs (); i++)
{
WifiMode testMode = m_stationManager->GetBasicMcs (i);
if ((!found || testMode.IsHigherDataRate (mode))
&& (!testMode.IsHigherDataRate (reqMode))
&& (testMode.GetModulationClass () == reqMode.GetModulationClass ()))
{
mode = testMode;
//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 ("MacLow::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_phy->GetNModes (); idx++)
{
WifiMode thismode = m_phy->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 (m_stationManager->GetHtSupported () || m_stationManager->GetVhtSupported () || m_stationManager->GetHeSupported ())
{
for (uint8_t idx = 0; idx < m_phy->GetNMcs (); idx++)
{
WifiMode thismode = m_phy->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.
*
* 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 ("MacLow::GetControlAnswerMode returning " << mode);
return mode;
}
WifiTxVector
MacLow::GetCtsTxVector (Mac48Address to, WifiMode rtsTxMode) const
{
return m_stationManager->GetCtsTxVector (to, rtsTxMode);
NS_ASSERT (!to.IsGroup ());
WifiMode ctsMode = GetControlAnswerMode (rtsTxMode);
WifiTxVector v;
v.SetMode (ctsMode);
v.SetPreambleType (GetPreambleForTransmission (ctsMode.GetModulationClass (), m_stationManager->GetShortPreambleEnabled (), m_stationManager->UseGreenfieldForDestination (to)));
v.SetTxPowerLevel (m_stationManager->GetDefaultTxPowerLevel ());
v.SetChannelWidth (GetChannelWidthForTransmission (ctsMode, m_phy->GetChannelWidth ()));
uint16_t ctsTxGuardInterval = ConvertGuardIntervalToNanoSeconds (ctsMode, m_phy->GetShortGuardInterval (), m_phy->GetGuardInterval ());
v.SetGuardInterval (ctsTxGuardInterval);
v.SetNss (1);
return v;
}
WifiTxVector
MacLow::GetAckTxVector (Mac48Address to, WifiMode dataTxMode) const
{
return m_stationManager->GetAckTxVector (to, dataTxMode);
NS_ASSERT (!to.IsGroup ());
WifiMode ackMode = GetControlAnswerMode (dataTxMode);
WifiTxVector v;
v.SetMode (ackMode);
v.SetPreambleType (GetPreambleForTransmission (ackMode.GetModulationClass (), m_stationManager->GetShortPreambleEnabled (), m_stationManager->UseGreenfieldForDestination (to)));
v.SetTxPowerLevel (m_stationManager->GetDefaultTxPowerLevel ());
v.SetChannelWidth (GetChannelWidthForTransmission (ackMode, m_phy->GetChannelWidth ()));
uint16_t ackTxGuardInterval = ConvertGuardIntervalToNanoSeconds (ackMode, m_phy->GetShortGuardInterval (), m_phy->GetGuardInterval ());
v.SetGuardInterval (ackTxGuardInterval);
v.SetNss (1);
return v;
}
WifiTxVector
MacLow::GetBlockAckTxVector (Mac48Address to, WifiMode dataTxMode) const
{
return m_stationManager->GetBlockAckTxVector (to, dataTxMode);
NS_ASSERT (!to.IsGroup ());
WifiMode blockAckMode = GetControlAnswerMode (dataTxMode);
WifiTxVector v;
v.SetMode (blockAckMode);
v.SetPreambleType (GetPreambleForTransmission (blockAckMode.GetModulationClass (), m_stationManager->GetShortPreambleEnabled (), m_stationManager->UseGreenfieldForDestination (to)));
v.SetTxPowerLevel (m_stationManager->GetDefaultTxPowerLevel ());
v.SetChannelWidth (GetChannelWidthForTransmission (blockAckMode, m_phy->GetChannelWidth ()));
uint16_t blockAckTxGuardInterval = ConvertGuardIntervalToNanoSeconds (blockAckMode, m_phy->GetShortGuardInterval (), m_phy->GetGuardInterval ());
v.SetGuardInterval (blockAckTxGuardInterval);
v.SetNss (1);
return v;
}
WifiTxVector

8
src/wifi/model/mac-low.h
View File

@@ -541,6 +541,14 @@ private:
* \return TXVECTOR for the Block ACK
*/
WifiTxVector GetAckTxVectorForData (Mac48Address to, WifiMode dataTxMode) const;
/**
* Get control answer mode function.
*
* \param reqMode request mode
*
* \return control answer mode
*/
WifiMode GetControlAnswerMode (WifiMode reqMode) const;
/**
* Return the time required to transmit the CTS (including preamble and FCS).
*

282
src/wifi/model/wifi-remote-station-manager.cc
View File

@@ -1055,288 +1055,6 @@ WifiRemoteStationManager::IsLastFragment (Mac48Address address, const WifiMacHea
return isLast;
}
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;
}
uint8_t
WifiRemoteStationManager::GetDefaultTxPowerLevel (void) const
{

152
src/wifi/model/wifi-remote-station-manager.h
View File

@@ -848,27 +848,6 @@ public:
bool IsLastFragment (Mac48Address address, const WifiMacHeader *header,
Ptr<const Packet> packet, uint32_t fragmentNumber);
/**
* \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);
/**
* \return the default transmission power
*/
@@ -893,6 +872,14 @@ public:
* \return the maximum number of spatial streams supported by the phy layer
*/
uint8_t GetMaxNumberOfTransmitStreams (void) const;
/**
* \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;
/**
* TracedCallback signature for power change events.
@@ -1071,14 +1058,6 @@ protected:
* \return the number of Ness the station has
*/
uint8_t GetNess (const WifiRemoteStation *station) const;
/**
* \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;
/**
* Return the WifiPhy.
@@ -1163,112 +1142,6 @@ private:
* to decide which transmission mode to use for the rts.
*/
virtual WifiTxVector DoGetRtsTxVector (WifiRemoteStation *station) = 0;
/**
* \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);
/**
* This method is a pure virtual method that must be implemented by the sub-class.
@@ -1373,15 +1246,6 @@ private:
*/
WifiRemoteStation* Lookup (Mac48Address address, const WifiMacHeader *header) const;
/**
* Get control answer mode function.
*
* \param reqMode request mode
*
* \return control answer mode
*/
WifiMode GetControlAnswerMode (WifiMode reqMode);
/**
* Actually sets the fragmentation threshold, it also checks the validity of
* the given threshold.