inet::ieee80211::Edcaf Class Reference

Implements IEEE 802.11 Enhanced Distributed Channel Access Function. More...

#include <Edcaf.h>

Inheritance diagram for inet::ieee80211::Edcaf:

Public Member Functions
virtual	~Edcaf ()
virtual StationRetryCounters *	getStationRetryCounters () const
virtual QosAckHandler *	getAckHandler () const
virtual QosRecoveryProcedure *	getRecoveryProcedure () const
virtual TxopProcedure *	getTxopProcedure () const
virtual queueing::IPacketQueue *	getPendingQueue () const
virtual InProgressFrames *	getInProgressFrames () const
virtual void	requestChannel (IChannelAccess::ICallback *callback) override
virtual void	releaseChannel (IChannelAccess::ICallback *callback) override
virtual void	channelAccessGranted () override
virtual void	expectedChannelAccess (simtime_t time) override
virtual void	incrementCw () override
virtual void	resetCw () override
virtual int	getCw () override
virtual bool	isOwning ()
virtual bool	isInternalCollision ()
virtual AccessCategory	getAccessCategory ()
Public Member Functions inherited from inet::ieee80211::IChannelAccess
virtual	~IChannelAccess ()
Public Member Functions inherited from inet::ieee80211::IContention::ICallback
	~ICallback ()
Public Member Functions inherited from inet::ieee80211::IRecoveryProcedure::ICwCalculator
virtual	~ICwCalculator ()

Protected Member Functions
virtual int	numInitStages () const override
virtual void	initialize (int stage) override
virtual void	refreshDisplay () const override
virtual void	receiveSignal (cComponent *source, simsignal_t signalID, cObject *obj, cObject *details) override
virtual AccessCategory	getAccessCategory (const char *ac)
virtual int	getAifsNumber (AccessCategory ac)
virtual int	getCwMax (AccessCategory ac, int aCwMax, int aCwMin)
virtual int	getCwMin (AccessCategory ac, int aCwMin)
virtual void	calculateTimingParameters ()

Protected Attributes
IContention *	contention = nullptr
IChannelAccess::ICallback *	callback = nullptr
IEdcaCollisionController *	collisionController = nullptr
StationRetryCounters *	stationRetryCounters = nullptr
QosAckHandler *	ackHandler = nullptr
QosRecoveryProcedure *	recoveryProcedure = nullptr
TxopProcedure *	txopProcedure = nullptr
queueing::IPacketQueue *	pendingQueue = nullptr
InProgressFrames *	inProgressFrames = nullptr
bool	owning = false
simtime_t	slotTime = -1
simtime_t	sifs = -1
simtime_t	ifs = -1
simtime_t	eifs = -1
AccessCategory	ac = AccessCategory(-1)
int	cw = -1
int	cwMin = -1
int	cwMax = -1
Protected Attributes inherited from inet::ieee80211::ModeSetListener
physicallayer::Ieee80211ModeSet *	modeSet = nullptr

Additional Inherited Members
Static Public Attributes inherited from inet::ieee80211::IChannelAccess
static simsignal_t	channelOwnershipChangedSignal = cComponent::registerSignal("channelOwnershipChanged")

Detailed Description

Implements IEEE 802.11 Enhanced Distributed Channel Access Function.

Constructor & Destructor Documentation

~Edcaf()

inet::ieee80211::Edcaf::~Edcaf ( )

virtual

{
    delete stationRetryCounters;
}

Member Function Documentation

calculateTimingParameters()

void inet::ieee80211::Edcaf::calculateTimingParameters ( )

protectedvirtual

