inet::ieee80211::Ieee80211Mac Class Reference

Implements the IEEE 802.11 MAC. More...

#include <Ieee80211Mac.h>

Inheritance diagram for inet::ieee80211::Ieee80211Mac:

Public Member Functions
	Ieee80211Mac ()
virtual	~Ieee80211Mac ()
virtual FcsMode	getFcsMode () const
virtual const MacAddress &	getAddress () const
virtual void	sendUp (cMessage *message) override
virtual void	sendUpFrame (Packet *frame)
virtual void	sendDownFrame (Packet *frame)
virtual void	sendDownPendingRadioConfigMsg ()
virtual void	processUpperFrame (Packet *packet, const Ptr< const Ieee80211DataOrMgmtHeader > &header)
virtual void	processLowerFrame (Packet *packet, const Ptr< const Ieee80211MacHeader > &header)
Public Member Functions inherited from inet::OperationalMixin< cSimpleModule >
virtual	~OperationalMixin ()
	}@ More...
Public Member Functions inherited from inet::ILifecycle
virtual	~ILifecycle ()

Protected Member Functions
virtual int	numInitStages () const override
virtual void	initialize (int) override
virtual void	initializeRadioMode ()
virtual void	receiveSignal (cComponent *source, simsignal_t signalID, intval_t value, cObject *details) override
virtual void	configureRadioMode (physicallayer::IRadio::RadioMode radioMode)
virtual void	configureNetworkInterface () override
virtual const MacAddress &	isInterfaceRegistered ()
virtual void	handleMessageWhenUp (cMessage *message) override
virtual void	handleUpperCommand (cMessage *msg) override
	Handle commands (msg kind+control info) coming from upper layers. More...
virtual void	handleSelfMessage (cMessage *msg) override
	Handle timer self messages. More...
virtual void	handleMgmtPacket (Packet *packet)
	Handle packets from management. More...
virtual void	handleUpperPacket (Packet *packet) override
	Handle messages from upper layer. More...
virtual void	handleLowerPacket (Packet *packet) override
	Handle messages from lower (physical) layer. More...
virtual void	handleStartOperation (LifecycleOperation *operation) override
virtual void	handleStopOperation (LifecycleOperation *operation) override
virtual void	handleCrashOperation (LifecycleOperation *operation) override
virtual void	encapsulate (Packet *packet)
virtual void	decapsulate (Packet *packet)
virtual void	receiveSignal (cComponent *source, simsignal_t signalID, cObject *obj, cObject *details) override
Protected Member Functions inherited from inet::MacProtocolBase
	MacProtocolBase ()
virtual	~MacProtocolBase ()
virtual void	registerInterface ()
virtual MacAddress	parseMacAddressParameter (const char *addrstr)
virtual void	deleteCurrentTxFrame ()
virtual void	dropCurrentTxFrame (PacketDropDetails &details)
virtual void	handleMessageWhenDown (cMessage *msg) override
virtual void	sendDown (cMessage *message)
virtual bool	isUpperMessage (cMessage *message) const override
virtual bool	isLowerMessage (cMessage *message) const override
virtual bool	isInitializeStage (int stage) const override
virtual bool	isModuleStartStage (int stage) const override
virtual bool	isModuleStopStage (int stage) const override
virtual void	flushQueue (PacketDropDetails &details)
	should clear queue and emit signal "packetDropped" with entire packets More...
virtual void	clearQueue ()
	should clear queue silently More...
virtual void	receiveSignal (cComponent *source, simsignal_t signalID, cObject *obj, cObject *details) override
queueing::IPacketQueue *	getQueue (cGate *gate) const
virtual bool	canDequeuePacket () const
virtual Packet *	dequeuePacket ()
Protected Member Functions inherited from inet::LayeredProtocolBase
virtual void	handleUpperMessage (cMessage *message)
virtual void	handleLowerMessage (cMessage *message)
virtual void	handleLowerCommand (cMessage *message)
Protected Member Functions inherited from inet::OperationalMixin< cSimpleModule >
virtual int	numInitStages () const override
virtual void	refreshDisplay () const override
virtual void	handleMessage (cMessage *msg) override
virtual bool	handleOperationStage (LifecycleOperation *operation, IDoneCallback *doneCallback) override
	Perform one stage of a lifecycle operation. More...
