inet::CSMA Class Reference

Generic CSMA Mac-Layer. More...

#include <CSMA.h>

Inheritance diagram for inet::CSMA:

Public Member Functions
	CSMA ()
virtual	~CSMA ()
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 (cPacket *) override
	Handle messages from lower layer. More...
virtual void	handleUpperPacket (cPacket *) 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, long value, cObject *details) override
	Handle control messages from lower layer. More...
Public Member Functions inherited from inet::OperationalBase
	OperationalBase ()
Public Member Functions inherited from inet::ILifecycle
virtual	~ILifecycle ()
Public Member Functions inherited from inet::IMACProtocol
virtual	~IMACProtocol ()

Protected Types
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...
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...
typedef std::list< CSMAFrame * >	MacQueue

Protected Member Functions
virtual void	initializeMACAddress ()
	Generate new interface address. More...
virtual InterfaceEntry *	createInterfaceEntry () override
virtual void	handleCommand (cMessage *msg)
virtual void	flushQueue ()
virtual void	clearQueue ()
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 (CSMAFrame *mac, simtime_t_cref startTime)
void	manageMissingAck (t_mac_event event, cMessage *msg)
void	startTimer (t_mac_timer timer)
virtual simtime_t	scheduleBackoff ()
virtual cPacket *	decapsMsg (CSMAFrame *macPkt)
cObject *	setUpControlInfo (cMessage *const pMsg, const MACAddress &pSrcAddr)
	Attaches a "control info" (MacToNetw) structure (object) to the message pMsg. More...
Protected Member Functions inherited from inet::MACProtocolBase
	MACProtocolBase ()
virtual void	registerInterface ()
virtual void	sendUp (cMessage *message)
virtual void	sendDown (cMessage *message)
virtual bool	isUpperMessage (cMessage *message) override
virtual bool	isLowerMessage (cMessage *message) override
virtual bool	isInitializeStage (int stage) override
virtual bool	isNodeStartStage (int stage) override
virtual bool	isNodeShutdownStage (int stage) override
Protected Member Functions inherited from inet::LayeredProtocolBase
virtual void	handleMessageWhenUp (cMessage *message) override
virtual void	handleUpperCommand (cMessage *message)
virtual void	handleLowerCommand (cMessage *message)
Protected Member Functions inherited from inet::OperationalBase
virtual int	numInitStages () const override
virtual void	handleMessage (cMessage *msg) override
virtual void	handleMessageWhenDown (cMessage *msg)
virtual bool	handleOperationStage (LifecycleOperation *operation, int stage, IDoneCallback *doneCallback) override
	Perform one stage of a lifecycle operation. More...
virtual bool	handleNodeStart (IDoneCallback *doneCallback)
virtual bool	handleNodeShutdown (IDoneCallback *doneCallback)
virtual void	handleNodeCrash ()
virtual void	setOperational (bool isOperational)

Protected Attributes
t_mac_states	macState
	keep track of MAC state More...
t_mac_status	status
MACAddress	address
	The MAC address of the interface. More...
IRadio *	radio
	The radio. More...
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...
double	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...
MacQueue	macQueue
	A queue to store packets from upper layer in case another packet is still waiting for transmission. More...
unsigned int	queueLength
	length of the queue 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...
CSMAFrame *	ackMessage
std::map< MACAddress, unsigned long >	SeqNrParent
std::map< MACAddress, unsigned long >	SeqNrChild
Different tracked statistics.
long	nbTxFrames
long	nbRxFrames
long	nbMissedAcks
long	nbRecvdAcks
long	nbDroppedFrames
long	nbTxAcks
long	nbDuplicates
long	nbBackoffs
double	backoffValues
Pointer for timer messages.
cMessage *	backoffTimer
cMessage *	ccaTimer
cMessage *	sifsTimer
cMessage *	rxAckTimer
Protected Attributes inherited from inet::OperationalBase
bool	isOperational
simtime_t	lastChange

Private Member Functions
	CSMA (const CSMA &)
	Copy constructor is not allowed. More...
CSMA &	operator= (const CSMA &)
	Assignment operator is not allowed. More...

Additional Inherited Members
Public Attributes inherited from inet::MACProtocolBase
InterfaceEntry *	interfaceEntry
int	upperLayerInGateId
	Gate ids. More...
