#include <CsmaCaMac.h>

Inheritance diagram for inet::CsmaCaMac:

Public Member Functions
Construction functions
virtual	~CsmaCaMac ()

Public Member Functions inherited from inet::OperationalBase
	OperationalBase ()

Public Member Functions inherited from inet::ILifecycle
virtual	~ILifecycle ()

Protected Member Functions
Initialization functions
virtual void	initialize (int stage) override
	Initialization of the module and its variables. More...

virtual void	initializeQueueModule ()

virtual void	finish () override

virtual InterfaceEntry *	createInterfaceEntry () override

Message handing functions
Functions called from other classes to notify about state changes and to handle messages.
virtual void	handleSelfMessage (cMessage *msg) override

virtual void	handleUpperPacket (cPacket *msg) override

virtual void	handleLowerPacket (cPacket *msg) override

virtual void	handleWithFsm (cMessage *msg)

virtual void	receiveSignal (cComponent source, simsignal_t signalID, long value, cObject details) override

virtual CsmaCaMacDataFrame *	encapsulate (cPacket *msg)

virtual cPacket *	decapsulate (CsmaCaMacDataFrame *frame)

Timer functions
These functions have the side effect of starting the corresponding timers.
virtual void	scheduleSifsTimer (CsmaCaMacFrame *frame)

virtual void	scheduleDifsTimer ()

virtual void	cancelDifsTimer ()

virtual void	scheduleAckTimeout (CsmaCaMacDataFrame *frame)

virtual void	cancelAckTimer ()

virtual void	invalidateBackoffPeriod ()

virtual bool	isInvalidBackoffPeriod ()

virtual void	generateBackoffPeriod ()

virtual void	decreaseBackoffPeriod ()

virtual void	scheduleBackoffTimer ()

virtual void	cancelBackoffTimer ()

Frame transmission functions
virtual void	sendDataFrame (CsmaCaMacDataFrame *frameToSend)

virtual void	sendAckFrame ()

Utility functions
virtual void	finishCurrentTransmission ()

virtual void	giveUpCurrentTransmission ()

virtual void	retryCurrentTransmission ()

virtual CsmaCaMacDataFrame *	getCurrentTransmission ()

virtual void	popTransmissionQueue ()

virtual void	resetStateVariables ()

virtual bool	isMediumFree ()

virtual bool	isReceiving ()

virtual bool	isAck (CsmaCaMacFrame *frame)

virtual bool	isBroadcast (CsmaCaMacFrame *msg)

virtual bool	isForUs (CsmaCaMacFrame *msg)

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
Configuration parameters
MACAddress	address

bool	useAck = true

double	bitrate = NaN

int	headerLength = -1

int	ackLength = -1

simtime_t	ackTimeout = -1

simtime_t	slotTime = -1

simtime_t	sifsTime = -1

simtime_t	difsTime = -1

int	maxQueueSize = -1

int	retryLimit = -1

int	cwMin = -1

int	cwMax = -1

int	cwMulticast = -1

Timer messages
cMessage *	endSifs = nullptr
	End of the Short Inter-Frame Time period. More...

cMessage *	endDifs = nullptr
	End of the Data Inter-Frame Time period. More...

cMessage *	endBackoff = nullptr
	End of the backoff period. More...

cMessage *	endAckTimeout = nullptr
	End of the ack timeout. More...

cMessage *	endData = nullptr
	Timeout after the transmission of a Data frame. More...

cMessage *	mediumStateChange = nullptr
	Radio state change self message. More...

Statistics
long	numRetry

long	numSentWithoutRetry

long	numGivenUp

long	numCollision

long	numSent

long	numReceived

long	numSentBroadcast

long	numReceivedBroadcast

Protected Attributes inherited from inet::OperationalBase
bool	isOperational

simtime_t	lastChange

CsmaCaMac state variables
Various state information checked and modified according to the state machine.
enum	State { IDLE, DEFER, WAITDIFS, BACKOFF, TRANSMIT, WAITACK, RECEIVE, WAITSIFS }