virtual State	getInitialOperationalState () const
	Returns initial operational state: OPERATING or NOT_OPERATING. More...
virtual void	handleActiveOperationTimeout (cMessage *message)
virtual bool	isUp () const
	utility functions More...
virtual bool	isDown () const
virtual void	setOperationalState (State newState)
virtual void	scheduleOperationTimeout (simtime_t timeout)
virtual void	setupActiveOperation (LifecycleOperation *operation, IDoneCallback *doneCallback, State)
virtual void	delayActiveOperationFinish (simtime_t timeout)
virtual void	startActiveOperationExtraTime (simtime_t delay=SIMTIME_ZERO)
virtual void	startActiveOperationExtraTimeOrFinish (simtime_t extraTime)
virtual void	finishActiveOperation ()

Protected Attributes
FcsMode	fcsMode
ModuleRefByPar< Ieee80211Mib >	mib
opp_component_ptr< IIeee80211Llc >	llc
opp_component_ptr< IDs >	ds
opp_component_ptr< IRx >	rx
opp_component_ptr< ITx >	tx
opp_component_ptr< physicallayer::IRadio >	radio
const physicallayer::Ieee80211ModeSet *	modeSet = nullptr
physicallayer::IRadio::TransmissionState	transmissionState = physicallayer::IRadio::TransmissionState::TRANSMISSION_STATE_UNDEFINED
opp_component_ptr< Dcf >	dcf
opp_component_ptr< Pcf >	pcf
opp_component_ptr< Hcf >	hcf
opp_component_ptr< Mcf >	mcf
cMessage *	pendingRadioConfigMsg = nullptr
Protected Attributes inherited from inet::MacProtocolBase
int	upperLayerInGateId = -1
	Gate ids. More...
int	upperLayerOutGateId = -1
int	lowerLayerInGateId = -1
int	lowerLayerOutGateId = -1
opp_component_ptr< NetworkInterface >	networkInterface
opp_component_ptr< cModule >	hostModule
Packet *	currentTxFrame = nullptr
	Currently transmitted frame if any. More...
opp_component_ptr< queueing::IPacketQueue >	txQueue
	Messages received from upper layer and to be transmitted later. More...
Protected Attributes inherited from inet::OperationalMixin< cSimpleModule >
State	operationalState
simtime_t	lastChange
Operation	activeOperation
cMessage *	activeOperationTimeout
cMessage *	activeOperationExtraTimer

Additional Inherited Members
Protected Types inherited from inet::OperationalMixin< cSimpleModule >
enum	State

Detailed Description

Implements the IEEE 802.11 MAC.

The features, standards compliance and exact operation of the MAC depend on the plugged-in components (see IUpperMac, IRx, ITx, IContention and other interface classes).

Constructor & Destructor Documentation

Ieee80211Mac()

inet::ieee80211::Ieee80211Mac::Ieee80211Mac

(

)

{
}

~Ieee80211Mac()

inet::ieee80211::Ieee80211Mac::~Ieee80211Mac ( )

virtual

{
    if (pendingRadioConfigMsg)
        delete pendingRadioConfigMsg;
}

Member Function Documentation

configureNetworkInterface()

void inet::ieee80211::Ieee80211Mac::configureNetworkInterface ( )

overrideprotectedvirtual

Implements inet::MacProtocolBase.

{
    // TODO the mib module should use the mac address from NetworkInterface
    mib->address = networkInterface->getMacAddress();
    networkInterface->setMtu(par("mtu"));
    // capabilities
    networkInterface->setBroadcast(true);
    networkInterface->setMulticast(true);
    networkInterface->setPointToPoint(false);
}

configureRadioMode()

void inet::ieee80211::Ieee80211Mac::configureRadioMode ( physicallayer::IRadio::RadioMode  radioMode )

protectedvirtual

{
    if (radio->getRadioMode() != radioMode) {
        ConfigureRadioCommand *configureCommand = new ConfigureRadioCommand();
        configureCommand->setRadioMode(radioMode);
        auto request = new Request("configureRadioMode", RADIO_C_CONFIGURE);
        request->setControlInfo(configureCommand);
        sendDown(request);
    }
}

decapsulate()

void inet::ieee80211::Ieee80211Mac::decapsulate ( Packet *  packet )