int	upperLayerOutGateId
int	lowerLayerInGateId
int	lowerLayerOutGateId
Static Public Attributes inherited from inet::LayeredProtocolBase
static simsignal_t	packetSentToUpperSignal = registerSignal("packetSentToUpper")
static simsignal_t	packetReceivedFromUpperSignal = registerSignal("packetReceivedFromUpper")
static simsignal_t	packetFromUpperDroppedSignal = registerSignal("packetFromUpperDropped")
static simsignal_t	packetSentToLowerSignal = registerSignal("packetSentToLower")
static simsignal_t	packetReceivedFromLowerSignal = registerSignal("packetReceivedFromLower")
static simsignal_t	packetFromLowerDroppedSignal = registerSignal("packetFromLowerDropped")

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 Typedef Documentation

typedef std::list<CSMAFrame *> inet::CSMA::MacQueue

protected

Member Enumeration Documentation

enum inet::CSMA::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,
    };

enum inet::CSMA::t_csma_frame_types

protected

Types for frames sent by the CSMA.

Enumerator
DATA
ACK

                            {
        DATA,
        ACK
    };

enum inet::CSMA::t_mac_carrier_sensed

protected

Enumerator
CHANNEL_BUSY
CHANNEL_FREE

                              {
        CHANNEL_BUSY = 1,
        CHANNEL_FREE
    };

enum inet::CSMA::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
    };

enum inet::CSMA::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
    };

enum inet::CSMA::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
    };

enum inet::CSMA::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

inet::CSMA::CSMA ( )

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)
        , radio(nullptr)
        , transmissionState(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)
        , macQueue()
        , queueLength(0)
        , txAttempts(0)
        , bitrate(0)
        , ackLength(0)
        , ackMessage(nullptr)
        , SeqNrParent()
        , SeqNrChild()
    {}

inet::CSMA::~CSMA ( )

virtual

{
    cancelAndDelete(backoffTimer);
    cancelAndDelete(ccaTimer);
    cancelAndDelete(sifsTimer);
    cancelAndDelete(rxAckTimer);
    if (ackMessage)
        delete ackMessage;
    for (auto & elem : macQueue) {
        delete (elem);
    }
}

inet::CSMA::CSMA ( const CSMA &  )

private

Copy constructor is not allowed.

Member Function Documentation

void inet::CSMA::attachSignal ( CSMAFrame *  mac, simtime_t_cref  startTime  )

protected

Referenced by updateStatusCCA(), and updateStatusSIFS().

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

void inet::CSMA::clearQueue ( )

protectedvirtual

{
    macQueue.clear();
}

InterfaceEntry * inet::CSMA::createInterfaceEntry ( )

overrideprotectedvirtual

Implements inet::MACProtocolBase.

{
    InterfaceEntry *e = new InterfaceEntry(this);

    // data rate
    e->setDatarate(bitrate);

    // generate a link-layer address to be used as interface token for IPv6
    e->setMACAddress(address);
    e->setInterfaceToken(address.formInterfaceIdentifier());

    // capabilities
    e->setMtu(par("mtu").longValue());
    e->setMulticast(false);
    e->setBroadcast(true);

    return e;
}

cPacket * inet::CSMA::decapsMsg ( CSMAFrame *  macPkt )

protectedvirtual

Referenced by updateStatusBackoff(), updateStatusCCA(), updateStatusIdle(), updateStatusSIFS(), and updateStatusWaitAck().

{
    cPacket *msg = macPkt->decapsulate();
    setUpControlInfo(msg, macPkt->getSrcAddr());

    return msg;
}

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

protected

Updates state machine.

Referenced by handleLowerPacket(), handleSelfMessage(), handleUpperPacket(), and receiveSignal().

{
    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;
        }
    }
}

void inet::CSMA::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);
}

void inet::CSMA::flushQueue ( )

protectedvirtual

{
    // TODO:
    macQueue.clear();
}

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

protected

Referenced by updateStatusBackoff(), updateStatusCCA(), updateStatusIdle(), updateStatusSIFS(), updateStatusTransmitAck(), updateStatusTransmitFrame(), and updateStatusWaitAck().

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

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

inlineprotectedvirtual

{}

void inet::CSMA::handleLowerPacket ( cPacket *  msg )

overridevirtual

Handle messages from lower layer.

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

Generates the corresponding event.

Implements inet::LayeredProtocolBase.