IRadio *	radio = nullptr

IRadio::TransmissionState	transmissionState = IRadio::TRANSMISSION_STATE_UNDEFINED

cFSM	fsm

simtime_t	backoffPeriod = -1
	Remaining backoff period in seconds. More...

int	retryCounter = -1
	Number of frame retransmission attempts. More...

PacketQueue	transmissionQueue
	Messages received from upper layer and to be transmitted later. More...

IPassiveQueue *	queueModule = nullptr
	Passive queue module to request messages from. 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")

Member Enumeration Documentation

enum inet::CsmaCaMac::State

protected

Enumerator
IDLE
DEFER
WAITDIFS
BACKOFF
TRANSMIT
WAITACK
RECEIVE
WAITSIFS

                {
         IDLE,
         DEFER,
         WAITDIFS,
         BACKOFF,
         TRANSMIT,
         WAITACK,
         RECEIVE,
         WAITSIFS,
     };

Constructor & Destructor Documentation

inet::CsmaCaMac::~CsmaCaMac ( )

virtual

 {
     cancelAndDelete(endSifs);
     cancelAndDelete(endDifs);
     cancelAndDelete(endBackoff);
     cancelAndDelete(endAckTimeout);
     cancelAndDelete(endData);
     cancelAndDelete(mediumStateChange);
 }

Member Function Documentation

void inet::CsmaCaMac::cancelAckTimer ( )

protectedvirtual

Referenced by handleWithFsm().

 {
     EV << "canceling ACK timer\n";
     cancelEvent(endAckTimeout);
 }

void inet::CsmaCaMac::cancelBackoffTimer ( )

protectedvirtual

Referenced by handleWithFsm().

 {
     EV << "canceling backoff timer\n";
     cancelEvent(endBackoff);
 }

void inet::CsmaCaMac::cancelDifsTimer ( )

protectedvirtual

Referenced by handleWithFsm().

 {
     EV << "canceling DIFS timer\n";
     cancelEvent(endDifs);
 }

InterfaceEntry * inet::CsmaCaMac::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"));
     e->setMulticast(true);
     e->setBroadcast(true);
     e->setPointToPoint(false);
 
     return e;
 }

cPacket * inet::CsmaCaMac::decapsulate ( CsmaCaMacDataFrame * frame )

protectedvirtual

Referenced by handleWithFsm().

 {
     cPacket *payload = frame->decapsulate();
 
     Ieee802Ctrl *ctrl = new Ieee802Ctrl();
     ctrl->setSrc(frame->getTransmitterAddress());
     ctrl->setDest(frame->getReceiverAddress());
     ctrl->setUserPriority(frame->getPriority());
     payload->setControlInfo(ctrl);
 
     delete frame;
     return payload;
 }

void inet::CsmaCaMac::decreaseBackoffPeriod ( )

protectedvirtual

Referenced by handleWithFsm().

 {
     simtime_t elapsedBackoffTime = simTime() - endBackoff->getSendingTime();
     backoffPeriod -= ((int)(elapsedBackoffTime / slotTime)) * slotTime;
     ASSERT(backoffPeriod >= 0);
     EV << "backoff period decreased to " << backoffPeriod << endl;
 }

CsmaCaMacDataFrame * inet::CsmaCaMac::encapsulate ( cPacket * msg )

protectedvirtual

Referenced by handleUpperPacket().

 {
     CsmaCaMacDataFrame *frame = new CsmaCaMacDataFrame(msg->getName());
     frame->setByteLength(headerLength);
     // TODO: kludge to make isUpperMessage work
     frame->setArrival(msg->getArrivalModuleId(), msg->getArrivalGateId());
 
     Ieee802Ctrl *ctrl = check_and_cast<Ieee802Ctrl *>(msg->removeControlInfo());
     frame->setTransmitterAddress(address);
     frame->setReceiverAddress(ctrl->getDest());
     int up = ctrl->getUserPriority();
     frame->setPriority(up == -1 ? UP_BE : up);  // -1 is unset
     delete ctrl;
 
     frame->encapsulate(msg);
     return frame;
 }