protectedvirtual

{
    const auto& header = packet->popAtFront<Ieee80211DataOrMgmtHeader>();
    auto packetProtocolTag = packet->addTagIfAbsent<PacketProtocolTag>();
    if (dynamicPtrCast<const Ieee80211DataHeader>(header))
        packetProtocolTag->setProtocol(llc->getProtocol());
    else if (dynamicPtrCast<const Ieee80211MgmtHeader>(header))
        packetProtocolTag->setProtocol(&Protocol::ieee80211Mgmt);
    auto macAddressInd = packet->addTagIfAbsent<MacAddressInd>();
    if (mib->mode == Ieee80211Mib::INDEPENDENT) {
        macAddressInd->setSrcAddress(header->getTransmitterAddress());
        macAddressInd->setDestAddress(header->getReceiverAddress());
    }
    else if (mib->mode == Ieee80211Mib::INFRASTRUCTURE) {
        if (mib->bssStationData.stationType == Ieee80211Mib::ACCESS_POINT) {
            macAddressInd->setSrcAddress(header->getTransmitterAddress());
            macAddressInd->setDestAddress(header->getAddress3());
        }
        else if (mib->bssStationData.stationType == Ieee80211Mib::STATION) {
            macAddressInd->setSrcAddress(header->getAddress3());
            macAddressInd->setDestAddress(header->getReceiverAddress());
        }
        else
            throw cRuntimeError("Unknown station type");
    }
    else
        throw cRuntimeError("Unknown mode");
    if (header->getType() == ST_DATA_WITH_QOS) {
        auto dataHeader = dynamicPtrCast<const Ieee80211DataHeader>(header);
        int tid = dataHeader->getTid();
        if (tid < 8)
            packet->addTagIfAbsent<UserPriorityInd>()->setUserPriority(tid);
    }
    packet->addTagIfAbsent<InterfaceInd>()->setInterfaceId(networkInterface->getInterfaceId());
    packet->popAtBack<Ieee80211MacTrailer>(B(4));
}

encapsulate()

void inet::ieee80211::Ieee80211Mac::encapsulate ( Packet *  packet )

protectedvirtual

{
    auto macAddressReq = packet->getTag<MacAddressReq>();
    auto destAddress = macAddressReq->getDestAddress();
    const auto& header = makeShared<Ieee80211DataHeader>();
    header->setTransmitterAddress(mib->address);
    if (mib->mode == Ieee80211Mib::INDEPENDENT)
        header->setReceiverAddress(destAddress);
    else if (mib->mode == Ieee80211Mib::INFRASTRUCTURE) {
        if (mib->bssStationData.stationType == Ieee80211Mib::ACCESS_POINT) {
            header->setFromDS(true);
            header->setAddress3(mib->address);
            header->setReceiverAddress(destAddress);
        }
        else if (mib->bssStationData.stationType == Ieee80211Mib::STATION) {
            header->setToDS(true);
            header->setReceiverAddress(mib->bssData.bssid);
            header->setAddress3(destAddress);
        }
        else
            throw cRuntimeError("Unknown station type");
    }
    else
        throw cRuntimeError("Unknown mode");
    if (auto userPriorityReq = packet->findTag<UserPriorityReq>()) {
        // make it a QoS frame, and set TID
        header->setType(ST_DATA_WITH_QOS);
        header->addChunkLength(QOSCONTROL_PART_LENGTH);
        header->setTid(userPriorityReq->getUserPriority());
    }
    packet->insertAtFront(header);
    packet->insertAtBack(makeShared<Ieee80211MacTrailer>());
    auto packetProtocolTag = packet->addTagIfAbsent<PacketProtocolTag>();
    packetProtocolTag->setProtocol(&Protocol::ieee80211Mac);
}

getAddress()

virtual const MacAddress& inet::ieee80211::Ieee80211Mac::getAddress ( ) const

inlinevirtual

{ return mib->address; }

Referenced by inet::ieee80211::Tx::transmitFrame().

getFcsMode()

virtual FcsMode inet::ieee80211::Ieee80211Mac::getFcsMode ( ) const

inlinevirtual

{ return fcsMode; }

Referenced by inet::ieee80211::Tx::transmitFrame().

handleCrashOperation()