{
    slotTime = modeSet->getSlotTime();
    sifs = modeSet->getSifsTime();
    int aifsn = par("aifsn");
    simtime_t aifs = sifs + fallback(aifsn, getAifsNumber(ac)) * slotTime;
    ifs = aifs;
    eifs = sifs + aifs + modeSet->getSlowestMandatoryMode()->getDuration(LENGTH_ACK);
    EV_DEBUG << "Timing parameters are initialized: slotTime = " << slotTime << ", sifs = " << sifs << ", ifs = " << ifs << ", eifs = " << eifs << std::endl;
    ASSERT(ifs > sifs);
    cwMin = par("cwMin");
    cwMax = par("cwMax");
    if (cwMin == -1)
        cwMin = getCwMin(ac, modeSet->getCwMin());
    if (cwMax == -1)
        cwMax = getCwMax(ac, modeSet->getCwMax(), modeSet->getCwMin());
    cw = cwMin;
    EV_DEBUG << "Contention window parameters are initialized: cw = " << cw << ", cwMin = " << cwMin << ", cwMax = " << cwMax << std::endl;
}

channelAccessGranted()

void inet::ieee80211::Edcaf::channelAccessGranted ( )

overridevirtual

Implements inet::ieee80211::IContention::ICallback.

{
    Enter_Method("channelAccessGranted");
    ASSERT(callback != nullptr);
    if (!collisionController->isInternalCollision(this)) {
        owning = true;
        emit(channelOwnershipChangedSignal, owning);
        callback->channelGranted(this);
    }
    else
        EV_WARN << "Ignoring channel access granted due to internal collision.\n";
}

expectedChannelAccess()

void inet::ieee80211::Edcaf::expectedChannelAccess ( simtime_t  time )

overridevirtual

Implements inet::ieee80211::IContention::ICallback.

{
    collisionController->expectedChannelAccess(this, time);
}

getAccessCategory() [1/2]

virtual AccessCategory inet::ieee80211::Edcaf::getAccessCategory ( )

inlinevirtual

{ return ac; }

getAccessCategory() [2/2]

AccessCategory inet::ieee80211::Edcaf::getAccessCategory ( const char *  ac )

protectedvirtual

{
    if (strcmp("AC_BK", ac) == 0)
        return AC_BK;
    if (strcmp("AC_VI", ac) == 0)
        return AC_VI;
    if (strcmp("AC_VO", ac) == 0)
        return AC_VO;
    if (strcmp("AC_BE", ac) == 0)
        return AC_BE;
    throw cRuntimeError("Unknown Access Category = %s", ac);
}

Referenced by inet::ieee80211::EdcaCollisionController::expectedChannelAccess(), and inet::ieee80211::EdcaCollisionController::isInternalCollision().

getAckHandler()

virtual QosAckHandler* inet::ieee80211::Edcaf::getAckHandler ( ) const

inlinevirtual

{ return ackHandler; }

getAifsNumber()

int inet::ieee80211::Edcaf::getAifsNumber ( AccessCategory  ac )

protectedvirtual

{
    switch (ac) {
        case AC_BK: return 7;
        case AC_BE: return 3;
        case AC_VI: return 2;
        case AC_VO: return 2;
        default: throw cRuntimeError("Unknown access category = %d", ac);
    }
}

getCw()

virtual int inet::ieee80211::Edcaf::getCw ( )

inlineoverridevirtual

Implements inet::ieee80211::IRecoveryProcedure::ICwCalculator.

{ return cw; }

getCwMax()

int inet::ieee80211::Edcaf::getCwMax ( AccessCategory  ac, int  aCwMax, int  aCwMin  )

protectedvirtual

{
    switch (ac) {
        case AC_BK: return aCwMax;
        case AC_BE: return aCwMax;
        case AC_VI: return aCwMin;
        case AC_VO: return (aCwMin + 1) / 2 - 1;
        default: throw cRuntimeError("Unknown access category = %d", ac);
    }
}

getCwMin()

int inet::ieee80211::Edcaf::getCwMin ( AccessCategory  ac, int  aCwMin  )

protectedvirtual

{
    switch (ac) {
        case AC_BK: return aCwMin;
        case AC_BE: return aCwMin;
        case AC_VI: return (aCwMin + 1) / 2 - 1;
        case AC_VO: return (aCwMin + 1) / 4 - 1;
        default: throw cRuntimeError("Unknown access category = %d", ac);
    }
}