void inet::CsmaCaMac::finish ( )

overrideprotectedvirtual

 {
     recordScalar("numRetry", numRetry);
     recordScalar("numSentWithoutRetry", numSentWithoutRetry);
     recordScalar("numGivenUp", numGivenUp);
     recordScalar("numCollision", numCollision);
     recordScalar("numSent", numSent);
     recordScalar("numReceived", numReceived);
     recordScalar("numSentBroadcast", numSentBroadcast);
     recordScalar("numReceivedBroadcast", numReceivedBroadcast);
 }

void inet::CsmaCaMac::finishCurrentTransmission ( )

protectedvirtual

Referenced by handleWithFsm().

 {
     popTransmissionQueue();
     resetStateVariables();
 }

void inet::CsmaCaMac::generateBackoffPeriod ( )

protectedvirtual

Referenced by retryCurrentTransmission(), and scheduleBackoffTimer().

 {
     ASSERT(0 <= retryCounter && retryCounter <= retryLimit);
     EV << "generating backoff slot number for retry: " << retryCounter << endl;
     int cw;
     if (getCurrentTransmission()->getReceiverAddress().isMulticast())
         cw = cwMulticast;
     else
         cw = std::min(cwMax, (cwMin + 1) * (1 << retryCounter) - 1);
     int slots = intrand(cw + 1);
     EV << "generated backoff slot number: " << slots << " , cw: " << cw << endl;
     backoffPeriod = slots * slotTime;
     ASSERT(backoffPeriod >= 0);
     EV << "backoff period set to " << backoffPeriod << endl;
 }

CsmaCaMacDataFrame * inet::CsmaCaMac::getCurrentTransmission ( )

protectedvirtual

Referenced by generateBackoffPeriod(), giveUpCurrentTransmission(), and handleWithFsm().

 {
     return static_cast<CsmaCaMacDataFrame*>(transmissionQueue.front());
 }

void inet::CsmaCaMac::giveUpCurrentTransmission ( )

protectedvirtual

Referenced by handleWithFsm().

 {
     emit(NF_LINK_BREAK, getCurrentTransmission());
     popTransmissionQueue();
     resetStateVariables();
     numGivenUp++;
 }

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

overrideprotectedvirtual

Implements inet::LayeredProtocolBase.

 {
     EV << "received message from lower layer: " << msg << endl;
 
     CsmaCaMacFrame *frame = check_and_cast<CsmaCaMacFrame *>(msg);
     EV << "Self address: " << address
        << ", receiver address: " << frame->getReceiverAddress()
        << ", received frame is for us: " << isForUs(frame) << endl;
 
     handleWithFsm(msg);
 }

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

overrideprotectedvirtual

Reimplemented from inet::LayeredProtocolBase.

 {
     EV << "received self message: " << msg << endl;
     handleWithFsm(msg);
 }

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

overrideprotectedvirtual

Implements inet::LayeredProtocolBase.

 {
     if (maxQueueSize != -1 && (int)transmissionQueue.getLength() == maxQueueSize) {
         EV << "message " << msg << " received from higher layer but MAC queue is full, dropping message\n";
         emit(LayeredProtocolBase::packetFromUpperDroppedSignal, msg);
         delete msg;
         return;
     }
     CsmaCaMacDataFrame *frame = encapsulate(msg);
     EV << "frame " << frame << " received from higher layer, receiver = " << frame->getReceiverAddress() << endl;
     ASSERT(!frame->getReceiverAddress().isUnspecified());
     transmissionQueue.insert(frame);
     if (fsm.getState() != IDLE)
         EV << "deferring upper message transmission in " << fsm.getStateName() << " state\n";
     else
         handleWithFsm(frame);
 }