void inet::ieee80211::Ieee80211Mac::handleCrashOperation ( LifecycleOperation *  operation )

overrideprotectedvirtual

Reimplemented from inet::MacProtocolBase.

{
}

handleLowerPacket()

void inet::ieee80211::Ieee80211Mac::handleLowerPacket ( Packet *  packet )

overrideprotectedvirtual

Handle messages from lower (physical) layer.

Reimplemented from inet::LayeredProtocolBase.

{
    if (rx->lowerFrameReceived(packet)) {
        auto header = packet->peekAtFront<Ieee80211MacHeader>();
        processLowerFrame(packet, header);
    }
    else { // corrupted frame received
        if (mib->qos)
            hcf->corruptedFrameReceived();
        else
            dcf->corruptedFrameReceived();
    }
}

handleMessageWhenUp()

void inet::ieee80211::Ieee80211Mac::handleMessageWhenUp ( cMessage *  message )

overrideprotectedvirtual

Reimplemented from inet::LayeredProtocolBase.

{
    if (message->arrivedOn("mgmtIn")) {
        if (!message->isPacket())
            handleUpperCommand(message);
        else
            handleMgmtPacket(check_and_cast<Packet *>(message));
    }
    else
        LayeredProtocolBase::handleMessageWhenUp(message);
}

handleMgmtPacket()

void inet::ieee80211::Ieee80211Mac::handleMgmtPacket ( Packet *  packet )

protectedvirtual

Handle packets from management.

{
    const auto& header = makeShared<Ieee80211MgmtHeader>();
    header->setType((Ieee80211FrameType)packet->getTag<Ieee80211SubtypeReq>()->getSubtype());
    header->setReceiverAddress(packet->getTag<MacAddressReq>()->getDestAddress());
    if (mib->mode == Ieee80211Mib::INFRASTRUCTURE && mib->bssStationData.stationType == Ieee80211Mib::ACCESS_POINT)
        header->setAddress3(mib->bssData.bssid);
    packet->insertAtFront(header);
    packet->insertAtBack(makeShared<Ieee80211MacTrailer>());
    processUpperFrame(packet, header);
}

handleSelfMessage()

void inet::ieee80211::Ieee80211Mac::handleSelfMessage ( cMessage *  msg )

overrideprotectedvirtual

Handle timer self messages.

Reimplemented from inet::LayeredProtocolBase.

{
    ASSERT(false);
}

handleStartOperation()

void inet::ieee80211::Ieee80211Mac::handleStartOperation ( LifecycleOperation *  operation )

overrideprotectedvirtual

Reimplemented from inet::MacProtocolBase.

{
    if (!operation)
        return; // do nothing when called from initialize()
 
    initializeRadioMode();
}

handleStopOperation()

void inet::ieee80211::Ieee80211Mac::handleStopOperation ( LifecycleOperation *  operation )

overrideprotectedvirtual

Reimplemented from inet::MacProtocolBase.

{
}

handleUpperCommand()

void inet::ieee80211::Ieee80211Mac::handleUpperCommand ( cMessage *  msg )

overrideprotectedvirtual

Handle commands (msg kind+control info) coming from upper layers.

Reimplemented from inet::LayeredProtocolBase.

{
    if (msg->getKind() == RADIO_C_CONFIGURE) {
        EV_DEBUG << "Passing on command " << msg->getName() << " to physical layer\n";
        if (pendingRadioConfigMsg != nullptr) {
            // merge contents of the old command into the new one, then delete it
            Ieee80211ConfigureRadioCommand *oldConfigureCommand = check_and_cast<Ieee80211ConfigureRadioCommand *>(pendingRadioConfigMsg->getControlInfo());
            Ieee80211ConfigureRadioCommand *newConfigureCommand = check_and_cast<Ieee80211ConfigureRadioCommand *>(msg->getControlInfo());
            if (newConfigureCommand->getChannelNumber() == -1 && oldConfigureCommand->getChannelNumber() != -1)
                newConfigureCommand->setChannelNumber(oldConfigureCommand->getChannelNumber());
            if (std::isnan(newConfigureCommand->getBitrate().get()) && !std::isnan(oldConfigureCommand->getBitrate().get()))
                newConfigureCommand->setBitrate(oldConfigureCommand->getBitrate());
            delete pendingRadioConfigMsg;
            pendingRadioConfigMsg = nullptr;
        }
 
        if (rx->isMediumFree()) { // TODO this should be just the physical channel sense!!!!
            EV_DEBUG << "Sending it down immediately\n";
//            PhyControlInfo *phyControlInfo = dynamic_cast<PhyControlInfo *>(msg->getControlInfo());
//            if (phyControlInfo)
//                phyControlInfo->setAdaptiveSensitivity(true);
            // end dynamic power
            sendDown(msg);
        }
        else {
            // TODO waiting potentially indefinitely?! wtf?!
            EV_DEBUG << "Delaying " << msg->getName() << " until next IDLE or DEFER state\n";
            pendingRadioConfigMsg = msg;
        }
    }
    else {
        throw cRuntimeError("Unrecognized command from mgmt layer: (%s)%s msgkind=%d", msg->getClassName(), msg->getName(), msg->getKind());
    }
}