getInProgressFrames()

virtual InProgressFrames* inet::ieee80211::Edcaf::getInProgressFrames ( ) const

inlinevirtual

{ return inProgressFrames; }

getPendingQueue()

virtual queueing::IPacketQueue* inet::ieee80211::Edcaf::getPendingQueue ( ) const

inlinevirtual

{ return pendingQueue; }

getRecoveryProcedure()

virtual QosRecoveryProcedure* inet::ieee80211::Edcaf::getRecoveryProcedure ( ) const

inlinevirtual

{ return recoveryProcedure; }

getStationRetryCounters()

virtual StationRetryCounters* inet::ieee80211::Edcaf::getStationRetryCounters ( ) const

inlinevirtual

{ return stationRetryCounters; }

getTxopProcedure()

virtual TxopProcedure* inet::ieee80211::Edcaf::getTxopProcedure ( ) const

inlinevirtual

{ return txopProcedure; }

incrementCw()

void inet::ieee80211::Edcaf::incrementCw ( )

overridevirtual

Implements inet::ieee80211::IRecoveryProcedure::ICwCalculator.

{
    Enter_Method("incrementCw");
    int newCw = 2 * cw + 1;
    if (newCw > cwMax)
        cw = cwMax;
    else
        cw = newCw;
    EV_DEBUG << "Contention window is incremented: cw = " << cw << std::endl;
}

initialize()

void inet::ieee80211::Edcaf::initialize ( int  stage )

overrideprotectedvirtual

Reimplemented from inet::ieee80211::ModeSetListener.

{
    if (stage == INITSTAGE_LOCAL) {
        getContainingNicModule(this)->subscribe(modesetChangedSignal, this);
        ac = getAccessCategory(par("accessCategory"));
        contention = check_and_cast<IContention *>(getSubmodule("contention"));
        collisionController = check_and_cast<IEdcaCollisionController *>(getModuleByPath(par("collisionControllerModule")));
        pendingQueue = check_and_cast<queueing::IPacketQueue *>(getSubmodule("pendingQueue"));
        recoveryProcedure = check_and_cast<QosRecoveryProcedure *>(getSubmodule("recoveryProcedure"));
        ackHandler = check_and_cast<QosAckHandler *>(getSubmodule("ackHandler"));
        inProgressFrames = check_and_cast<InProgressFrames *>(getSubmodule("inProgressFrames"));
        txopProcedure = check_and_cast<TxopProcedure *>(getSubmodule("txopProcedure"));
        stationRetryCounters = new StationRetryCounters();
        WATCH(owning);
        WATCH(slotTime);
        WATCH(sifs);
        WATCH(ifs);
        WATCH(eifs);
        WATCH(ac);
        WATCH(cw);
        WATCH(cwMin);
        WATCH(cwMax);
    }
    else if (stage == INITSTAGE_LINK_LAYER) {
        auto rx = check_and_cast<IRx *>(getModuleByPath(par("rxModule")));
        rx->registerContention(contention);
        calculateTimingParameters();
    }
}

isInternalCollision()

bool inet::ieee80211::Edcaf::isInternalCollision ( )

virtual

{
    return collisionController->isInternalCollision(this);
}

isOwning()

virtual bool inet::ieee80211::Edcaf::isOwning ( )

inlinevirtual

{ return owning; }

numInitStages()

virtual int inet::ieee80211::Edcaf::numInitStages ( ) const

inlineoverrideprotectedvirtual

Reimplemented from inet::ieee80211::ModeSetListener.

{ return NUM_INIT_STAGES; }

receiveSignal()

void inet::ieee80211::Edcaf::receiveSignal ( cComponent *  source, simsignal_t  signalID, cObject *  obj, cObject *  details  )

overrideprotectedvirtual