void inet::CsmaCaMac::handleWithFsm ( cMessage * msg )

protectedvirtual

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

 {
     CsmaCaMacFrame *frame = dynamic_cast<CsmaCaMacFrame*>(msg);
     FSMA_Switch(fsm)
     {
         FSMA_State(IDLE)
         {
             FSMA_Event_Transition(Defer-Transmit,
                                   isUpperMessage(msg) && !isMediumFree(),
                                   DEFER,
             );
             FSMA_Event_Transition(Start-Backoff,
                                   isUpperMessage(msg) && isMediumFree() && !useAck,
                                   BACKOFF,
             );
             FSMA_Event_Transition(Start-Difs,
                                   isUpperMessage(msg) && isMediumFree() && useAck,
                                   WAITDIFS,
             );
             FSMA_Event_Transition(Start-Receive,
                                   msg == mediumStateChange && isReceiving(),
                                   RECEIVE,
             );
         }
         FSMA_State(DEFER)
         {
             FSMA_Event_Transition(Start-Backoff,
                                   msg == mediumStateChange && isMediumFree() && !useAck,
                                   BACKOFF,
             );
             FSMA_Event_Transition(Start-Difs,
                                   msg == mediumStateChange && isMediumFree() && useAck,
                                   WAITDIFS,
             );
             FSMA_Event_Transition(Start-Receive,
                                   msg == mediumStateChange && isReceiving(),
                                   RECEIVE,
             );
         }
         FSMA_State(WAITDIFS)
         {
             FSMA_Enter(scheduleDifsTimer());
             FSMA_Event_Transition(Start-Backoff,
                                   msg == endDifs,
                                   BACKOFF,
             );
             FSMA_Event_Transition(Start-Receive,
                                   msg == mediumStateChange && isReceiving(),
                                   RECEIVE,
                 cancelDifsTimer();
             );
             FSMA_Event_Transition(Defer-Difs,
                                   msg == mediumStateChange && !isMediumFree(),
                                   DEFER,
                 cancelDifsTimer();
             );
         }
         FSMA_State(BACKOFF)
         {
             FSMA_Enter(scheduleBackoffTimer());
             FSMA_Event_Transition(Start-Transmit,
                                   msg == endBackoff,
                                   TRANSMIT,
                 invalidateBackoffPeriod();
             );
             FSMA_Event_Transition(Start-Receive,
                                   msg == mediumStateChange && isReceiving(),
                                   RECEIVE,
                 cancelBackoffTimer();
                 decreaseBackoffPeriod();
             );
             FSMA_Event_Transition(Defer-Backoff,
                                   msg == mediumStateChange && !isMediumFree(),
                                   DEFER,
                 cancelBackoffTimer();
                 decreaseBackoffPeriod();
             );
         }
         FSMA_State(TRANSMIT)
         {
             FSMA_Enter(sendDataFrame(getCurrentTransmission()));
             FSMA_Event_Transition(Transmit-Broadcast,
                                   msg == endData && isBroadcast(getCurrentTransmission()),
                                   IDLE,
                 finishCurrentTransmission();
                 numSentBroadcast++;
             );
             FSMA_Event_Transition(Transmit-Unicast-No-Ack,
                                   msg == endData && !useAck && !isBroadcast(getCurrentTransmission()),
                                   IDLE,
                 finishCurrentTransmission();
                 numSent++;
             );
             FSMA_Event_Transition(Transmit-Unicast-Use-Ack,
                                   msg == endData && useAck && !isBroadcast(getCurrentTransmission()),
                                   WAITACK,
             );
         }
         FSMA_State(WAITACK)
         {
             FSMA_Enter(scheduleAckTimeout(getCurrentTransmission()));
             FSMA_Event_Transition(Receive-Ack,
                                   isLowerMessage(msg) && isForUs(frame) && isAck(frame),
                                   IDLE,
                 if (retryCounter == 0) numSentWithoutRetry++;
                 numSent++;
                 cancelAckTimer();
                 finishCurrentTransmission();
                 delete frame;
             );
             FSMA_Event_Transition(Give-Up-Transmission,
                                   msg == endAckTimeout && retryCounter == retryLimit,
                                   IDLE,
                 giveUpCurrentTransmission();
             );
             FSMA_Event_Transition(Retry-Transmission,
                                   msg == endAckTimeout,
                                   IDLE,
                 retryCurrentTransmission();
             );
         }
         FSMA_State(RECEIVE)
         {
             FSMA_Event_Transition(Receive-Bit-Error,
                                   isLowerMessage(msg) && frame->hasBitError(),
                                   IDLE,
                 // TODO: reason? emit(LayeredProtocolBase::packetFromLowerDroppedSignal, frame);
                 delete frame;
                 numCollision++;
                 resetStateVariables();
             );
             FSMA_Event_Transition(Receive-Unexpected-Ack,
                                   isLowerMessage(msg) && isAck(frame),
                                   IDLE,
                 delete frame;
                 resetStateVariables();
             );
             FSMA_Event_Transition(Receive-Broadcast,
                                   isLowerMessage(msg) && isBroadcast(frame),
                                   IDLE,
                 sendUp(decapsulate(check_and_cast<CsmaCaMacDataFrame *>(frame)));
                 numReceivedBroadcast++;
                 resetStateVariables();
             );
             FSMA_Event_Transition(Receive-Unicast-No-Ack,
                                   isLowerMessage(msg) && isForUs(frame) && !useAck,
                                   IDLE,
                 sendUp(decapsulate(check_and_cast<CsmaCaMacDataFrame *>(frame)));
                 numReceived++;
                 resetStateVariables();
             );
             FSMA_Event_Transition(Receive-Unicast-Use-Ack,
                                   isLowerMessage(msg) && isForUs(frame) && useAck,
                                   WAITSIFS,
                 sendUp(decapsulate(check_and_cast<CsmaCaMacDataFrame *>(frame->dup())));
                 numReceived++;
             );
             FSMA_Event_Transition(Receive-Unicast-Not-For-Us,
                                   isLowerMessage(msg) && !isForUs(frame),
                                   IDLE,
                 delete frame;
                 resetStateVariables();
             );
         }
         FSMA_State(WAITSIFS)
         {
             FSMA_Enter(scheduleSifsTimer(frame));
             FSMA_Event_Transition(Transmit-Ack,
                                   msg == endSifs,
                                   IDLE,
                 sendAckFrame();
                 resetStateVariables();
             );
         }
     }
     if (fsm.getState() == IDLE) {
         if (isReceiving())
             handleWithFsm(mediumStateChange);
         else if (!transmissionQueue.isEmpty())
             handleWithFsm(transmissionQueue.front());
     }
 }

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