{
    if (msg->hasBitError()) {
        EV << "Received " << msg << " contains bit errors or collision, dropping it\n";
        delete msg;
        return;
    }
    CSMAFrame *macPkt = static_cast<CSMAFrame *>(msg);
    const MACAddress& src = macPkt->getSrcAddr();
    const MACAddress& dest = macPkt->getDestAddr();
    long ExpectedNr = 0;

    EV_DETAIL << "Received frame name= " << macPkt->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, macPkt);
        }
        else {
            long SeqNr = macPkt->getSequenceId();

            if (strcmp(macPkt->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;
                ackMessage = new CSMAFrame("CSMA-Ack");
                ackMessage->setSrcAddr(address);
                ackMessage->setDestAddr(src);
                ackMessage->setBitLength(ackLength);
                //Check for duplicates by checking expected seqNr of sender
                if (SeqNrChild.find(src) == SeqNrChild.end()) {
                    //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, macPkt);
                }
                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, macPkt);
                    }
                    else {
                        SeqNrChild[src] = SeqNr + 1;
                        executeMac(EV_FRAME_RECEIVED, macPkt);
                    }
                }
            }
            else if (macQueue.size() != 0) {
                // message is an ack, and it is for us.
                // Is it from the right node ?
                CSMAFrame *firstPacket = static_cast<CSMAFrame *>(macQueue.front());
                if (src == firstPacket->getDestAddr()) {
                    nbRecvdAcks++;
                    executeMac(EV_ACK_RECEIVED, macPkt);
                }
                else {
                    EV << "Error! Received an ack from an unexpected source: src=" << src << ", I was expecting from node addr=" << firstPacket->getDestAddr() << endl;
                    delete macPkt;
                }
            }
            else {
                EV << "Error! Received an Ack while my send queue was empty. src=" << src << "." << endl;
                delete macPkt;
            }
        }
    }
    else if (dest.isBroadcast()) {
        executeMac(EV_BROADCAST_RECEIVED, macPkt);
    }
    else {
        EV_DETAIL << "packet not for me, deleting...\n";
        delete macPkt;
    }
}

void inet::CSMA::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;
}

void inet::CSMA::handleUpperPacket ( cPacket *  msg )

overridevirtual

Handle messages from upper layer.

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

Implements inet::LayeredProtocolBase.

{
    //MacPkt*macPkt = encapsMsg(msg);
    CSMAFrame *macPkt = new CSMAFrame(msg->getName());
    macPkt->setBitLength(headerLength);
    IMACProtocolControlInfo *const cInfo = check_and_cast<IMACProtocolControlInfo *>(msg->removeControlInfo());
    EV_DETAIL << "CSMA received a message from upper layer, name is " << msg->getName() << ", CInfo removed, mac addr=" << cInfo->getDestinationAddress() << endl;
    MACAddress dest = cInfo->getDestinationAddress();
    macPkt->setDestAddr(dest);
    delete cInfo;
    macPkt->setSrcAddr(address);

    if (useMACAcks) {
        if (SeqNrParent.find(dest) == SeqNrParent.end()) {
            //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]++;
        }
    }

    //RadioAccNoise3PhyControlInfo *pco = new RadioAccNoise3PhyControlInfo(bitrate);
    //macPkt->setControlInfo(pco);
    assert(static_cast<cPacket *>(msg));
    macPkt->encapsulate(static_cast<cPacket *>(msg));
    EV_DETAIL << "pkt encapsulated, length: " << macPkt->getBitLength() << "\n";
    executeMac(EV_SEND_REQUEST, macPkt);
}

void inet::CSMA::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").boolValue();
        queueLength = par("queueLength");
        sifs = par("sifs");
        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").doubleValue();
        aUnitBackoffPeriod = par("aUnitBackoffPeriod").doubleValue();
        ccaDetectionTime = par("ccaDetectionTime").doubleValue();
        rxSetupTime = par("rxSetupTime").doubleValue();
        aTurnaroundTime = par("aTurnaroundTime").doubleValue();
        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;

        initializeMACAddress();
        registerInterface();

        cModule *radioModule = getModuleFromPar<cModule>(par("radioModule"), this);
        radioModule->subscribe(IRadio::radioModeChangedSignal, this);
        radioModule->subscribe(IRadio::transmissionStateChangedSignal, this);
        radio = check_and_cast<IRadio *>(radioModule);

        //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").doubleValue();
            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));
            }
        }
    }
    else if (stage == INITSTAGE_LINK_LAYER) {
        radio->setRadioMode(IRadio::RADIO_MODE_RECEIVER);
        EV_DETAIL << "queueLength = " << queueLength
                  << " bitrate = " << bitrate
                  << " backoff method = " << par("backoffMethod").stringValue() << endl;

        EV_DETAIL << "finished csma init stage 1." << endl;
    }
}

