inet::Ieee802154Mac Class Reference

Generic CSMA Mac-Layer. More...

#include <Ieee802154Mac.h>

Inheritance diagram for inet::Ieee802154Mac:

Public Member Functions
	Ieee802154Mac ()
virtual	~Ieee802154Mac ()
virtual void	initialize (int) override
	Initialization of the module and some variables. More...
virtual void	finish () override
	Delete all dynamically allocated objects of the module. More...
virtual void	handleLowerPacket (Packet *packet) override
	Handle messages from lower layer. More...
virtual void	handleUpperPacket (Packet *packet) override
	Handle messages from upper layer. More...
virtual void	handleSelfMessage (cMessage *) override
	Handle self messages such as timers. More...
virtual void	receiveSignal (cComponent *source, simsignal_t signalID, intval_t value, cObject *details) override
	Handle control messages from lower layer. More...
virtual queueing::IPassivePacketSource *	getProvider (cGate *gate) override
	Returns the passive packet source from where packets are pulled or nullptr if the connected module doesn't implement the interface. More...
virtual void	handleCanPullPacketChanged (cGate *gate) override
	Notifies about a change in the possibility of pulling some packet from the passive packet source at the given gate. More...
virtual void	handlePullPacketProcessed (Packet *packet, cGate *gate, bool successful) override
	Notifies about the completion of the packet processing for a packet that was pulled earlier independently whether the packet is passed or streamed. More...
Public Member Functions inherited from inet::OperationalMixin< cSimpleModule >
virtual	~OperationalMixin ()
	}@ More...
Public Member Functions inherited from inet::ILifecycle
virtual	~ILifecycle ()
Public Member Functions inherited from inet::IMacProtocol
virtual	~IMacProtocol ()
Public Member Functions inherited from inet::queueing::IActivePacketSink
virtual	~IActivePacketSink ()

Different tracked statistics.
enum	t_mac_states {   IDLE_1 = 1, BACKOFF_2, CCA_3, TRANSMITFRAME_4,   WAITACK_5, WAITSIFS_6, TRANSMITACK_7 }
	MAC states see states diagram. More...
enum	t_mac_timer {   TIMER_NULL = 0, TIMER_BACKOFF, TIMER_CCA, TIMER_SIFS,   TIMER_RX_ACK }
	Kinds for timer messages. More...
long	nbTxFrames
long	nbRxFrames
long	nbMissedAcks
long	nbRecvdAcks
long	nbDroppedFrames
long	nbTxAcks
long	nbDuplicates
long	nbBackoffs
double	backoffValues

Pointer for timer messages.
enum	t_mac_event {   EV_SEND_REQUEST = 1, EV_TIMER_BACKOFF, EV_FRAME_TRANSMITTED, EV_ACK_RECEIVED,   EV_ACK_TIMEOUT, EV_FRAME_RECEIVED, EV_DUPLICATE_RECEIVED, EV_TIMER_SIFS,   EV_BROADCAST_RECEIVED, EV_TIMER_CCA }
	MAC state machine events. More...
enum	t_csma_frame_types { DATA, ACK }
	Types for frames sent by the CSMA. More...
enum	t_mac_carrier_sensed { CHANNEL_BUSY = 1, CHANNEL_FREE }
enum	t_mac_status {   STATUS_OK = 1, STATUS_ERROR, STATUS_RX_ERROR, STATUS_RX_TIMEOUT,   STATUS_FRAME_TO_PROCESS, STATUS_NO_FRAME_TO_PROCESS, STATUS_FRAME_TRANSMITTED }
enum	backoff_methods { CONSTANT = 0, LINEAR, EXPONENTIAL }
	The different back-off methods. More...
cMessage *	backoffTimer
cMessage *	ccaTimer
cMessage *	sifsTimer
cMessage *	rxAckTimer
t_mac_states	macState
	keep track of MAC state More...
t_mac_status	status
ModuleRefByPar< physicallayer::IRadio >	radio
	The radio. More...
physicallayer::IRadio::TransmissionState	transmissionState
simtime_t	sifs
	Maximum time between a packet and its ACK. More...
simtime_t	macAckWaitDuration
	The amount of time the MAC waits for the ACK of a packet. More...
int	headerLength
	Length of the header. More...
bool	transmissionAttemptInterruptedByRx
simtime_t	ccaDetectionTime
	CCA detection time. More...
simtime_t	rxSetupTime
	Time to setup radio from sleep to Rx state. More...
simtime_t	aTurnaroundTime
	Time to switch radio from Rx to Tx state. More...
int	macMaxCSMABackoffs
	maximum number of extra backoffs (excluding the first unconditional one) before frame drop More...
unsigned int	macMaxFrameRetries
	maximum number of frame retransmissions without ack More...
simtime_t	aUnitBackoffPeriod
	base time unit for calculating backoff durations More...
bool	useMACAcks
	Stores if the MAC expects Acks for Unicast packets. More...
backoff_methods	backoffMethod
	Defines the backoff method to be used. More...
int	macMinBE
	Minimum backoff exponent. More...
int	macMaxBE
	Maximum backoff exponent. More...
int	initialCW
	initial contention window size Only used for linear and constant backoff method. More...
double	txPower
	The power (in mW) to transmit with. More...
int	NB
	number of backoff performed until now for current frame More...
unsigned int	txAttempts
	count the number of tx attempts More...
double	bitrate
	the bit rate at which we transmit More...
int	ackLength
	The bit length of the ACK packet. More...
Packet *	ackMessage
std::map< MacAddress, unsigned long >	SeqNrParent
std::map< MacAddress, unsigned long >	SeqNrChild
virtual void	configureNetworkInterface () override
	Generate new interface address. More...
virtual void	handleCommand (cMessage *msg)
void	fsmError (t_mac_event event, cMessage *msg)
void	executeMac (t_mac_event event, cMessage *msg)
	Updates state machine. More...
void	updateStatusIdle (t_mac_event event, cMessage *msg)
void	updateStatusBackoff (t_mac_event event, cMessage *msg)
void	updateStatusCCA (t_mac_event event, cMessage *msg)
void	updateStatusTransmitFrame (t_mac_event event, cMessage *msg)
void	updateStatusWaitAck (t_mac_event event, cMessage *msg)
void	updateStatusSIFS (t_mac_event event, cMessage *msg)
void	updateStatusTransmitAck (t_mac_event event, cMessage *msg)
void	updateStatusNotIdle (cMessage *msg)
void	manageQueue ()
void	updateMacState (t_mac_states newMacState)
void	attachSignal (Packet *mac, simtime_t_cref startTime)
void	manageMissingAck (t_mac_event event, cMessage *msg)
void	startTimer (t_mac_timer timer)
virtual simtime_t	scheduleBackoff ()
virtual void	encapsulate (Packet *packet)
	Encapsulates the message. More...
virtual void	decapsulate (Packet *packet)
virtual void	handleStartOperation (LifecycleOperation *operation) override
virtual void	handleStopOperation (LifecycleOperation *operation) override
virtual void	handleCrashOperation (LifecycleOperation *operation) override
virtual void	refreshDisplay () const override
	Ieee802154Mac (const Ieee802154Mac &)
	Copy constructor is not allowed. More...