handleUpperPacket()

void inet::ieee80211::Ieee80211Mac::handleUpperPacket ( Packet *  packet )

overrideprotectedvirtual

Handle messages from upper layer.

Reimplemented from inet::LayeredProtocolBase.

{
    if (mib->mode == Ieee80211Mib::INFRASTRUCTURE && mib->bssStationData.stationType == Ieee80211Mib::STATION && !mib->bssStationData.isAssociated) {
        EV << "STA is not associated with an access point, discarding packet " << packet << "\n";
        PacketDropDetails details;
        details.setReason(OTHER_PACKET_DROP);
        emit(packetDroppedSignal, packet, &details);
        delete packet;
        return;
    }
    encapsulate(packet);
    const auto& header = packet->peekAtFront<Ieee80211DataOrMgmtHeader>();
    if (mib->mode == Ieee80211Mib::INFRASTRUCTURE && mib->bssStationData.stationType == Ieee80211Mib::ACCESS_POINT) {
        auto receiverAddress = header->getReceiverAddress();
        if (!receiverAddress.isMulticast()) {
            auto it = mib->bssAccessPointData.stations.find(receiverAddress);
            if (it == mib->bssAccessPointData.stations.end() || it->second != Ieee80211Mib::ASSOCIATED) {
                EV << "STA with MAC address " << receiverAddress << " not associated with this AP, dropping frame\n";
                PacketDropDetails details;
                details.setReason(OTHER_PACKET_DROP);
                emit(packetDroppedSignal, packet, &details);
                delete packet;
                return;
            }
        }
    }
    processUpperFrame(packet, header);
}

initialize()

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

overrideprotectedvirtual

Reimplemented from inet::MacProtocolBase.

{
    MacProtocolBase::initialize(stage);
    if (stage == INITSTAGE_LOCAL) {
        modeSet = Ieee80211ModeSet::getModeSet(par("modeSet"));
        fcsMode = parseFcsMode(par("fcsMode"));
        mib.reference(this, "mibModule", true);
        mib->qos = par("qosStation");
    }
    else if (stage == INITSTAGE_LINK_LAYER) {
        cModule *llcModule = gate("upperLayerOut")->getNextGate()->getOwnerModule();
        llc = check_and_cast<IIeee80211Llc *>(llcModule);
        cModule *radioModule = gate("lowerLayerOut")->getNextGate()->getOwnerModule();
        radioModule->subscribe(IRadio::radioModeChangedSignal, this);
        radioModule->subscribe(IRadio::receptionStateChangedSignal, this);
        radioModule->subscribe(IRadio::transmissionStateChangedSignal, this);
        radioModule->subscribe(IRadio::receivedSignalPartChangedSignal, this);
        radio = check_and_cast<IRadio *>(radioModule);
        ds = check_and_cast<IDs *>(getSubmodule("ds"));
        rx = check_and_cast<IRx *>(getSubmodule("rx"));
        tx = check_and_cast<ITx *>(getSubmodule("tx"));
        emit(modesetChangedSignal, modeSet);
        if (isUp())
            initializeRadioMode();
        rx = check_and_cast<IRx *>(getSubmodule("rx"));
        tx = check_and_cast<ITx *>(getSubmodule("tx"));
        dcf = check_and_cast<Dcf *>(getSubmodule("dcf"));
        hcf = check_and_cast_nullable<Hcf *>(getSubmodule("hcf"));
        if (mib->qos && !hcf)
            throw cRuntimeError("Missing hcf module, required for QoS");
    }
}