void inet::CSMA::initializeMACAddress ( )

protectedvirtual

Generate new interface address.

Referenced by initialize().

{
    const char *addrstr = par("address");

    if (!strcmp(addrstr, "auto")) {
        // assign automatic address
        address = MACAddress::generateAutoAddress();

        // change module parameter from "auto" to concrete address
        par("address").setStringValue(address.str().c_str());
    }
    else {
        address.setAddress(addrstr);
    }
}

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

protected

Referenced by updateStatusWaitAck().

{
    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;
        cMessage *mac = macQueue.front();
        macQueue.pop_front();
        txAttempts = 0;
        // TODO: send dropped signal
        // emit(packetDropped, mac);
        emit(NF_LINK_BREAK, mac);
        delete mac;
    }
    manageQueue();
}

void inet::CSMA::manageQueue ( )

protected

Referenced by manageMissingAck(), updateStatusCCA(), updateStatusTransmitAck(), updateStatusTransmitFrame(), and updateStatusWaitAck().

{
    if (macQueue.size() != 0) {
        EV_DETAIL << "(manageQueue) there are " << macQueue.size() << " 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);
    }
}

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

private

Assignment operator is not allowed.

void inet::CSMA::receiveSignal ( cComponent *  source, simsignal_t  signalID, long  value, cObject *  details  )

overridevirtual

Handle control messages from lower layer.

{
    Enter_Method_Silent();
    if (signalID == IRadio::transmissionStateChangedSignal) {
        IRadio::TransmissionState newRadioTransmissionState = (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;
    }
}

simtime_t inet::CSMA::scheduleBackoff ( )

protectedvirtual

Referenced by startTimer().

{
    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 + simTime();
}

cObject * inet::CSMA::setUpControlInfo ( cMessage *const  pMsg, const MACAddress &  pSrcAddr  )

protected

Attaches a "control info" (MacToNetw) structure (object) to the message pMsg.

Referenced by decapsMsg().

{
    SimpleLinkLayerControlInfo *const cCtrlInfo = new SimpleLinkLayerControlInfo();
    cCtrlInfo->setSrc(pSrcAddr);
    pMsg->setControlInfo(cCtrlInfo);
    return cCtrlInfo;
}

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

protected

Referenced by manageQueue(), updateStatusBackoff(), updateStatusCCA(), updateStatusIdle(), updateStatusSIFS(), and updateStatusTransmitFrame().

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

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

protected

Referenced by manageQueue(), updateStatusBackoff(), updateStatusCCA(), updateStatusIdle(), updateStatusSIFS(), and updateStatusTransmitFrame().

{
    macState = newMacState;
}

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

protected

Referenced by executeMac().

{
    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.";
            }
            sendUp(decapsMsg(static_cast<CSMAFrame *>(msg)));
            delete msg;
            break;

        case EV_BROADCAST_RECEIVED:
            EV_DETAIL << "(29) FSM State BACKOFF, EV_BROADCAST_RECEIVED:"
                      << "sending frame up and resuming normal operation." << endl;
            sendUp(decapsMsg(static_cast<CSMAFrame *>(msg)));
            delete msg;
            break;

        default:
            fsmError(event, msg);
            break;
    }
}

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

protected

Referenced by executeMac().

{
    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);
                CSMAFrame *mac = check_and_cast<CSMAFrame *>(macQueue.front()->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;
                    cMessage *mac = macQueue.front();
                    macQueue.pop_front();
                    txAttempts = 0;
                    nbDroppedFrames++;
                    emit(packetFromUpperDroppedSignal, mac);
                    delete mac;
                    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;
            }
            sendUp(decapsMsg(static_cast<CSMAFrame *>(msg)));
            delete msg;
            break;

        case EV_BROADCAST_RECEIVED:
            EV_DETAIL << "(24) FSM State BACKOFF, EV_BROADCAST_RECEIVED:"
                      << " Nothing to do." << endl;
            sendUp(decapsMsg(static_cast<CSMAFrame *>(msg)));
            delete msg;
            break;

        default:
            fsmError(event, msg);
            break;
    }
}

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

protected

Referenced by executeMac().