Ieee802154Mac &	operator= (const Ieee802154Mac &)
	Assignment operator is not allowed. More...

Additional Inherited Members
Protected Types inherited from inet::OperationalMixin< cSimpleModule >
enum	State
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	sendUp (cMessage *message)
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	handleMessageWhenUp (cMessage *message) override
virtual void	handleUpperMessage (cMessage *message)
virtual void	handleLowerMessage (cMessage *message)
virtual void	handleUpperCommand (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 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

Detailed Description

Generic CSMA Mac-Layer.

Supports constant, linear and exponential backoffs as well as MAC ACKs.

Author

Jerome Rousselot, Amre El-Hoiydi, Marc Loebbers, Yosia Hadisusanto, Andreas Koepke

Karl Wessel (port for MiXiM)

CSMA Mac-Layer - finite state machine

Member Enumeration Documentation

backoff_methods

enum inet::Ieee802154Mac::backoff_methods

protected

The different back-off methods.

Enumerator
CONSTANT	Constant back-off time.
LINEAR	Linear increasing back-off time.
EXPONENTIAL	Exponentially increasing back-off time.

                         {
        CONSTANT = 0,
        LINEAR,
        EXPONENTIAL,
    };

t_csma_frame_types

enum inet::Ieee802154Mac::t_csma_frame_types

protected

Types for frames sent by the CSMA.

Enumerator
DATA
ACK

                            {
        DATA,
        ACK
    };

t_mac_carrier_sensed

enum inet::Ieee802154Mac::t_mac_carrier_sensed

protected

Enumerator
CHANNEL_BUSY
CHANNEL_FREE

                              {
        CHANNEL_BUSY = 1,
        CHANNEL_FREE
    };

t_mac_event

enum inet::Ieee802154Mac::t_mac_event

protected

MAC state machine events.

See state diagram.

Enumerator
EV_SEND_REQUEST
EV_TIMER_BACKOFF
EV_FRAME_TRANSMITTED
EV_ACK_RECEIVED
EV_ACK_TIMEOUT
EV_FRAME_RECEIVED
EV_DUPLICATE_RECEIVED
EV_TIMER_SIFS
EV_BROADCAST_RECEIVED
EV_TIMER_CCA

                     {
        EV_SEND_REQUEST = 1, // 1, 11, 20, 21, 22
        EV_TIMER_BACKOFF, // 2, 7, 14, 15
        EV_FRAME_TRANSMITTED, // 4, 19
        EV_ACK_RECEIVED, // 5
        EV_ACK_TIMEOUT, // 12
        EV_FRAME_RECEIVED, // 15, 26
        EV_DUPLICATE_RECEIVED,
        EV_TIMER_SIFS, // 17
        EV_BROADCAST_RECEIVED, // 23, 24
        EV_TIMER_CCA
    };

t_mac_states

enum inet::Ieee802154Mac::t_mac_states

protected

MAC states see states diagram.

Enumerator
IDLE_1
BACKOFF_2
CCA_3
TRANSMITFRAME_4
WAITACK_5
WAITSIFS_6
TRANSMITACK_7

                      {
        IDLE_1 = 1,
        BACKOFF_2,
        CCA_3,
        TRANSMITFRAME_4,
        WAITACK_5,
        WAITSIFS_6,
        TRANSMITACK_7
    };

t_mac_status

enum inet::Ieee802154Mac::t_mac_status

protected

Enumerator
STATUS_OK
STATUS_ERROR
STATUS_RX_ERROR
STATUS_RX_TIMEOUT
STATUS_FRAME_TO_PROCESS
STATUS_NO_FRAME_TO_PROCESS
STATUS_FRAME_TRANSMITTED

                      {
        STATUS_OK = 1,
        STATUS_ERROR,
        STATUS_RX_ERROR,
        STATUS_RX_TIMEOUT,
        STATUS_FRAME_TO_PROCESS,
        STATUS_NO_FRAME_TO_PROCESS,
        STATUS_FRAME_TRANSMITTED
    };

t_mac_timer

enum inet::Ieee802154Mac::t_mac_timer

protected

Kinds for timer messages.

Enumerator
TIMER_NULL
TIMER_BACKOFF
TIMER_CCA
TIMER_SIFS
TIMER_RX_ACK

                     {
        TIMER_NULL = 0,
        TIMER_BACKOFF,
        TIMER_CCA,
        TIMER_SIFS,
        TIMER_RX_ACK,
    };

Constructor & Destructor Documentation

Ieee802154Mac() [1/2]

inet::Ieee802154Mac::Ieee802154Mac ( )

inline

        : MacProtocolBase()
        , nbTxFrames(0)
        , nbRxFrames(0)
        , nbMissedAcks(0)
        , nbRecvdAcks(0)
        , nbDroppedFrames(0)
        , nbTxAcks(0)
        , nbDuplicates(0)
        , nbBackoffs(0)
        , backoffValues(0)
        , backoffTimer(nullptr), ccaTimer(nullptr), sifsTimer(nullptr), rxAckTimer(nullptr)
        , macState(IDLE_1)
        , status(STATUS_OK)
        , transmissionState(physicallayer::IRadio::TRANSMISSION_STATE_UNDEFINED)
        , sifs()
        , macAckWaitDuration()
        , headerLength(0)
        , transmissionAttemptInterruptedByRx(false)
        , ccaDetectionTime()
        , rxSetupTime()
        , aTurnaroundTime()
        , macMaxCSMABackoffs(0)
        , macMaxFrameRetries(0)
        , aUnitBackoffPeriod()
        , useMACAcks(false)
        , backoffMethod(CONSTANT)
        , macMinBE(0)
        , macMaxBE(0)
        , initialCW(0)
        , txPower(0)
        , NB(0)
        , txAttempts(0)
        , bitrate(0)
        , ackLength(0)
        , ackMessage(nullptr)
        , SeqNrParent()
        , SeqNrChild()
    {}

~Ieee802154Mac()

inet::Ieee802154Mac::~Ieee802154Mac ( )

virtual

{
    cancelAndDelete(backoffTimer);
    cancelAndDelete(ccaTimer);
    cancelAndDelete(sifsTimer);
    cancelAndDelete(rxAckTimer);
    if (ackMessage)
        delete ackMessage;
}

Ieee802154Mac() [2/2]

inet::Ieee802154Mac::Ieee802154Mac ( const Ieee802154Mac &  )

private

Copy constructor is not allowed.

Member Function Documentation

attachSignal()

void inet::Ieee802154Mac::attachSignal ( Packet *  mac, simtime_t_cref  startTime  )

protected

{
    simtime_t duration = mac->getBitLength() / bitrate;
    mac->setDuration(duration);
}

configureNetworkInterface()

void inet::Ieee802154Mac::configureNetworkInterface ( )

overrideprotectedvirtual

Generate new interface address.

Implements inet::MacProtocolBase.

{
    MacAddress address = parseMacAddressParameter(par("address"));
 
    // data rate
    networkInterface->setDatarate(bitrate);
 
    // generate a link-layer address to be used as interface token for IPv6
    networkInterface->setMacAddress(address);
    networkInterface->setInterfaceToken(address.formInterfaceIdentifier());
 
    // capabilities
    networkInterface->setMtu(par("mtu"));
    networkInterface->setMulticast(true);
    networkInterface->setBroadcast(true);
}

decapsulate()

void inet::Ieee802154Mac::decapsulate ( Packet *  packet )

protectedvirtual

{
    const auto& csmaHeader = packet->popAtFront<Ieee802154MacHeader>();
    packet->addTagIfAbsent<MacAddressInd>()->setSrcAddress(csmaHeader->getSrcAddr());
    packet->addTagIfAbsent<InterfaceInd>()->setInterfaceId(networkInterface->getInterfaceId());
    auto payloadProtocol = ProtocolGroup::ethertype.getProtocol(csmaHeader->getNetworkProtocol());
    packet->addTagIfAbsent<DispatchProtocolReq>()->setProtocol(payloadProtocol);
    packet->addTagIfAbsent<PacketProtocolTag>()->setProtocol(payloadProtocol);
}

encapsulate()

void inet::Ieee802154Mac::encapsulate ( Packet *  packet )

protectedvirtual

Encapsulates the message.

{
    auto macPkt = makeShared<Ieee802154MacHeader>();
    assert(headerLength % 8 == 0);
    macPkt->setChunkLength(b(headerLength));
    MacAddress dest = packet->getTag<MacAddressReq>()->getDestAddress();
    EV_DETAIL << "CSMA received a message from upper layer, name is " << packet->getName() << ", CInfo removed, mac addr=" << dest << endl;
    macPkt->setNetworkProtocol(ProtocolGroup::ethertype.getProtocolNumber(packet->getTag<PacketProtocolTag>()->getProtocol()));
    macPkt->setDestAddr(dest);
    delete packet->removeControlInfo();
    macPkt->setSrcAddr(networkInterface->getMacAddress());
 
    if (useMACAcks) {
        if (!containsKey(SeqNrParent, dest)) {
            // no record of current parent -> add next sequence number to map
            SeqNrParent[dest] = 1;
            macPkt->setSequenceId(0);
            EV_DETAIL << "Adding a new parent to the map of Sequence numbers:" << dest << endl;
        }
        else {
            macPkt->setSequenceId(SeqNrParent[dest]);
            EV_DETAIL << "Packet send with sequence number = " << SeqNrParent[dest] << endl;
            SeqNrParent[dest]++;
        }
    }
 
    packet->insertAtFront(macPkt);
    packet->getTagForUpdate<PacketProtocolTag>()->setProtocol(&Protocol::ieee802154);
    EV_DETAIL << "pkt encapsulated, length: " << macPkt->getChunkLength() << "\n";
}

executeMac()

void inet::Ieee802154Mac::executeMac ( t_mac_event  event, cMessage *  msg  )

protected

Updates state machine.

{
    EV_DETAIL << "In executeMac" << endl;
    if (macState != IDLE_1 && event == EV_SEND_REQUEST) {
        updateStatusNotIdle(msg);
    }
    else {
        switch (macState) {
            case IDLE_1:
                updateStatusIdle(event, msg);
                break;
 
            case BACKOFF_2:
                updateStatusBackoff(event, msg);
                break;
 
            case CCA_3:
                updateStatusCCA(event, msg);
                break;
 
            case TRANSMITFRAME_4:
                updateStatusTransmitFrame(event, msg);
                break;
 
            case WAITACK_5:
                updateStatusWaitAck(event, msg);
                break;
 
            case WAITSIFS_6:
                updateStatusSIFS(event, msg);
                break;
 
            case TRANSMITACK_7:
                updateStatusTransmitAck(event, msg);
                break;
 
            default:
                EV << "Error in CSMA FSM: an unknown state has been reached. macState=" << macState << endl;
                break;
        }
    }
}

finish()

void inet::Ieee802154Mac::finish ( )

overridevirtual

Delete all dynamically allocated objects of the module.

{
    recordScalar("nbTxFrames", nbTxFrames);
    recordScalar("nbRxFrames", nbRxFrames);
    recordScalar("nbDroppedFrames", nbDroppedFrames);
    recordScalar("nbMissedAcks", nbMissedAcks);
    recordScalar("nbRecvdAcks", nbRecvdAcks);
    recordScalar("nbTxAcks", nbTxAcks);
    recordScalar("nbDuplicates", nbDuplicates);
    if (nbBackoffs > 0) {
        recordScalar("meanBackoff", backoffValues / nbBackoffs);
    }
    else {
        recordScalar("meanBackoff", 0);
    }
    recordScalar("nbBackoffs", nbBackoffs);
    recordScalar("backoffDurations", backoffValues);
}

fsmError()

void inet::Ieee802154Mac::fsmError ( t_mac_event  event, cMessage *  msg  )

protected

{
    EV << "FSM Error ! In state " << macState << ", received unknown event:" << event << "." << endl;
    if (msg != nullptr)
        delete msg;
}

getProvider()

queueing::IPassivePacketSource * inet::Ieee802154Mac::getProvider ( cGate *  gate )

overridevirtual

Returns the passive packet source from where packets are pulled or nullptr if the connected module doesn't implement the interface.

The gate parameter must be a valid gate of this module.

Implements inet::queueing::IActivePacketSink.

{
    return (gate->getId() == upperLayerInGateId) ? txQueue.get() : nullptr;
}

handleCanPullPacketChanged()

void inet::Ieee802154Mac::handleCanPullPacketChanged ( cGate *  gate )

overridevirtual

Notifies about a change in the possibility of pulling some packet from the passive packet source at the given gate.

This method is called, for example, when a new packet is inserted into a queue. It allows the sink to pull a new packet from the queue.

The gate parameter must be a valid gate of this module.

Implements inet::queueing::IActivePacketSink.

{
    Enter_Method("handleCanPullPacketChanged");
    if (gate->getId() == upperLayerInGateId)
        executeMac(EV_SEND_REQUEST, nullptr);
}

handleCommand()

virtual void inet::Ieee802154Mac::handleCommand ( cMessage *  msg )

inlineprotectedvirtual

{}

handleCrashOperation()

void inet::Ieee802154Mac::handleCrashOperation ( LifecycleOperation *  operation )

overrideprotectedvirtual

Reimplemented from inet::MacProtocolBase.

{
    cancelEvent(backoffTimer);
    cancelEvent(ccaTimer);
    cancelEvent(sifsTimer);
    cancelEvent(rxAckTimer);
 
    cModule *radioModule = check_and_cast<cModule *>(radio.get());
    radioModule->unsubscribe(IRadio::transmissionStateChangedSignal, this);
 
    MacProtocolBase::handleCrashOperation(operation);
}

handleLowerPacket()

void inet::Ieee802154Mac::handleLowerPacket ( Packet *  packet )

overridevirtual

Handle messages from lower layer.

Compares the address of this Host with the destination address in frame.

Generates the corresponding event.

Reimplemented from inet::LayeredProtocolBase.

{
    if (packet->hasBitError()) {
        EV << "Received " << packet << " contains bit errors or collision, dropping it\n";
        PacketDropDetails details;
        details.setReason(INCORRECTLY_RECEIVED);
        emit(packetDroppedSignal, packet, &details);
        delete packet;
        return;
    }
    const auto& csmaHeader = packet->peekAtFront<Ieee802154MacHeader>();
    const MacAddress& src = csmaHeader->getSrcAddr();
    const MacAddress& dest = csmaHeader->getDestAddr();
    long ExpectedNr = 0;
    MacAddress address = networkInterface->getMacAddress();
 
    EV_DETAIL << "Received frame name= " << csmaHeader->getName()
              << ", myState=" << macState << " src=" << src
              << " dst=" << dest << " myAddr="
              << address << endl;
 
    if (dest == address) {
        if (!useMACAcks) {
            EV_DETAIL << "Received a data packet addressed to me." << endl;
//            nbRxFrames++;
            executeMac(EV_FRAME_RECEIVED, packet);
        }
        else {
            long SeqNr = csmaHeader->getSequenceId();
 
            if (strcmp(packet->getName(), "CSMA-Ack") != 0) {
                // This is a data message addressed to us
                // and we should send an ack.
                // we build the ack packet here because we need to
                // copy data from macPkt (src).
                EV_DETAIL << "Received a data packet addressed to me,"
                          << " preparing an ack..." << endl;
 
//                nbRxFrames++;
 
                if (ackMessage != nullptr)
                    delete ackMessage;
                auto csmaHeader = makeShared<Ieee802154MacHeader>();
                csmaHeader->setSrcAddr(address);
                csmaHeader->setDestAddr(src);
                csmaHeader->setChunkLength(b(ackLength));
                ackMessage = new Packet("CSMA-Ack");
                ackMessage->insertAtFront(csmaHeader);
                ackMessage->addTag<PacketProtocolTag>()->setProtocol(&Protocol::ieee802154);
                // Check for duplicates by checking expected seqNr of sender
                if (!containsKey(SeqNrChild, src)) {
                    // no record of current child -> add expected next number to map
                    SeqNrChild[src] = SeqNr + 1;
                    EV_DETAIL << "Adding a new child to the map of Sequence numbers:" << src << endl;
                    executeMac(EV_FRAME_RECEIVED, packet);
                }
                else {
                    ExpectedNr = SeqNrChild[src];
                    EV_DETAIL << "Expected Sequence number is " << ExpectedNr
                              << " and number of packet is " << SeqNr << endl;
                    if (SeqNr < ExpectedNr) {
                        // Duplicate Packet, count and do not send to upper layer
                        nbDuplicates++;
                        executeMac(EV_DUPLICATE_RECEIVED, packet);
                    }
                    else {
                        SeqNrChild[src] = SeqNr + 1;
                        executeMac(EV_FRAME_RECEIVED, packet);
                    }
                }
            }
            else if (currentTxFrame != nullptr) {
                // message is an ack, and it is for us.
                // Is it from the right node ?
                const auto& csmaHeader = currentTxFrame->peekAtFront<Ieee802154MacHeader>();
                if (src == csmaHeader->getDestAddr()) {
                    nbRecvdAcks++;
                    executeMac(EV_ACK_RECEIVED, packet);
                }
                else {
                    EV << "Error! Received an ack from an unexpected source: src=" << src << ", I was expecting from node addr=" << csmaHeader->getDestAddr() << endl;
                    delete packet;
                }
            }
            else {
                EV << "Error! Received an Ack while my send queue was empty. src=" << src << "." << endl;
                delete packet;
            }
        }
    }
    else if (dest.isBroadcast() || dest.isMulticast()) {
        executeMac(EV_BROADCAST_RECEIVED, packet);
    }
    else {
        EV_DETAIL << "packet not for me, deleting...\n";
        PacketDropDetails details;
        details.setReason(NOT_ADDRESSED_TO_US);
        emit(packetDroppedSignal, packet, &details);
        delete packet;
    }
}

handlePullPacketProcessed()

void inet::Ieee802154Mac::handlePullPacketProcessed ( Packet *  packet, cGate *  gate, bool  successful  )

overridevirtual

Notifies about the completion of the packet processing for a packet that was pulled earlier independently whether the packet is passed or streamed.

This method is called, for example, when a previously pulled packet is failed to be processed successfully. It allows the sink to retry the operation.

The gate parameter must be a valid gate of this module. The packet must not be nullptr.

Implements inet::queueing::IActivePacketSink.

{
    Enter_Method("handlePullPacketProcessed");
    throw cRuntimeError("Not supported callback");
}

handleSelfMessage()

void inet::Ieee802154Mac::handleSelfMessage ( cMessage *  msg )

overridevirtual

Handle self messages such as timers.

Reimplemented from inet::LayeredProtocolBase.

{
    EV_DETAIL << "timer routine." << endl;
    if (msg == backoffTimer)
        executeMac(EV_TIMER_BACKOFF, msg);
    else if (msg == ccaTimer)
        executeMac(EV_TIMER_CCA, msg);
    else if (msg == sifsTimer)
        executeMac(EV_TIMER_SIFS, msg);
    else if (msg == rxAckTimer) {
        nbMissedAcks++;
        executeMac(EV_ACK_TIMEOUT, msg);
    }
    else
        EV << "CSMA Error: unknown timer fired:" << msg << endl;
}

handleStartOperation()

void inet::Ieee802154Mac::handleStartOperation ( LifecycleOperation *  operation )

overrideprotectedvirtual

Reimplemented from inet::MacProtocolBase.

{
    updateMacState(IDLE_1);
    // manageQueue() to see waiting packets or set to idle if none
    MacProtocolBase::handleStartOperation(operation);
 
    cModule *radioModule = check_and_cast<cModule *>(radio.get());
    radioModule->subscribe(IRadio::transmissionStateChangedSignal, this);
}

handleStopOperation()

void inet::Ieee802154Mac::handleStopOperation ( LifecycleOperation *  operation )

overrideprotectedvirtual

Reimplemented from inet::MacProtocolBase.

{
    // TODO More gracefully allow current Tx to end (delay operation)
    // Cancel all self message timers
    cancelEvent(backoffTimer);
    cancelEvent(ccaTimer);
    cancelEvent(sifsTimer);
    cancelEvent(rxAckTimer);
 
    cModule *radioModule = check_and_cast<cModule *>(radio.get());
    radioModule->unsubscribe(IRadio::transmissionStateChangedSignal, this);
 
    MacProtocolBase::handleStopOperation(operation);
}

handleUpperPacket()

void inet::Ieee802154Mac::handleUpperPacket ( Packet *  packet )

overridevirtual

Handle messages from upper layer.

Encapsulates the message to be transmitted and pass it on to the FSM main method for further processing.

Reimplemented from inet::LayeredProtocolBase.

{
    throw cRuntimeError("not supported");
}

initialize()

void inet::Ieee802154Mac::initialize ( int  stage )

overridevirtual

Initialization of the module and some variables.

Reimplemented from inet::MacProtocolBase.

{
    MacProtocolBase::initialize(stage);
    if (stage == INITSTAGE_LOCAL) {
        useMACAcks = par("useMACAcks");
        sifs = par("sifs");
        headerLength = par("headerLength");
        transmissionAttemptInterruptedByRx = false;
        nbTxFrames = 0;
        nbRxFrames = 0;
        nbMissedAcks = 0;
        nbTxAcks = 0;
        nbRecvdAcks = 0;
        nbDroppedFrames = 0;
        nbDuplicates = 0;
        nbBackoffs = 0;
        backoffValues = 0;
        macMaxCSMABackoffs = par("macMaxCSMABackoffs");
        macMaxFrameRetries = par("macMaxFrameRetries");
        macAckWaitDuration = par("macAckWaitDuration");
        aUnitBackoffPeriod = par("aUnitBackoffPeriod");
        ccaDetectionTime = par("ccaDetectionTime");
        rxSetupTime = par("rxSetupTime");
        aTurnaroundTime = par("aTurnaroundTime");
        bitrate = par("bitrate");
        ackLength = par("ackLength");
        ackMessage = nullptr;
 
        // init parameters for backoff method
        std::string backoffMethodStr = par("backoffMethod").stdstringValue();
        if (backoffMethodStr == "exponential") {
            backoffMethod = EXPONENTIAL;
            macMinBE = par("macMinBE");
            macMaxBE = par("macMaxBE");
        }
        else {
            if (backoffMethodStr == "linear") {
                backoffMethod = LINEAR;
            }
            else if (backoffMethodStr == "constant") {
                backoffMethod = CONSTANT;
            }
            else {
                throw cRuntimeError("Unknown backoff method \"%s\".\
                       Use \"constant\", \"linear\" or \"\
                       \"exponential\".", backoffMethodStr.c_str());
            }
            initialCW = par("contentionWindow");
        }
        NB = 0;
 
        // initialize the timers
        backoffTimer = new cMessage("timer-backoff");
        ccaTimer = new cMessage("timer-cca");
        sifsTimer = new cMessage("timer-sifs");
        rxAckTimer = new cMessage("timer-rxAck");
        macState = IDLE_1;
        txAttempts = 0;
        txQueue = getQueue(gate(upperLayerInGateId));
        radio.reference(this, "radioModule", true);
        WATCH(macState);
    }
    else if (stage == INITSTAGE_LINK_LAYER) {
        cModule *radioModule = check_and_cast<cModule *>(radio.get());
        // check parameters for consistency
        // aTurnaroundTime should match (be equal or bigger) the RX to TX
        // switching time of the radio
        if (radioModule->hasPar("timeRXToTX")) {
            simtime_t rxToTx = radioModule->par("timeRXToTX");
            if (rxToTx > aTurnaroundTime) {
                throw cRuntimeError("Parameter \"aTurnaroundTime\" (%f) does not match"
                        " the radios RX to TX switching time (%f)! It"
                        " should be equal or bigger",
                        SIMTIME_DBL(aTurnaroundTime), SIMTIME_DBL(rxToTx));
            }
        }
        radio->setRadioMode(IRadio::RADIO_MODE_RECEIVER);
 
        EV_DETAIL << " bitrate = " << bitrate
                  << " backoff method = " << par("backoffMethod").stringValue() << endl;
    }
}

manageMissingAck()

void inet::Ieee802154Mac::manageMissingAck ( t_mac_event  event, cMessage *  msg  )

protected

{
    if (txAttempts < macMaxFrameRetries) {
        // increment counter
        txAttempts++;
        EV_DETAIL << "I will retransmit this packet (I already tried "
                  << txAttempts << " times)." << endl;
    }
    else {
        // drop packet
        EV_DETAIL << "Packet was transmitted " << txAttempts
                  << " times and I never got an Ack. I drop the packet." << endl;
        txAttempts = 0;
        PacketDropDetails details;
        details.setReason(RETRY_LIMIT_REACHED);
        details.setLimit(macMaxFrameRetries);
        dropCurrentTxFrame(details);
    }
    manageQueue();
}

manageQueue()

void inet::Ieee802154Mac::manageQueue ( )

protected

{
    if (currentTxFrame != nullptr || !txQueue->isEmpty()) {
        EV_DETAIL << "(manageQueue) there are " << txQueue->getNumPackets() + (currentTxFrame == nullptr ? 0 : 1) << " packets to send, entering backoff wait state." << endl;
        if (transmissionAttemptInterruptedByRx) {
            // resume a transmission cycle which was interrupted by
            // a frame reception during CCA check
            transmissionAttemptInterruptedByRx = false;
        }
        else {
            // initialize counters if we start a new transmission
            // cycle from zero
            NB = 0;
//            BE = macMinBE;
        }
        if (!backoffTimer->isScheduled()) {
            startTimer(TIMER_BACKOFF);
        }
        updateMacState(BACKOFF_2);
    }
    else {
        EV_DETAIL << "(manageQueue) no packets to send, entering IDLE state." << endl;
        updateMacState(IDLE_1);
    }
}

operator=()

Ieee802154Mac& inet::Ieee802154Mac::operator= ( const Ieee802154Mac &  )

private

Assignment operator is not allowed.

receiveSignal()

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

overridevirtual

Handle control messages from lower layer.

{
    Enter_Method("%s", cComponent::getSignalName(signalID));
 
    if (signalID == IRadio::transmissionStateChangedSignal) {
        IRadio::TransmissionState newRadioTransmissionState = static_cast<IRadio::TransmissionState>(value);
        if (transmissionState == IRadio::TRANSMISSION_STATE_TRANSMITTING && newRadioTransmissionState == IRadio::TRANSMISSION_STATE_IDLE) {
            // KLUDGE we used to get a cMessage from the radio (the identity was not important)
            executeMac(EV_FRAME_TRANSMITTED, new cMessage("Transmission over"));
        }
        transmissionState = newRadioTransmissionState;
    }
}

refreshDisplay()

void inet::Ieee802154Mac::refreshDisplay ( ) const

overrideprotectedvirtual

{
    std::stringstream os;
    os<<"";
    switch (macState) {
        case IDLE_1:
            os<< "IDLE";
            break;
 
        case BACKOFF_2:
            os<< "BACKOFF ("<<(backoffTimer->getArrivalTime()- simTime()).inUnit(SIMTIME_US) <<"us)";
            break;
 
        case CCA_3:
            os<< "CCA ("<<(ccaTimer->getArrivalTime()- simTime()).inUnit(SIMTIME_US) <<"us)";
            break;
 
        case TRANSMITFRAME_4:
            os<< "TRANSMITING FRAME";
            break;
 
        case WAITACK_5:
            os<< "WAITING ACK (" <<(rxAckTimer->getArrivalTime()- simTime()).inUnit(SIMTIME_US) <<"us)";
            break;
 
        case WAITSIFS_6:
            os<< "WAITING SIFS (" <<(sifsTimer->getArrivalTime()- simTime()).inUnit(SIMTIME_US) <<"us)";
            break;
 
        case TRANSMITACK_7:
            os<< "TRANSMITING ACK";
            break;
        default:
            os<< "defined state";
            break;
    }
    getDisplayString().setTagArg("t", 0, os.str().c_str());
}

scheduleBackoff()

simtime_t inet::Ieee802154Mac::scheduleBackoff ( )

protectedvirtual

{
    simtime_t backoffTime;
 
    switch (backoffMethod) {
        case EXPONENTIAL: {
            int BE = std::min(macMinBE + NB, macMaxBE);
            int v = (1 << BE) - 1;
            int r = intuniform(0, v, 0);
            backoffTime = r * aUnitBackoffPeriod;
 
            EV_DETAIL << "(startTimer) backoffTimer value=" << backoffTime
                      << " (BE=" << BE << ", 2^BE-1= " << v << "r="
                      << r << ")" << endl;
            break;
        }
 
        case LINEAR: {
            int slots = intuniform(1, initialCW + NB, 0);
            backoffTime = slots * aUnitBackoffPeriod;
            EV_DETAIL << "(startTimer) backoffTimer value=" << backoffTime << endl;
            break;
        }
 
        case CONSTANT: {
            int slots = intuniform(1, initialCW, 0);
            backoffTime = slots * aUnitBackoffPeriod;
            EV_DETAIL << "(startTimer) backoffTimer value=" << backoffTime << endl;
            break;
        }
 
        default:
            throw cRuntimeError("Unknown backoff method!");
            break;
    }
 
    nbBackoffs = nbBackoffs + 1;
    backoffValues = backoffValues + SIMTIME_DBL(backoffTime);
 
    return backoffTime;
}

startTimer()

void inet::Ieee802154Mac::startTimer ( t_mac_timer  timer )

protected

{
    if (timer == TIMER_BACKOFF) {
        scheduleAfter(scheduleBackoff(), backoffTimer);
    }
    else if (timer == TIMER_CCA) {
        simtime_t ccaTime = rxSetupTime + ccaDetectionTime;
        EV_DETAIL << "(startTimer) ccaTimer value=" << ccaTime
                  << "(rxSetupTime,ccaDetectionTime:" << rxSetupTime
                  << "," << ccaDetectionTime << ")." << endl;
        scheduleAfter(rxSetupTime + ccaDetectionTime, ccaTimer);
    }
    else if (timer == TIMER_SIFS) {
        assert(useMACAcks);
        EV_DETAIL << "(startTimer) sifsTimer value=" << sifs << endl;
        scheduleAfter(sifs, sifsTimer);
    }
    else if (timer == TIMER_RX_ACK) {
        assert(useMACAcks);
        EV_DETAIL << "(startTimer) rxAckTimer value=" << macAckWaitDuration << endl;
        scheduleAfter(macAckWaitDuration, rxAckTimer);
    }
    else {
        EV << "Unknown timer requested to start:" << timer << endl;
    }
}

updateMacState()

void inet::Ieee802154Mac::updateMacState ( t_mac_states  newMacState )

protected

{
    macState = newMacState;
}

updateStatusBackoff()

void inet::Ieee802154Mac::updateStatusBackoff ( t_mac_event  event, cMessage *  msg  )

protected

{
    switch (event) {
        case EV_TIMER_BACKOFF:
            EV_DETAIL << "(2) FSM State BACKOFF, EV_TIMER_BACKOFF:"
                      << " starting CCA timer." << endl;
            startTimer(TIMER_CCA);
            updateMacState(CCA_3);
            radio->setRadioMode(IRadio::RADIO_MODE_RECEIVER);
            break;
 
        case EV_DUPLICATE_RECEIVED:
            // suspend current transmission attempt,
            // transmit ack,
            // and resume transmission when entering manageQueue()
            EV_DETAIL << "(28) FSM State BACKOFF, EV_DUPLICATE_RECEIVED:";
            if (useMACAcks) {
                EV_DETAIL << "suspending current transmit tentative and transmitting ack";
                transmissionAttemptInterruptedByRx = true;
                cancelEvent(backoffTimer);
                radio->setRadioMode(IRadio::RADIO_MODE_TRANSMITTER);
                updateMacState(WAITSIFS_6);
                startTimer(TIMER_SIFS);
            }
            else {
                EV_DETAIL << "Nothing to do.";
            }
//            sendUp(decapsMsg(static_cast<MacSeqPkt *>(msg)));
            delete msg;
 
            break;
 
        case EV_FRAME_RECEIVED:
            // suspend current transmission attempt,
            // transmit ack,
            // and resume transmission when entering manageQueue()
            EV_DETAIL << "(28) FSM State BACKOFF, EV_FRAME_RECEIVED:";
            if (useMACAcks) {
                EV_DETAIL << "suspending current transmit tentative and transmitting ack";
                transmissionAttemptInterruptedByRx = true;
                cancelEvent(backoffTimer);
 
                radio->setRadioMode(IRadio::RADIO_MODE_TRANSMITTER);
                updateMacState(WAITSIFS_6);
                startTimer(TIMER_SIFS);
            }
            else {
                EV_DETAIL << "sending frame up and resuming normal operation.";
            }
            decapsulate(check_and_cast<Packet *>(msg));
            sendUp(msg);
            break;
 
        case EV_BROADCAST_RECEIVED:
            EV_DETAIL << "(29) FSM State BACKOFF, EV_BROADCAST_RECEIVED:"
                      << "sending frame up and resuming normal operation." << endl;
            decapsulate(check_and_cast<Packet *>(msg));
            sendUp(msg);
            break;
 
        default:
            fsmError(event, msg);
            break;
    }
}

updateStatusCCA()

void inet::Ieee802154Mac::updateStatusCCA ( t_mac_event  event, cMessage *  msg  )

protected

{
    switch (event) {
        case EV_TIMER_CCA: {
            EV_DETAIL << "(25) FSM State CCA_3, EV_TIMER_CCA" << endl;
            bool isIdle = radio->getReceptionState() == IRadio::RECEPTION_STATE_IDLE;
            if (isIdle) {
                EV_DETAIL << "(3) FSM State CCA_3, EV_TIMER_CCA, [Channel Idle]: -> TRANSMITFRAME_4." << endl;
                updateMacState(TRANSMITFRAME_4);
                radio->setRadioMode(IRadio::RADIO_MODE_TRANSMITTER);
                if (currentTxFrame == nullptr) {
                    currentTxFrame = dequeuePacket();
                    encapsulate(currentTxFrame);
                }
                Packet *mac = currentTxFrame->dup();
                attachSignal(mac, simTime() + aTurnaroundTime);
//                sendDown(msg);
                // give time for the radio to be in Tx state before transmitting
                sendDelayed(mac, aTurnaroundTime, lowerLayerOutGateId);
                nbTxFrames++;
            }
            else {
                // Channel was busy, increment 802.15.4 backoff timers as specified.
                EV_DETAIL << "(7) FSM State CCA_3, EV_TIMER_CCA, [Channel Busy]: "
                          << " increment counters." << endl;
                NB = NB + 1;
//                BE = std::min(BE+1, macMaxBE);
 
                // decide if we go for another backoff or if we drop the frame.
                if (NB > macMaxCSMABackoffs) {
                    // drop the frame
                    EV_DETAIL << "Tried " << NB << " backoffs, all reported a busy "
                              << "channel. Dropping the packet." << endl;
                    txAttempts = 0;
                    if (currentTxFrame) {
                        nbDroppedFrames++;
                        PacketDropDetails details;
                        details.setReason(CONGESTION);
                        details.setLimit(macMaxCSMABackoffs);
                        dropCurrentTxFrame(details);
                    }
                    else {
                        EV_ERROR << "too many Backoffs, but currentTxFrame is empty\n"; // TODO is it good, or model error?
                    }
                    manageQueue();
                }
                else {
                    // redo backoff
                    updateMacState(BACKOFF_2);
                    startTimer(TIMER_BACKOFF);
                }
            }
            break;
        }
 
        case EV_DUPLICATE_RECEIVED:
            EV_DETAIL << "(26) FSM State CCA_3, EV_DUPLICATE_RECEIVED:";
            if (useMACAcks) {
                EV_DETAIL << " setting up radio tx -> WAITSIFS." << endl;
                // suspend current transmission attempt,
                // transmit ack,
                // and resume transmission when entering manageQueue()
                transmissionAttemptInterruptedByRx = true;
                cancelEvent(ccaTimer);
 
                radio->setRadioMode(IRadio::RADIO_MODE_TRANSMITTER);
                updateMacState(WAITSIFS_6);
                startTimer(TIMER_SIFS);
            }
            else {
                EV_DETAIL << " Nothing to do." << endl;
            }
//            sendUp(decapsMsg(static_cast<MacPkt*>(msg)));
            delete msg;
            break;
 
        case EV_FRAME_RECEIVED:
            EV_DETAIL << "(26) FSM State CCA_3, EV_FRAME_RECEIVED:";
            if (useMACAcks) {
                EV_DETAIL << " setting up radio tx -> WAITSIFS." << endl;
                // suspend current transmission attempt,
                // transmit ack,
                // and resume transmission when entering manageQueue()
                transmissionAttemptInterruptedByRx = true;
                cancelEvent(ccaTimer);
                radio->setRadioMode(IRadio::RADIO_MODE_TRANSMITTER);
                updateMacState(WAITSIFS_6);
                startTimer(TIMER_SIFS);
            }
            else {
                EV_DETAIL << " Nothing to do." << endl;
            }
            decapsulate(check_and_cast<Packet *>(msg));
            sendUp(msg);
            break;
 
        case EV_BROADCAST_RECEIVED:
            EV_DETAIL << "(24) FSM State BACKOFF, EV_BROADCAST_RECEIVED:"
                      << " Nothing to do." << endl;
            decapsulate(check_and_cast<Packet *>(msg));
            sendUp(msg);
            break;
 
        default:
            fsmError(event, msg);
            break;
    }
}

updateStatusIdle()

void inet::Ieee802154Mac::updateStatusIdle ( t_mac_event  event, cMessage *  msg  )

protected

{
    switch (event) {
        case EV_SEND_REQUEST:
            if (!txQueue->isEmpty()) {
                EV_DETAIL << "(1) FSM State IDLE_1, EV_SEND_REQUEST and [TxBuff avail]: startTimerBackOff -> BACKOFF." << endl;
                updateMacState(BACKOFF_2);
                NB = 0;
//                BE = macMinBE;
                startTimer(TIMER_BACKOFF);
            }
            break;
 
        case EV_DUPLICATE_RECEIVED:
            EV_DETAIL << "(15) FSM State IDLE_1, EV_DUPLICATE_RECEIVED: setting up radio tx -> WAITSIFS." << endl;
//            sendUp(decapsMsg(static_cast<MacSeqPkt *>(msg)));
            delete msg;
 
            if (useMACAcks) {
                radio->setRadioMode(IRadio::RADIO_MODE_TRANSMITTER);
                updateMacState(WAITSIFS_6);
                startTimer(TIMER_SIFS);
            }
            break;
 
        case EV_FRAME_RECEIVED:
            EV_DETAIL << "(15) FSM State IDLE_1, EV_FRAME_RECEIVED: setting up radio tx -> WAITSIFS." << endl;
            decapsulate(check_and_cast<Packet *>(msg));
            sendUp(msg);
            nbRxFrames++;
 
            if (useMACAcks) {
                radio->setRadioMode(IRadio::RADIO_MODE_TRANSMITTER);
                updateMacState(WAITSIFS_6);
                startTimer(TIMER_SIFS);
            }
            break;
 
        case EV_BROADCAST_RECEIVED:
            EV_DETAIL << "(23) FSM State IDLE_1, EV_BROADCAST_RECEIVED: Nothing to do." << endl;
            nbRxFrames++;
            decapsulate(check_and_cast<Packet *>(msg));
            sendUp(msg);
            break;
 
        default:
            fsmError(event, msg);
            break;
    }
}

updateStatusNotIdle()

void inet::Ieee802154Mac::updateStatusNotIdle ( cMessage *  msg )

protected

{
    EV_DETAIL << "(20) FSM State NOT IDLE, EV_SEND_REQUEST. Is a TxBuffer available ?" << endl;
}

updateStatusSIFS()

void inet::Ieee802154Mac::updateStatusSIFS ( t_mac_event  event, cMessage *  msg  )

protected

{
    assert(useMACAcks);
 
    switch (event) {
        case EV_TIMER_SIFS:
            EV_DETAIL << "(17) FSM State WAITSIFS_6, EV_TIMER_SIFS:"
                      << " sendAck -> TRANSMITACK." << endl;
            updateMacState(TRANSMITACK_7);
            attachSignal(ackMessage, simTime());
            sendDown(ackMessage);
            nbTxAcks++;
//            sendDelayed(ackMessage, aTurnaroundTime, lowerLayerOut);
            ackMessage = nullptr;
            break;
 
        case EV_TIMER_BACKOFF:
            // Backoff timer has expired while receiving a frame. Restart it
            // and stay here.
            EV_DETAIL << "(16) FSM State WAITSIFS_6, EV_TIMER_BACKOFF. "
                      << "Restart backoff timer and don't move." << endl;
            startTimer(TIMER_BACKOFF);
            break;
 
        case EV_BROADCAST_RECEIVED:
        case EV_FRAME_RECEIVED:
            EV << "Error ! Received a frame during SIFS !" << endl;
            decapsulate(check_and_cast<Packet *>(msg));
            sendUp(msg);
            break;
 
        default:
            fsmError(event, msg);
            break;
    }
}

updateStatusTransmitAck()

void inet::Ieee802154Mac::updateStatusTransmitAck ( t_mac_event  event, cMessage *  msg  )

protected

{
    assert(useMACAcks);
 
    if (event == EV_FRAME_TRANSMITTED) {
        EV_DETAIL << "(19) FSM State TRANSMITACK_7, EV_FRAME_TRANSMITTED:"
                  << " ->manageQueue." << endl;
        radio->setRadioMode(IRadio::RADIO_MODE_RECEIVER);
        delete msg;
        manageQueue();
    }
    else {
        fsmError(event, msg);
    }
}

updateStatusTransmitFrame()

void inet::Ieee802154Mac::updateStatusTransmitFrame ( t_mac_event  event, cMessage *  msg  )

protected

{
    if (event == EV_FRAME_TRANSMITTED && currentTxFrame != nullptr) {
//        delete msg;
        Packet *packet = currentTxFrame;
        const auto& csmaHeader = packet->peekAtFront<Ieee802154MacHeader>();
        radio->setRadioMode(IRadio::RADIO_MODE_RECEIVER);
 
        bool expectAck = useMACAcks;
        if (!csmaHeader->getDestAddr().isBroadcast() && !csmaHeader->getDestAddr().isMulticast()) {
            // unicast
            EV_DETAIL << "(4) FSM State TRANSMITFRAME_4, "
                      << "EV_FRAME_TRANSMITTED [Unicast]: ";
        }
        else {
            // broadcast
            EV_DETAIL << "(27) FSM State TRANSMITFRAME_4, EV_FRAME_TRANSMITTED "
                      << " [Broadcast]";
            expectAck = false;
        }
 
        if (expectAck) {
            EV_DETAIL << "RadioSetupRx -> WAITACK." << endl;
            updateMacState(WAITACK_5);
            startTimer(TIMER_RX_ACK);
        }
        else {
            EV_DETAIL << ": RadioSetupRx, manageQueue..." << endl;
            deleteCurrentTxFrame();
            manageQueue();
        }
        delete msg;
    }
    else {
        fsmError(event, msg);
    }
}

updateStatusWaitAck()

void inet::Ieee802154Mac::updateStatusWaitAck ( t_mac_event  event, cMessage *  msg  )

protected

{
    assert(useMACAcks);
 
    switch (event) {
        case EV_ACK_RECEIVED: {
            EV_DETAIL << "(5) FSM State WAITACK_5, EV_ACK_RECEIVED: "
                      << " ProcessAck, manageQueue..." << endl;
            if (rxAckTimer->isScheduled())
                cancelEvent(rxAckTimer);
            deleteCurrentTxFrame();
            txAttempts = 0;
            delete msg;
            manageQueue();
            break;
        }
        case EV_ACK_TIMEOUT:
            EV_DETAIL << "(12) FSM State WAITACK_5, EV_ACK_TIMEOUT:"
                      << " incrementCounter/dropPacket, manageQueue..." << endl;
            manageMissingAck(event, msg);
            break;
 
        case EV_BROADCAST_RECEIVED:
        case EV_FRAME_RECEIVED:
            decapsulate(check_and_cast<Packet *>(msg));
            sendUp(msg);
            break;
 
        case EV_DUPLICATE_RECEIVED:
            EV_DETAIL << "Error ! Received a frame during SIFS !" << endl;
            delete msg;
            break;
 
        default:
            fsmError(event, msg);
            break;
    }
}

Member Data Documentation

ackLength

int inet::Ieee802154Mac::ackLength

protected

The bit length of the ACK packet.

ackMessage

Packet* inet::Ieee802154Mac::ackMessage

protected

aTurnaroundTime

simtime_t inet::Ieee802154Mac::aTurnaroundTime

protected

Time to switch radio from Rx to Tx state.

aUnitBackoffPeriod

simtime_t inet::Ieee802154Mac::aUnitBackoffPeriod

protected

base time unit for calculating backoff durations

backoffMethod

backoff_methods inet::Ieee802154Mac::backoffMethod

protected

Defines the backoff method to be used.

backoffTimer

cMessage* inet::Ieee802154Mac::backoffTimer

protected

backoffValues

double inet::Ieee802154Mac::backoffValues

protected

bitrate

double inet::Ieee802154Mac::bitrate

protected

the bit rate at which we transmit

ccaDetectionTime

simtime_t inet::Ieee802154Mac::ccaDetectionTime

protected

CCA detection time.

ccaTimer

cMessage * inet::Ieee802154Mac::ccaTimer

protected

headerLength

int inet::Ieee802154Mac::headerLength

protected

Length of the header.

initialCW

int inet::Ieee802154Mac::initialCW

protected

initial contention window size Only used for linear and constant backoff method.

macAckWaitDuration

simtime_t inet::Ieee802154Mac::macAckWaitDuration

protected

The amount of time the MAC waits for the ACK of a packet.

macMaxBE

int inet::Ieee802154Mac::macMaxBE

protected

Maximum backoff exponent.

Only used for exponential backoff method.

macMaxCSMABackoffs

int inet::Ieee802154Mac::macMaxCSMABackoffs

protected

maximum number of extra backoffs (excluding the first unconditional one) before frame drop

macMaxFrameRetries

unsigned int inet::Ieee802154Mac::macMaxFrameRetries

protected

maximum number of frame retransmissions without ack

macMinBE

int inet::Ieee802154Mac::macMinBE

protected

Minimum backoff exponent.

Only used for exponential backoff method.

macState

t_mac_states inet::Ieee802154Mac::macState

protected

keep track of MAC state

NB

int inet::Ieee802154Mac::NB

protected

number of backoff performed until now for current frame

nbBackoffs

long inet::Ieee802154Mac::nbBackoffs

protected

nbDroppedFrames

long inet::Ieee802154Mac::nbDroppedFrames

protected

nbDuplicates

long inet::Ieee802154Mac::nbDuplicates

protected

nbMissedAcks

long inet::Ieee802154Mac::nbMissedAcks

protected

nbRecvdAcks

long inet::Ieee802154Mac::nbRecvdAcks

protected

nbRxFrames

long inet::Ieee802154Mac::nbRxFrames

protected

nbTxAcks

long inet::Ieee802154Mac::nbTxAcks

protected

nbTxFrames

long inet::Ieee802154Mac::nbTxFrames

protected

radio

ModuleRefByPar<physicallayer::IRadio> inet::Ieee802154Mac::radio

protected

The radio.

rxAckTimer

cMessage * inet::Ieee802154Mac::rxAckTimer

protected

rxSetupTime

simtime_t inet::Ieee802154Mac::rxSetupTime

protected

Time to setup radio from sleep to Rx state.

SeqNrChild

std::map<MacAddress, unsigned long> inet::Ieee802154Mac::SeqNrChild

protected

SeqNrParent

std::map<MacAddress, unsigned long> inet::Ieee802154Mac::SeqNrParent

protected

sifs

simtime_t inet::Ieee802154Mac::sifs

protected

Maximum time between a packet and its ACK.

Usually this is slightly more then the tx-rx turnaround time The channel should stay clear within this period of time.

sifsTimer

cMessage * inet::Ieee802154Mac::sifsTimer

protected

status

t_mac_status inet::Ieee802154Mac::status

protected

transmissionAttemptInterruptedByRx

bool inet::Ieee802154Mac::transmissionAttemptInterruptedByRx

protected

transmissionState

physicallayer::IRadio::TransmissionState inet::Ieee802154Mac::transmissionState

protected

txAttempts

unsigned int inet::Ieee802154Mac::txAttempts

protected

count the number of tx attempts

This holds the number of transmission attempts for the current frame.

txPower

double inet::Ieee802154Mac::txPower

protected

The power (in mW) to transmit with.

useMACAcks

bool inet::Ieee802154Mac::useMACAcks

protected

Stores if the MAC expects Acks for Unicast packets.

---

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

• Ieee802154Mac.h
• Ieee802154Mac.cc