initializeRadioMode()

void inet::ieee80211::Ieee80211Mac::initializeRadioMode ( )

protectedvirtual

                                       {
    const char *initialRadioMode = par("initialRadioMode");
    if (!strcmp(initialRadioMode, "off"))
        radio->setRadioMode(IRadio::RADIO_MODE_OFF);
    else if (!strcmp(initialRadioMode, "sleep"))
        radio->setRadioMode(IRadio::RADIO_MODE_SLEEP);
    else if (!strcmp(initialRadioMode, "receiver"))
        radio->setRadioMode(IRadio::RADIO_MODE_RECEIVER);
    else if (!strcmp(initialRadioMode, "transmitter"))
        radio->setRadioMode(IRadio::RADIO_MODE_TRANSMITTER);
    else if (!strcmp(initialRadioMode, "transceiver"))
        radio->setRadioMode(IRadio::RADIO_MODE_TRANSCEIVER);
    else
        throw cRuntimeError("Unknown initialRadioMode");
}

isInterfaceRegistered()

const MacAddress & inet::ieee80211::Ieee80211Mac::isInterfaceRegistered ( )

protectedvirtual

{
//    if (!par("multiMac"))
//        return MacAddress::UNSPECIFIED_ADDRESS;
    IInterfaceTable *ift = findModuleFromPar<IInterfaceTable>(par("interfaceTableModule"), this);
    if (!ift)
        return MacAddress::UNSPECIFIED_ADDRESS;
    cModule *interfaceModule = findModuleUnderContainingNode(this);
    if (!interfaceModule)
        throw cRuntimeError("NIC module not found in the host");
    std::string interfaceName = utils::stripnonalnum(interfaceModule->getFullName());
    NetworkInterface *e = ift->findInterfaceByName(interfaceName.c_str());
    if (e)
        return e->getMacAddress();
    return MacAddress::UNSPECIFIED_ADDRESS;
}

numInitStages()

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

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

processLowerFrame()

void inet::ieee80211::Ieee80211Mac::processLowerFrame ( Packet *  packet, const Ptr< const Ieee80211MacHeader > &  header  )

virtual

{
    Enter_Method("processLowerFrame(\"%s\")", packet->getName());
    take(packet);
    if (mib->qos)
        hcf->processLowerFrame(packet, header);
    else
        // TODO what if the received frame is ST_DATA_WITH_QOS? drop?
        dcf->processLowerFrame(packet, header);
}

processUpperFrame()

void inet::ieee80211::Ieee80211Mac::processUpperFrame ( Packet *  packet, const Ptr< const Ieee80211DataOrMgmtHeader > &  header  )

virtual

{
    Enter_Method("processUpperFrame(\"%s\")", packet->getName());
    take(packet);
    EV_INFO << "Frame " << packet << " received from higher layer, receiver = " << header->getReceiverAddress() << "\n";
    ASSERT(!header->getReceiverAddress().isUnspecified());
    if (mib->qos)
        hcf->processUpperFrame(packet, header);
    else
        dcf->processUpperFrame(packet, header);
}

Referenced by inet::ieee80211::Ds::distributeDataFrame().

receiveSignal() [1/2]

void inet::MacProtocolBase::receiveSignal

overrideprotected

{
    Enter_Method("%s", cComponent::getSignalName(signalID));
}

receiveSignal() [2/2]

void inet::ieee80211::Ieee80211Mac::receiveSignal ( cComponent *  source, simsignal_t  signalID, intval_t  value, cObject *  details  )

overrideprotectedvirtual

{
    Enter_Method("%s", cComponent::getSignalName(signalID));
 
    if (signalID == IRadio::receptionStateChangedSignal) {
        rx->receptionStateChanged(static_cast<IRadio::ReceptionState>(value));
    }
    else if (signalID == IRadio::transmissionStateChangedSignal) {
        auto oldTransmissionState = transmissionState;
        transmissionState = static_cast<IRadio::TransmissionState>(value);
        bool transmissionFinished = (oldTransmissionState == IRadio::TRANSMISSION_STATE_TRANSMITTING && transmissionState == IRadio::TRANSMISSION_STATE_IDLE);
        if (transmissionFinished) {
            tx->radioTransmissionFinished();
            EV_DEBUG << "changing radio to receiver mode\n";
            configureRadioMode(IRadio::RADIO_MODE_RECEIVER); // FIXME this is in a very wrong place!!! should be done explicitly from coordination function!
        }
        rx->transmissionStateChanged(transmissionState);
    }
    else if (signalID == IRadio::receivedSignalPartChangedSignal) {
        rx->receivedSignalPartChanged(static_cast<IRadioSignal::SignalPart>(value));
    }
}