{
    switch (event) {
        case EV_SEND_REQUEST:
            if (macQueue.size() <= queueLength) {
                macQueue.push_back(static_cast<CSMAFrame *>(msg));
                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);
            }
            else {
                // queue is full, message has to be deleted
                EV_DETAIL << "(12) FSM State IDLE_1, EV_SEND_REQUEST and [TxBuff not avail]: dropping packet -> IDLE." << endl;
                emit(packetFromUpperDroppedSignal, msg);
                delete msg;
                updateMacState(IDLE_1);
            }
            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;
            sendUp(decapsMsg(static_cast<CSMAFrame *>(msg)));
            nbRxFrames++;
            delete msg;

            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++;
            sendUp(decapsMsg(static_cast<CSMAFrame *>(msg)));
            delete msg;
            break;

        default:
            fsmError(event, msg);
            break;
    }
}

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

protected

Referenced by executeMac().

{
    EV_DETAIL << "(20) FSM State NOT IDLE, EV_SEND_REQUEST. Is a TxBuffer available ?" << endl;
    if (macQueue.size() <= queueLength) {
        macQueue.push_back(static_cast<CSMAFrame *>(msg));
        EV_DETAIL << "(21) FSM State NOT IDLE, EV_SEND_REQUEST"
                  << " and [TxBuff avail]: enqueue packet and don't move." << endl;
    }
    else {
        // queue is full, message has to be deleted
        EV_DETAIL << "(22) FSM State NOT IDLE, EV_SEND_REQUEST"
                  << " and [TxBuff not avail]: dropping packet and don't move."
                  << endl;
        // TODO: send dropped signal
        // emit(packetDropped, msg);
        delete msg;
    }
}

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

protected

Referenced by executeMac().

{
    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;
            sendUp(decapsMsg(static_cast<CSMAFrame *>(msg)));
            delete msg;
            break;

        default:
            fsmError(event, msg);
            break;
    }
}

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

protected

Referenced by executeMac().

{
    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);
    }
}

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

protected

Referenced by executeMac().

{
    if (event == EV_FRAME_TRANSMITTED) {
        //    delete msg;
        CSMAFrame *packet = macQueue.front();
        radio->setRadioMode(IRadio::RADIO_MODE_RECEIVER);

        bool expectAck = useMACAcks;
        if (!packet->getDestAddr().isBroadcast()) {
            //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;
            macQueue.pop_front();
            delete packet;
            manageQueue();
        }
        delete msg;
    }
    else {
        fsmError(event, msg);
    }
}

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

protected

Referenced by executeMac().