Reimplemented from inet::ieee80211::ModeSetListener.

{
    Enter_Method("%s", cComponent::getSignalName(signalID));
 
    if (signalID == modesetChangedSignal) {
        modeSet = check_and_cast<Ieee80211ModeSet *>(obj);
        calculateTimingParameters();
    }
}

refreshDisplay()

void inet::ieee80211::Edcaf::refreshDisplay ( ) const

overrideprotectedvirtual

{
    std::string text(printAccessCategory(ac));
    if (owning)
        text += "\nOwning";
    else if (contention->isContentionInProgress())
        text += "\nContending";
    else
        text += "\nIdle";
    getDisplayString().setTagArg("t", 0, text.c_str());
}

releaseChannel()

void inet::ieee80211::Edcaf::releaseChannel ( IChannelAccess::ICallback *  callback )

overridevirtual

Implements inet::ieee80211::IChannelAccess.

{
    Enter_Method("releaseChannel");
    ASSERT(owning);
    owning = false;
    emit(channelOwnershipChangedSignal, owning);
    this->callback = nullptr;
    EV_INFO << "Channel released.\n";
}

Referenced by inet::ieee80211::Edca::releaseChannelAccess().

requestChannel()

void inet::ieee80211::Edcaf::requestChannel ( IChannelAccess::ICallback *  callback )

overridevirtual

Implements inet::ieee80211::IChannelAccess.

{
    Enter_Method("requestChannel");
    this->callback = callback;
    ASSERT(!owning);
    if (contention->isContentionInProgress())
        EV_DEBUG << "Contention has been already started.\n";
    else
        contention->startContention(cw, ifs, eifs, slotTime, this);
}

Referenced by inet::ieee80211::Edca::requestChannelAccess().

resetCw()

void inet::ieee80211::Edcaf::resetCw ( )

overridevirtual

Implements inet::ieee80211::IRecoveryProcedure::ICwCalculator.

{
    Enter_Method("resetCw");
    cw = cwMin;
    EV_DEBUG << "Contention window is reset: cw = " << cw << std::endl;
}

Member Data Documentation

ac

AccessCategory inet::ieee80211::Edcaf::ac = AccessCategory(-1)

protected

ackHandler

QosAckHandler* inet::ieee80211::Edcaf::ackHandler = nullptr

protected

callback

IChannelAccess::ICallback* inet::ieee80211::Edcaf::callback = nullptr

protected

collisionController

IEdcaCollisionController* inet::ieee80211::Edcaf::collisionController = nullptr

protected

contention

IContention* inet::ieee80211::Edcaf::contention = nullptr

protected

cw

int inet::ieee80211::Edcaf::cw = -1

protected

cwMax

int inet::ieee80211::Edcaf::cwMax = -1

protected

cwMin

int inet::ieee80211::Edcaf::cwMin = -1

protected

eifs

simtime_t inet::ieee80211::Edcaf::eifs = -1

protected

ifs

simtime_t inet::ieee80211::Edcaf::ifs = -1

protected

inProgressFrames

InProgressFrames* inet::ieee80211::Edcaf::inProgressFrames = nullptr

protected

owning

bool inet::ieee80211::Edcaf::owning = false

protected

pendingQueue

queueing::IPacketQueue* inet::ieee80211::Edcaf::pendingQueue = nullptr

protected

recoveryProcedure

QosRecoveryProcedure* inet::ieee80211::Edcaf::recoveryProcedure = nullptr

protected

sifs

simtime_t inet::ieee80211::Edcaf::sifs = -1

protected

slotTime

simtime_t inet::ieee80211::Edcaf::slotTime = -1

protected

stationRetryCounters

StationRetryCounters* inet::ieee80211::Edcaf::stationRetryCounters = nullptr

protected

txopProcedure

TxopProcedure* inet::ieee80211::Edcaf::txopProcedure = nullptr

protected

---

The documentation for this class was generated from the following files:

• Edcaf.h
• Edcaf.cc