sendDownFrame()

void inet::ieee80211::Ieee80211Mac::sendDownFrame ( Packet *  frame )

virtual

{
    Enter_Method("sendDownFrame(\"%s\")", frame->getName());
    take(frame);
    configureRadioMode(IRadio::RADIO_MODE_TRANSMITTER);
    frame->addTagIfAbsent<PacketProtocolTag>()->setProtocol(&Protocol::ieee80211Mac);
    sendDown(frame);
}

Referenced by inet::ieee80211::Tx::handleMessage(), and inet::ieee80211::Tx::transmitFrame().

sendDownPendingRadioConfigMsg()

void inet::ieee80211::Ieee80211Mac::sendDownPendingRadioConfigMsg ( )

virtual

{
    if (pendingRadioConfigMsg != nullptr) {
        sendDown(pendingRadioConfigMsg);
        pendingRadioConfigMsg = nullptr;
    }
}

Referenced by inet::ieee80211::Contention::handleWithFSM().

sendUp()

void inet::ieee80211::Ieee80211Mac::sendUp ( cMessage *  message )

overridevirtual

Reimplemented from inet::MacProtocolBase.

{
    Enter_Method("sendUp(\"%s\")", msg->getName());
    take(msg);
    MacProtocolBase::sendUp(msg);
}

Referenced by inet::ieee80211::Ds::processDataFrame().

sendUpFrame()

void inet::ieee80211::Ieee80211Mac::sendUpFrame ( Packet *  frame )

virtual

{
    Enter_Method("sendUpFrame(\"%s\")", frame->getName());
    take(frame);
    const auto& header = frame->peekAtFront<Ieee80211DataOrMgmtHeader>();
    decapsulate(frame);
    if (!(header->getType() & 0x30))
        send(frame, "mgmtOut");
    else
        ds->processDataFrame(frame, dynamicPtrCast<const Ieee80211DataHeader>(header));
}

Member Data Documentation

dcf

opp_component_ptr<Dcf> inet::ieee80211::Ieee80211Mac::dcf

protected

ds

opp_component_ptr<IDs> inet::ieee80211::Ieee80211Mac::ds

protected

fcsMode

FcsMode inet::ieee80211::Ieee80211Mac::fcsMode

protected

hcf

opp_component_ptr<Hcf> inet::ieee80211::Ieee80211Mac::hcf

protected

llc

opp_component_ptr<IIeee80211Llc> inet::ieee80211::Ieee80211Mac::llc

protected

mcf

opp_component_ptr<Mcf> inet::ieee80211::Ieee80211Mac::mcf

protected

mib

ModuleRefByPar<Ieee80211Mib> inet::ieee80211::Ieee80211Mac::mib

protected

modeSet

const physicallayer::Ieee80211ModeSet* inet::ieee80211::Ieee80211Mac::modeSet = nullptr

protected

pcf

opp_component_ptr<Pcf> inet::ieee80211::Ieee80211Mac::pcf

protected

pendingRadioConfigMsg

cMessage* inet::ieee80211::Ieee80211Mac::pendingRadioConfigMsg = nullptr

protected

radio

opp_component_ptr<physicallayer::IRadio> inet::ieee80211::Ieee80211Mac::radio

protected

rx

opp_component_ptr<IRx> inet::ieee80211::Ieee80211Mac::rx

protected

transmissionState

physicallayer::IRadio::TransmissionState inet::ieee80211::Ieee80211Mac::transmissionState = physicallayer::IRadio::TransmissionState::TRANSMISSION_STATE_UNDEFINED

protected

tx

opp_component_ptr<ITx> inet::ieee80211::Ieee80211Mac::tx

protected

---

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

• Ieee80211Mac.h
• Ieee80211Mac.cc