{
    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);
            cMessage *mac = macQueue.front();
            macQueue.pop_front();
            txAttempts = 0;
            delete mac;
            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:
            sendUp(decapsMsg(static_cast<CSMAFrame *>(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

int inet::CSMA::ackLength

protected

The bit length of the ACK packet.

Referenced by handleLowerPacket(), and initialize().

CSMAFrame* inet::CSMA::ackMessage

protected

Referenced by handleLowerPacket(), initialize(), updateStatusSIFS(), and ~CSMA().

MACAddress inet::CSMA::address

protected

The MAC address of the interface.

Referenced by createInterfaceEntry(), handleLowerPacket(), handleUpperPacket(), and initializeMACAddress().

simtime_t inet::CSMA::aTurnaroundTime

protected

Time to switch radio from Rx to Tx state.

Referenced by initialize(), and updateStatusCCA().

simtime_t inet::CSMA::aUnitBackoffPeriod

protected

base time unit for calculating backoff durations

Referenced by initialize(), and scheduleBackoff().

backoff_methods inet::CSMA::backoffMethod

protected

Defines the backoff method to be used.

Referenced by initialize(), and scheduleBackoff().

cMessage* inet::CSMA::backoffTimer

protected

Referenced by handleSelfMessage(), initialize(), manageQueue(), startTimer(), updateStatusBackoff(), and ~CSMA().

double inet::CSMA::backoffValues

protected

Referenced by finish(), initialize(), and scheduleBackoff().

double inet::CSMA::bitrate

protected

the bit rate at which we transmit

Referenced by attachSignal(), createInterfaceEntry(), and initialize().

simtime_t inet::CSMA::ccaDetectionTime

protected

CCA detection time.

Referenced by initialize(), and startTimer().

cMessage * inet::CSMA::ccaTimer

protected

Referenced by handleSelfMessage(), initialize(), startTimer(), updateStatusCCA(), and ~CSMA().

int inet::CSMA::headerLength

protected

Length of the header.

Referenced by handleUpperPacket().

double inet::CSMA::initialCW

protected

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

Referenced by initialize(), and scheduleBackoff().

simtime_t inet::CSMA::macAckWaitDuration

protected

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

Referenced by initialize(), and startTimer().

int inet::CSMA::macMaxBE

protected

Maximum backoff exponent.

Only used for exponential backoff method.

Referenced by initialize(), and scheduleBackoff().

int inet::CSMA::macMaxCSMABackoffs

protected

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

Referenced by initialize(), and updateStatusCCA().

unsigned int inet::CSMA::macMaxFrameRetries

protected

maximum number of frame retransmissions without ack

Referenced by initialize(), and manageMissingAck().

int inet::CSMA::macMinBE

protected

Minimum backoff exponent.

Only used for exponential backoff method.

Referenced by initialize(), and scheduleBackoff().

MacQueue inet::CSMA::macQueue

protected

A queue to store packets from upper layer in case another packet is still waiting for transmission.

Referenced by clearQueue(), flushQueue(), handleLowerPacket(), manageMissingAck(), manageQueue(), updateStatusCCA(), updateStatusIdle(), updateStatusNotIdle(), updateStatusTransmitFrame(), updateStatusWaitAck(), and ~CSMA().

t_mac_states inet::CSMA::macState

protected

keep track of MAC state

Referenced by executeMac(), fsmError(), handleLowerPacket(), initialize(), and updateMacState().

int inet::CSMA::NB

protected

number of backoff performed until now for current frame

Referenced by initialize(), manageQueue(), scheduleBackoff(), updateStatusCCA(), and updateStatusIdle().

long inet::CSMA::nbBackoffs

protected

Referenced by finish(), initialize(), and scheduleBackoff().

long inet::CSMA::nbDroppedFrames

protected

Referenced by finish(), initialize(), and updateStatusCCA().

long inet::CSMA::nbDuplicates

protected

Referenced by finish(), handleLowerPacket(), and initialize().

long inet::CSMA::nbMissedAcks

protected

Referenced by finish(), handleSelfMessage(), and initialize().

long inet::CSMA::nbRecvdAcks

protected

Referenced by finish(), handleLowerPacket(), and initialize().

long inet::CSMA::nbRxFrames

protected

Referenced by finish(), initialize(), and updateStatusIdle().

long inet::CSMA::nbTxAcks

protected

Referenced by finish(), initialize(), and updateStatusSIFS().

long inet::CSMA::nbTxFrames

protected

Referenced by finish(), initialize(), and updateStatusCCA().

unsigned int inet::CSMA::queueLength

protected

length of the queue

Referenced by initialize(), updateStatusIdle(), and updateStatusNotIdle().

IRadio* inet::CSMA::radio

protected

The radio.

Referenced by initialize(), updateStatusBackoff(), updateStatusCCA(), updateStatusIdle(), updateStatusTransmitAck(), and updateStatusTransmitFrame().

cMessage * inet::CSMA::rxAckTimer

protected

Referenced by handleSelfMessage(), initialize(), startTimer(), updateStatusWaitAck(), and ~CSMA().

simtime_t inet::CSMA::rxSetupTime

protected

Time to setup radio from sleep to Rx state.

Referenced by initialize(), and startTimer().

std::map<MACAddress, unsigned long> inet::CSMA::SeqNrChild

protected

Referenced by handleLowerPacket().

std::map<MACAddress, unsigned long> inet::CSMA::SeqNrParent

protected

Referenced by handleUpperPacket().

simtime_t inet::CSMA::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.

Referenced by initialize(), and startTimer().

cMessage * inet::CSMA::sifsTimer

protected

Referenced by handleSelfMessage(), initialize(), startTimer(), and ~CSMA().

t_mac_status inet::CSMA::status

protected

bool inet::CSMA::transmissionAttemptInterruptedByRx

protected

Referenced by initialize(), manageQueue(), updateStatusBackoff(), and updateStatusCCA().

IRadio::TransmissionState inet::CSMA::transmissionState

protected

Referenced by receiveSignal().

unsigned int inet::CSMA::txAttempts

protected

count the number of tx attempts

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

Referenced by initialize(), manageMissingAck(), updateStatusCCA(), and updateStatusWaitAck().

double inet::CSMA::txPower

protected

The power (in mW) to transmit with.

bool inet::CSMA::useMACAcks

protected

Stores if the MAC expects Acks for Unicast packets.

Referenced by handleLowerPacket(), handleUpperPacket(), initialize(), startTimer(), updateStatusBackoff(), updateStatusCCA(), updateStatusIdle(), updateStatusSIFS(), updateStatusTransmitAck(), updateStatusTransmitFrame(), and updateStatusWaitAck().

---

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

• CSMA.h
• CSMA.cc