overrideprotectedvirtual

Initialization of the module and its variables.

Reimplemented from inet::MACProtocolBase.

 {
     MACProtocolBase::initialize(stage);
 
     if (stage == INITSTAGE_LOCAL) {
         EV << "Initializing stage 0\n";
 
         maxQueueSize = par("maxQueueSize");
         useAck = par("useAck");
         bitrate = par("bitrate");
         headerLength = par("headerLength");
         ackLength = par("ackLength");
         ackTimeout = par("ackTimeout");
         slotTime = par("slotTime");
         sifsTime = par("sifsTime");
         difsTime = par("difsTime");
         cwMin = par("cwMin");
         cwMax = par("cwMax");
         cwMulticast = par("cwMulticast");
         retryLimit = par("retryLimit");
 
         const char *addressString = par("address");
         if (!strcmp(addressString, "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(addressString);
         registerInterface();
 
         // subscribe for the information of the carrier sense
         cModule *radioModule = getModuleFromPar<cModule>(par("radioModule"), this);
         radioModule->subscribe(IRadio::receptionStateChangedSignal, this);
         radioModule->subscribe(IRadio::transmissionStateChangedSignal, this);
         radio = check_and_cast<IRadio *>(radioModule);
 
         // initialize self messages
         endSifs = new cMessage("SIFS");
         endDifs = new cMessage("DIFS");
         endBackoff = new cMessage("Backoff");
         endAckTimeout = new cMessage("AckTimeout");
         endData = new cMessage("Data");
         mediumStateChange = new cMessage("MediumStateChange");
 
         // set up internal queue
         transmissionQueue.setMaxPacketLength(maxQueueSize);
         transmissionQueue.setName("transmissionQueue");
         if (par("prioritizeByUP"))
             transmissionQueue.setup(&compareFramesByPriority);
 
         // obtain pointer to external queue
         initializeQueueModule();
 
         // state variables
         fsm.setName("CsmaCaMac State Machine");
         backoffPeriod = -1;
         retryCounter = 0;
 
         // statistics
         numRetry = 0;
         numSentWithoutRetry = 0;
         numGivenUp = 0;
         numCollision = 0;
         numSent = 0;
         numReceived = 0;
         numSentBroadcast = 0;
         numReceivedBroadcast = 0;
 
         // initialize watches
         WATCH(fsm);
         WATCH(backoffPeriod);
         WATCH(retryCounter);
         WATCH(numRetry);
         WATCH(numSentWithoutRetry);
         WATCH(numGivenUp);
         WATCH(numCollision);
         WATCH(numSent);
         WATCH(numReceived);
         WATCH(numSentBroadcast);
         WATCH(numReceivedBroadcast);
     }
     else if (stage == INITSTAGE_LINK_LAYER)
         radio->setRadioMode(IRadio::RADIO_MODE_RECEIVER);
 }

void inet::CsmaCaMac::initializeQueueModule ( )

protectedvirtual

Referenced by initialize().

 {
     // use of external queue module is optional -- find it if there's one specified
     if (par("queueModule").stringValue()[0]) {
         cModule *module = getParentModule()->getSubmodule(par("queueModule").stringValue());
         queueModule = check_and_cast<IPassiveQueue *>(module);
 
         EV << "Requesting first two frames from queue module\n";
         queueModule->requestPacket();
         // needed for backoff: mandatory if next message is already present
         queueModule->requestPacket();
     }
 }

void inet::CsmaCaMac::invalidateBackoffPeriod ( )

protectedvirtual

Referenced by handleWithFsm().

 {
     backoffPeriod = -1;
 }

bool inet::CsmaCaMac::isAck ( CsmaCaMacFrame * frame )

protectedvirtual

Referenced by handleWithFsm().

 {
     return dynamic_cast<CsmaCaMacAckFrame *>(frame);
 }

bool inet::CsmaCaMac::isBroadcast ( CsmaCaMacFrame * msg )

protectedvirtual

Referenced by handleWithFsm().

 {
     return frame->getReceiverAddress().isBroadcast();
 }

bool inet::CsmaCaMac::isForUs ( CsmaCaMacFrame * msg )

protectedvirtual

Referenced by handleLowerPacket(), and handleWithFsm().

 {
     return frame->getReceiverAddress() == address;
 }

bool inet::CsmaCaMac::isInvalidBackoffPeriod ( )

protectedvirtual

Referenced by scheduleBackoffTimer().

 {
     return backoffPeriod == -1;
 }

bool inet::CsmaCaMac::isMediumFree ( )

protectedvirtual

Referenced by handleWithFsm().

 {
     return radio->getReceptionState() == IRadio::RECEPTION_STATE_IDLE;
 }

bool inet::CsmaCaMac::isReceiving ( )

protectedvirtual

Referenced by handleWithFsm().

 {
     return radio->getReceptionState() == IRadio::RECEPTION_STATE_RECEIVING;
 }

void inet::CsmaCaMac::popTransmissionQueue ( )

protectedvirtual

Referenced by finishCurrentTransmission(), and giveUpCurrentTransmission().

 {
     EV << "dropping frame from transmission queue\n";
     delete transmissionQueue.pop();
     if (queueModule) {
         // tell queue module that we've become idle
         EV << "requesting another frame from queue module\n";
         queueModule->requestPacket();
     }
 }

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

overrideprotectedvirtual

 {
     Enter_Method_Silent();
     if (signalID == IRadio::receptionStateChangedSignal)
         handleWithFsm(mediumStateChange);
     else if (signalID == IRadio::transmissionStateChangedSignal) {
         IRadio::TransmissionState newRadioTransmissionState = (IRadio::TransmissionState)value;
         if (transmissionState == IRadio::TRANSMISSION_STATE_TRANSMITTING && newRadioTransmissionState == IRadio::TRANSMISSION_STATE_IDLE) {
             handleWithFsm(endData);
             radio->setRadioMode(IRadio::RADIO_MODE_RECEIVER);
         }
         transmissionState = newRadioTransmissionState;
     }
 }

void inet::CsmaCaMac::resetStateVariables ( )

protectedvirtual

Referenced by finishCurrentTransmission(), giveUpCurrentTransmission(), and handleWithFsm().

 {
     backoffPeriod = -1;
     retryCounter = 0;
 }

void inet::CsmaCaMac::retryCurrentTransmission ( )

protectedvirtual

Referenced by handleWithFsm().

 {
     ASSERT(retryCounter < retryLimit);
     retryCounter++;
     numRetry++;
     generateBackoffPeriod();
 }

void inet::CsmaCaMac::scheduleAckTimeout ( CsmaCaMacDataFrame * frame )

protectedvirtual

Referenced by handleWithFsm().

 {
     EV << "scheduling ACK timeout\n";
     scheduleAt(simTime() + ackTimeout, endAckTimeout);
 }

void inet::CsmaCaMac::scheduleBackoffTimer ( )

protectedvirtual

Referenced by handleWithFsm().

 {
     EV << "scheduling backoff timer\n";
     if (isInvalidBackoffPeriod())
         generateBackoffPeriod();
     scheduleAt(simTime() + backoffPeriod, endBackoff);
 }

void inet::CsmaCaMac::scheduleDifsTimer ( )

protectedvirtual

Referenced by handleWithFsm().

 {
     EV << "scheduling DIFS timer\n";
     scheduleAt(simTime() + difsTime, endDifs);
 }

void inet::CsmaCaMac::scheduleSifsTimer ( CsmaCaMacFrame * frame )

protectedvirtual

Referenced by handleWithFsm().

 {
     EV << "scheduling SIFS timer\n";
     endSifs->setContextPointer(frame);
     scheduleAt(simTime() + sifsTime, endSifs);
 }

void inet::CsmaCaMac::sendAckFrame ( )

protectedvirtual

Referenced by handleWithFsm().

 {
     EV << "sending Ack frame\n";
     auto frameToAck = static_cast<CsmaCaMacDataFrame *>(endSifs->getContextPointer());
     endSifs->setContextPointer(nullptr);
     auto ackFrame = new CsmaCaMacAckFrame("CsmaAck");
     ackFrame->setReceiverAddress(frameToAck->getTransmitterAddress());
     ackFrame->setByteLength(ackLength);
     radio->setRadioMode(IRadio::RADIO_MODE_TRANSMITTER);
     sendDown(ackFrame);
     delete frameToAck;
 }

void inet::CsmaCaMac::sendDataFrame ( CsmaCaMacDataFrame * frameToSend )

protectedvirtual

Referenced by handleWithFsm().

 {
     EV << "sending Data frame " << frameToSend->getName() << endl;
     radio->setRadioMode(IRadio::RADIO_MODE_TRANSMITTER);
     sendDown(frameToSend->dup());
 }