Ethernet MAC module which supports both half-duplex (CSMA/CD) and full-duplex operation. More...

#include <EthernetCsmaMac.h>

Inheritance diagram for inet::EthernetCsmaMac:

Classes
struct	PkIdRxTime

class	RxSignal

Public Member Functions
	EthernetCsmaMac ()

virtual	~EthernetCsmaMac ()

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...

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

virtual	~EthernetMacBase ()

virtual MacAddress	getMacAddress ()

double	getTxRate ()

bool	isActive ()

MacTransmitState	getTransmitState ()

MacReceiveState	getReceiveState ()

virtual void	handleStartOperation (LifecycleOperation *operation) override

virtual void	handleStopOperation (LifecycleOperation *operation) override

virtual void	handleCrashOperation (LifecycleOperation *operation) override

virtual void	processAtHandleMessageFinished ()

void	addPaddingAndSetFcs (Packet *packet, B requiredMinByteLength=MIN_ETHERNET_FRAME_BYTES) const
	Inserts padding in front of FCS and calculate FCS. 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	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::queueing::IActivePacketSink
virtual	~IActivePacketSink ()

Protected Member Functions
virtual int	numInitStages () const override

virtual void	initialize (int stage) override

virtual void	initializeFlags () override

virtual void	initializeStatistics () override

virtual void	handleMessageWhenUp (cMessage *msg) override

virtual void	finish () override

virtual void	handleSelfMessage (cMessage *msg) override

virtual void	handleEndIFGPeriod ()

virtual void	handleEndPausePeriod ()

virtual void	handleEndTxPeriod ()

virtual void	handleEndRxPeriod ()

virtual void	handleEndBackoffPeriod ()

virtual void	handleEndJammingPeriod ()

virtual void	handleRetransmission ()

virtual void	readChannelParameters (bool errorWhenAsymmetric) override
	Calculates datarates, etc. More...

virtual void	handleUpperPacket (Packet *msg) override

virtual void	processMsgFromNetwork (EthernetSignalBase *msg)

virtual void	scheduleEndIFGPeriod ()

virtual void	fillIFGInBurst ()

virtual void	scheduleEndPausePeriod (int pauseUnits)

virtual void	beginSendFrames ()

virtual void	sendJamSignal ()

virtual void	startFrameTransmission ()

virtual void	frameReceptionComplete ()

virtual void	processReceivedDataFrame (Packet *frame)

virtual void	processReceivedControlFrame (Packet *packet)

virtual void	processConnectDisconnect () override

virtual void	processDetectedCollision ()

virtual void	sendSignal (EthernetSignalBase *signal, simtime_t_cref duration)

virtual void	handleSignalFromNetwork (EthernetSignalBase *signal)

virtual void	updateRxSignals (EthernetSignalBase *signal, simtime_t endRxTime)

virtual void	dropCurrentTxFrame (PacketDropDetails &details) override

bool	canContinueBurst (b remainingGapLength)

B	calculateMinFrameLength ()

virtual void	printState ()

Protected Member Functions inherited from inet::EthernetMacBase
virtual bool	dropFrameNotForUs (Packet *packet, const Ptr< const EthernetMacHeader > &frame)
	Checks destination address and drops the frame when frame is not for us; returns true if frame is dropped. More...

virtual void	printParameters ()

virtual void	encapsulate (Packet *packet)

virtual void	decapsulate (Packet *packet)

bool	verifyCrcAndLength (Packet *packet)
	Verify ethernet packet: check FCS and payload length. More...

virtual void	configureNetworkInterface () override

virtual void	refreshDisplay () const override

virtual void	receiveSignal (cComponent src, simsignal_t signalId, cObject obj, cObject *details) override

virtual void	refreshConnection ()

void	changeTransmissionState (MacTransmitState newState)

void	changeReceptionState (MacReceiveState newState)

virtual void	cutEthernetSignalEnd (EthernetSignalBase *signal, simtime_t duration)

virtual void	txFinished ()

Protected Member Functions inherited from inet::MacProtocolBase
	MacProtocolBase ()

virtual	~MacProtocolBase ()

virtual void	registerInterface ()

virtual MacAddress	parseMacAddressParameter (const char *addrstr)

virtual void	deleteCurrentTxFrame ()

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...

queueing::IPacketQueue *	getQueue (cGate *gate) const

virtual bool	canDequeuePacket () const

virtual Packet *	dequeuePacket ()

Protected Member Functions inherited from inet::LayeredProtocolBase
virtual void	handleUpperMessage (cMessage *message)

virtual void	handleLowerMessage (cMessage *message)

virtual void	handleUpperCommand (cMessage *message)

virtual void	handleLowerCommand (cMessage *message)

virtual void	handleLowerPacket (Packet *packet)

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
std::vector< RxSignal >	rxSignals

int	backoffs = 0

cMessage *	endRxTimer = nullptr

cMessage *	endBackoffTimer = nullptr

cMessage *	endJammingTimer = nullptr

simtime_t	totalCollisionTime

simtime_t	totalSuccessfulRxTxTime

simtime_t	channelBusySince

unsigned long	numCollisions = 0

unsigned long	numBackoffs = 0

int	framesSentInBurst = 0

B	bytesSentInBurst = B(0)

Protected Attributes inherited from inet::EthernetMacBase
const char *	displayStringTextFormat = nullptr

bool	sendRawBytes = false

FcsMode	fcsMode = FCS_MODE_UNDEFINED

const EtherDescr *	curEtherDescr = nullptr

bool	connected = false

bool	promiscuous = false

bool	duplexMode = false

bool	frameBursting = false

cChannel *	transmissionChannel = nullptr

cGate *	physInGate = nullptr

cGate *	physOutGate = nullptr

bool	channelsDiffer = false

MacTransmitState	transmitState = static_cast<MacTransmitState>(-1)

MacReceiveState	receiveState = static_cast<MacReceiveState>(-1)

simtime_t	lastTxFinishTime

int	pauseUnitsRequested = 0

cMessage *	endTxTimer = nullptr

cMessage *	endIfgTimer = nullptr

cMessage *	endPauseTimer = nullptr

EthernetSignalBase *	curTxSignal = nullptr

unsigned long	numFramesSent = 0

unsigned long	numFramesReceivedOK = 0

unsigned long	numBytesSent = 0

unsigned long	numBytesReceivedOK = 0

unsigned long	numFramesFromHL = 0

unsigned long	numDroppedPkFromHLIfaceDown = 0

unsigned long	numDroppedIfaceDown = 0

unsigned long	numDroppedBitError = 0

unsigned long	numDroppedNotForUs = 0

unsigned long	numFramesPassedToHL = 0

unsigned long	numPauseFramesRcvd = 0

unsigned long	numPauseFramesSent = 0

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

Static Protected Attributes
static simsignal_t	collisionSignal = registerSignal("collision")

static simsignal_t	backoffSlotsGeneratedSignal = registerSignal("backoffSlotsGenerated")

Static Protected Attributes inherited from inet::EthernetMacBase
static const EtherDescr	etherDescrs [NUM_OF_ETHERDESCRS]

static const EtherDescr	nullEtherDescr

static simsignal_t	rxPkOkSignal = registerSignal("rxPkOk")

static simsignal_t	txPausePkUnitsSignal = registerSignal("txPausePkUnits")

static simsignal_t	rxPausePkUnitsSignal = registerSignal("rxPausePkUnits")

static simsignal_t	transmissionStateChangedSignal = registerSignal("transmissionStateChanged")

static simsignal_t	receptionStateChangedSignal = registerSignal("receptionStateChanged")

Additional Inherited Members
Public Types inherited from inet::EthernetMacBase
enum	MacTransmitState { TX_IDLE_STATE = 1, WAIT_IFG_STATE, SEND_IFG_STATE, TRANSMITTING_STATE, JAMMING_STATE, BACKOFF_STATE, PAUSE_STATE }

enum	MacReceiveState { RX_IDLE_STATE = 1, RECEIVING_STATE, RX_COLLISION_STATE, RX_RECONNECT_STATE }

Static Public Attributes inherited from inet::EthernetMacBase
static const double	SPEED_OF_LIGHT_IN_CABLE = 200000000.0

Protected Types inherited from inet::EthernetMacBase
enum	SelfMsgKindValues { ENDIFG = 100, ENDRECEPTION, ENDBACKOFF, ENDTRANSMISSION, ENDJAMMING, ENDPAUSE }

enum	{ NUM_OF_ETHERDESCRS = 11 }

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

Detailed Description

Ethernet MAC module which supports both half-duplex (CSMA/CD) and full-duplex operation.

(See also EthernetMac which has a considerably smaller code with all the CSMA/CD complexity removed.)

See NED file for more details.

Constructor & Destructor Documentation

◆ EthernetCsmaMac()

inet::EthernetCsmaMac::EthernetCsmaMac ( )

inline

25 {}

◆ ~EthernetCsmaMac()

inet::EthernetCsmaMac::~EthernetCsmaMac ( )

virtual

 {
     for (auto& rx : rxSignals)
         delete rx.signal;
     cancelAndDelete(endRxTimer);
     cancelAndDelete(endBackoffTimer);
     cancelAndDelete(endJammingTimer);
 }

Member Function Documentation

◆ beginSendFrames()

void inet::EthernetCsmaMac::beginSendFrames ( )

protectedvirtual

 {
     if (currentTxFrame) {
         // Other frames are queued, therefore wait IFG period and transmit next frame
         EV_DETAIL << "Will transmit next frame in output queue after IFG period\n";
         startFrameTransmission();
     }
     else {
         // No more frames, set transmitter to idle
         changeTransmissionState(TX_IDLE_STATE);
         EV_DETAIL << "No more frames to send, transmitter set to idle\n";
     }
 }

Referenced by handleEndPausePeriod().

◆ calculateMinFrameLength()

B inet::EthernetCsmaMac::calculateMinFrameLength ( )

protected

 {
     bool inBurst = frameBursting && framesSentInBurst;
     B minFrameLength = duplexMode ? MIN_ETHERNET_FRAME_BYTES : (inBurst ? curEtherDescr->frameInBurstMinBytes : curEtherDescr->halfDuplexFrameMinBytes);
  
     return minFrameLength;
 }

Referenced by startFrameTransmission().

◆ canContinueBurst()

bool inet::EthernetCsmaMac::canContinueBurst ( b remainingGapLength )

protected

 {
     if ((frameBursting && framesSentInBurst > 0) && (framesSentInBurst < curEtherDescr->maxFramesInBurst)) {
         if (Packet *pk = txQueue->canPullPacket(gate(upperLayerInGateId)->getPathStartGate())) {
             // TODO before/after FilledIfg!!!
             B pkLength = std::max(MIN_ETHERNET_FRAME_BYTES, B(pk->getDataLength()));
             return (bytesSentInBurst + remainingGapLength + PREAMBLE_BYTES + SFD_BYTES + pkLength) <= curEtherDescr->maxBytesInBurst;
         }
     }
     return false;
 }

Referenced by handleEndIFGPeriod(), and handleEndTxPeriod().

◆ dropCurrentTxFrame()

void inet::EthernetCsmaMac::dropCurrentTxFrame ( PacketDropDetails & details )

overrideprotectedvirtual

Reimplemented from inet::MacProtocolBase.

 {
     EthernetMacBase::dropCurrentTxFrame(details);
     delete curTxSignal;
     curTxSignal = nullptr;
 }

Referenced by handleRetransmission().

◆ fillIFGInBurst()

void inet::EthernetCsmaMac::fillIFGInBurst ( )

protectedvirtual

 {
     EV_TRACE << "fillIFGInBurst(): t=" << simTime() << ", framesSentInBurst=" << framesSentInBurst << ", bytesSentInBurst=" << bytesSentInBurst << endl;
  
     EthernetFilledIfgSignal *gap = new EthernetFilledIfgSignal("FilledIFG");
     gap->setBitrate(curEtherDescr->txrate);
     bytesSentInBurst += B(gap->getByteLength());
     simtime_t duration = gap->getBitLength() / this->curEtherDescr->txrate;
     sendSignal(gap, duration);
     scheduleAfter(duration, endIfgTimer);
     changeTransmissionState(SEND_IFG_STATE);
 }

Referenced by handleEndTxPeriod().

◆ finish()

void inet::EthernetCsmaMac::finish ( )

overrideprotectedvirtual

Reimplemented from inet::EthernetMacBase.

 {
     EthernetMacBase::finish();
  
     simtime_t t = simTime();
     simtime_t totalChannelIdleTime = t - totalSuccessfulRxTxTime - totalCollisionTime;
     recordScalar("rx channel idle (%)", 100 * (totalChannelIdleTime / t));
     recordScalar("rx channel utilization (%)", 100 * (totalSuccessfulRxTxTime / t));
     recordScalar("rx channel collision (%)", 100 * (totalCollisionTime / t));
     recordScalar("collisions", numCollisions);
     recordScalar("backoffs", numBackoffs);
 }

◆ frameReceptionComplete()

void inet::EthernetCsmaMac::frameReceptionComplete ( )

protectedvirtual

 {
     ASSERT(rxSignals.size() == 1);
     EthernetSignalBase *signal = rxSignals[0].signal;
     rxSignals.clear();
  
     if (dynamic_cast<EthernetFilledIfgSignal *>(signal) != nullptr) {
         delete signal;
         return;
     }
     if (signal->getSrcMacFullDuplex() != duplexMode)
         throw cRuntimeError("Ethernet misconfiguration: MACs on the same link must be all in full duplex mode, or all in half-duplex mode");
  
     emit(receptionEndedSignal, signal);
  
     bool hasBitError = signal->hasBitError();
     auto packet = check_and_cast<Packet *>(signal->decapsulate());
     delete signal;
     decapsulate(packet);
     emit(packetReceivedFromLowerSignal, packet);
  
     if (hasBitError || !verifyCrcAndLength(packet)) {
         numDroppedBitError++;
         PacketDropDetails details;
         details.setReason(INCORRECTLY_RECEIVED);
         emit(packetDroppedSignal, packet, &details);
         delete packet;
         return;
     }
  
     const auto& frame = packet->peekAtFront<EthernetMacHeader>();
     auto macAddressInd = packet->addTag<MacAddressInd>();
     macAddressInd->setSrcAddress(frame->getSrc());
     macAddressInd->setDestAddress(frame->getDest());
     if (dropFrameNotForUs(packet, frame))
         return;
  
     if (frame->getTypeOrLength() == ETHERTYPE_FLOW_CONTROL) {
         processReceivedControlFrame(packet);
     }
     else {
         EV_INFO << "Reception of " << packet << " successfully completed.\n";
         processReceivedDataFrame(packet);
     }
 }

Referenced by handleEndRxPeriod(), and processMsgFromNetwork().

◆ handleCanPullPacketChanged()

void inet::EthernetCsmaMac::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 (duplexMode || receiveState == RX_IDLE_STATE) {
         if (currentTxFrame == nullptr && transmitState == TX_IDLE_STATE && canDequeuePacket()) {
             Packet *packet = dequeuePacket();
             handleUpperPacket(packet);
         }
     }
 }

◆ handleEndBackoffPeriod()

void inet::EthernetCsmaMac::handleEndBackoffPeriod ( )

protectedvirtual

 {
     if (transmitState != BACKOFF_STATE)
         throw cRuntimeError("At end of BACKOFF and not in BACKOFF_STATE");
  
     if (currentTxFrame == nullptr)
         throw cRuntimeError("At end of BACKOFF and no frame to transmit");
  
     if (receiveState == RX_IDLE_STATE) {
         EV_DETAIL << "Backoff period ended, wait IFG\n";
         scheduleEndIFGPeriod();
     }
     else {
         EV_DETAIL << "Backoff period ended but channel is not free, idling\n";
         changeTransmissionState(TX_IDLE_STATE);
     }
 }

Referenced by handleSelfMessage().

◆ handleEndIFGPeriod()

void inet::EthernetCsmaMac::handleEndIFGPeriod ( )

protectedvirtual

 {
     EV_DETAIL << "IFG elapsed\n";
  
     if (transmitState == SEND_IFG_STATE) {
         emit(transmissionEndedSignal, curTxSignal);
         txFinished();
         if (canContinueBurst(b(0))) {
             Packet *packet = dequeuePacket();
             handleUpperPacket(packet);
         }
         else
             scheduleEndIFGPeriod();
     }
     else if (transmitState == WAIT_IFG_STATE) {
         // End of IFG period, okay to transmit, if Rx idle OR duplexMode ( checked in startFrameTransmission(); )
         if (currentTxFrame != nullptr)
             startFrameTransmission();
         else if (canDequeuePacket()) {
             Packet *packet = dequeuePacket();
             handleUpperPacket(packet);
         }
         else
             changeTransmissionState(TX_IDLE_STATE);
     }
     else
         throw cRuntimeError("Not in WAIT_IFG_STATE at the end of IFG period");
 }

Referenced by handleSelfMessage().

◆ handleEndJammingPeriod()

void inet::EthernetCsmaMac::handleEndJammingPeriod ( )

protectedvirtual

 {
     if (transmitState != JAMMING_STATE)
         throw cRuntimeError("At end of JAMMING but not in JAMMING_STATE");
  
     emit(transmissionEndedSignal, curTxSignal);
     txFinished();
     EV_DETAIL << "Jamming finished, executing backoff\n";
     handleRetransmission();
 }

Referenced by handleSelfMessage().

◆ handleEndPausePeriod()

void inet::EthernetCsmaMac::handleEndPausePeriod ( )

protectedvirtual

 {
     if (transmitState != PAUSE_STATE)
         throw cRuntimeError("At end of PAUSE and not in PAUSE_STATE");
  
     EV_DETAIL << "Pause finished, resuming transmissions\n";
     beginSendFrames();
 }

Referenced by handleSelfMessage().

◆ handleEndRxPeriod()

void inet::EthernetCsmaMac::handleEndRxPeriod ( )

protectedvirtual

 {
     simtime_t dt = simTime() - channelBusySince;
  
     switch (receiveState) {
         case RECEIVING_STATE:
             frameReceptionComplete();
             totalSuccessfulRxTxTime += dt;
             break;
  
         case RX_COLLISION_STATE:
             EV_DETAIL << "Incoming signals finished after collision\n";
             totalCollisionTime += dt;
             for (auto& rx : rxSignals) {
                 delete rx.signal;
             }
             rxSignals.clear();
             break;
  
         case RX_RECONNECT_STATE:
             EV_DETAIL << "Incoming signals finished or reconnect time elapsed after reconnect\n";
             for (auto& rx : rxSignals) {
                 delete rx.signal;
             }
             rxSignals.clear();
             break;
  
         default:
             throw cRuntimeError("model error: invalid receiveState %d", receiveState);
     }
  
     changeReceptionState(RX_IDLE_STATE);
  
     if (!duplexMode && transmitState == TX_IDLE_STATE) {
         EV_DETAIL << "Start IFG period\n";
         scheduleEndIFGPeriod();
     }
 }

Referenced by handleSelfMessage().

◆ handleEndTxPeriod()

void inet::EthernetCsmaMac::handleEndTxPeriod ( )

protectedvirtual

 {
     EV_DETAIL << "TX successfully finished\n";
  
     // we only get here if transmission has finished successfully, without collision
     if (transmitState != TRANSMITTING_STATE || (!duplexMode && receiveState != RX_IDLE_STATE))
         throw cRuntimeError("End of transmission, and incorrect state detected");
  
     if (currentTxFrame == nullptr)
         throw cRuntimeError("Frame under transmission cannot be found");
  
     numFramesSent++;
     numBytesSent += currentTxFrame->getByteLength();
     emit(packetSentToLowerSignal, currentTxFrame); // consider: emit with start time of frame
  
     emit(transmissionEndedSignal, curTxSignal);
     txFinished();
  
     const auto& header = currentTxFrame->peekAtFront<EthernetMacHeader>();
     if (header->getTypeOrLength() == ETHERTYPE_FLOW_CONTROL) {
         const auto& controlFrame = currentTxFrame->peekDataAt<EthernetControlFrameBase>(header->getChunkLength(), b(-1));
         if (controlFrame->getOpCode() == ETHERNET_CONTROL_PAUSE) {
             const auto& pauseFrame = dynamicPtrCast<const EthernetPauseFrame>(controlFrame);
             numPauseFramesSent++;
             emit(txPausePkUnitsSignal, pauseFrame->getPauseTime());
         }
     }
  
     EV_INFO << "Transmission of " << currentTxFrame << " successfully completed.\n";
     deleteCurrentTxFrame();
     lastTxFinishTime = simTime();
  
     // only count transmissions in totalSuccessfulRxTxTime if channel is half-duplex
     if (!duplexMode) {
         simtime_t dt = simTime() - channelBusySince;
         totalSuccessfulRxTxTime += dt;
     }
  
     backoffs = 0;
  
     // check for and obey received PAUSE frames after each transmission
     if (pauseUnitsRequested > 0) {
         // if we received a PAUSE frame recently, go into PAUSE state
         EV_DETAIL << "Going to PAUSE mode for " << pauseUnitsRequested << " time units\n";
         scheduleEndPausePeriod(pauseUnitsRequested);
         pauseUnitsRequested = 0;
     }
     else {
         EV_DETAIL << "Start IFG period\n";
         if (canContinueBurst(INTERFRAME_GAP_BITS))
             fillIFGInBurst();
         else
             scheduleEndIFGPeriod();
     }
 }

Referenced by handleSelfMessage().

◆ handleMessageWhenUp()

void inet::EthernetCsmaMac::handleMessageWhenUp ( cMessage * msg )

overrideprotectedvirtual

Reimplemented from inet::LayeredProtocolBase.

 {
     if (channelsDiffer)
         readChannelParameters(true);
  
     printState();
  
     // some consistency check
     if (!duplexMode && transmitState == TRANSMITTING_STATE && receiveState != RX_IDLE_STATE)
         throw cRuntimeError("Inconsistent state -- transmitting and receiving at the same time");
  
     if (msg->isSelfMessage())
         handleSelfMessage(msg);
     else if (msg->getArrivalGateId() == upperLayerInGateId)
         handleUpperPacket(check_and_cast<Packet *>(msg));
     else if (msg->getArrivalGate() == physInGate)
         handleSignalFromNetwork(check_and_cast<EthernetSignalBase *>(msg));
     else
         throw cRuntimeError("Message received from unknown gate");
  
     processAtHandleMessageFinished();
     printState();
 }

◆ handleRetransmission()

void inet::EthernetCsmaMac::handleRetransmission ( )

protectedvirtual

 {
     if (++backoffs > MAX_ATTEMPTS) {
         EV_DETAIL << "Number of retransmit attempts of frame exceeds maximum, cancelling transmission of frame\n";
         PacketDropDetails details;
         details.setReason(RETRY_LIMIT_REACHED);
         details.setLimit(MAX_ATTEMPTS);
         dropCurrentTxFrame(details);
         changeTransmissionState(TX_IDLE_STATE);
         backoffs = 0;
  
         if (canDequeuePacket()) {
             Packet *packet = dequeuePacket();
             handleUpperPacket(packet);
         }
         return;
     }
  
     int backoffRange = (backoffs >= BACKOFF_RANGE_LIMIT) ? 1024 : (1 << backoffs);
     int slotNumber = intuniform(0, backoffRange - 1);
     EV_DETAIL << "Executing backoff procedure (slotNumber=" << slotNumber << ", backoffRange=[0," << backoffRange - 1 << "]" << endl;
  
     scheduleAfter(slotNumber * curEtherDescr->slotTime, endBackoffTimer);
     changeTransmissionState(BACKOFF_STATE);
     emit(backoffSlotsGeneratedSignal, slotNumber);
  
     numBackoffs++;
 }

Referenced by handleEndJammingPeriod().

◆ handleSelfMessage()

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

overrideprotectedvirtual

Reimplemented from inet::LayeredProtocolBase.

 {
     // Process different self-messages (timer signals)
     EV_TRACE << "Self-message " << msg << " received\n";
  
     switch (msg->getKind()) {
         case ENDIFG:
             handleEndIFGPeriod();
             break;
  
         case ENDTRANSMISSION:
             handleEndTxPeriod();
             break;
  
         case ENDRECEPTION:
             handleEndRxPeriod();
             break;
  
         case ENDBACKOFF:
             handleEndBackoffPeriod();
             break;
  
         case ENDJAMMING:
             handleEndJammingPeriod();
             break;
  
         case ENDPAUSE:
             handleEndPausePeriod();
             break;
  
         default:
             throw cRuntimeError("Self-message with unexpected message kind %d", msg->getKind());
     }
 }

Referenced by handleMessageWhenUp().

◆ handleSignalFromNetwork()

void inet::EthernetCsmaMac::handleSignalFromNetwork ( EthernetSignalBase * signal )

protectedvirtual

 {
     EV_DETAIL << "Received " << signal << " from network.\n";
  
     if (!connected) {
         EV_WARN << "Interface is not connected -- dropping signal " << signal << endl;
         if (!signal->isUpdate() && dynamic_cast<EthernetSignal *>(signal)) { // count only signal starts, do not count JAM and IFG packets
             auto packet = check_and_cast<Packet *>(signal->decapsulate());
             delete signal;
             decapsulate(packet);
             PacketDropDetails details;
             details.setReason(INTERFACE_DOWN);
             emit(packetDroppedSignal, packet, &details);
             delete packet;
             numDroppedIfaceDown++;
         }
         else
             delete signal;
         return;
     }
  
     // detect cable length violation in half-duplex mode
     if (!duplexMode) {
         simtime_t propagationTime = simTime() - signal->getSendingTime();
         if (propagationTime >= curEtherDescr->maxPropagationDelay) {
             throw cRuntimeError("Very long frame propagation time detected, maybe cable exceeds "
                                 "maximum allowed length? (%s s corresponds to an approx. %s m cable)",
                     SIMTIME_STR(propagationTime),
                     SIMTIME_STR(propagationTime * SPEED_OF_LIGHT_IN_CABLE));
         }
     }
  
     EthernetJamSignal *jamSignal = dynamic_cast<EthernetJamSignal *>(signal);
  
     if (duplexMode && jamSignal)
         throw cRuntimeError("Stray jam signal arrived in full-duplex mode");
  
     if (dynamic_cast<EthernetJamSignal *>(signal)) {
         updateRxSignals(signal, simTime() + signal->getRemainingDuration());
         processDetectedCollision();
     }
     else
         processMsgFromNetwork(signal);
 }

Referenced by handleMessageWhenUp().

◆ handleUpperPacket()

void inet::EthernetCsmaMac::handleUpperPacket ( Packet * msg )

overrideprotectedvirtual

Reimplemented from inet::LayeredProtocolBase.

 {
     EV_INFO << "Received " << packet << " from upper layer." << endl;
  
     numFramesFromHL++;
     emit(packetReceivedFromUpperSignal, packet);
  
     MacAddress address = getMacAddress();
  
     auto macHeader = packet->peekAtFront<EthernetMacHeader>();
     if (macHeader->getDest().equals(address)) {
         throw cRuntimeError("Logic error: frame %s from higher layer has local MAC address as dest (%s)",
                 packet->getFullName(), macHeader->getDest().str().c_str());
     }
  
     if (packet->getDataLength() > MAX_ETHERNET_FRAME_BYTES) {
         throw cRuntimeError("Packet length from higher layer (%s) exceeds maximum Ethernet frame size (%s)",
                 packet->getDataLength().str().c_str(), MAX_ETHERNET_FRAME_BYTES.str().c_str());
     }
  
     if (!connected) {
         EV_WARN << "Interface is not connected -- dropping packet " << packet << endl;
         PacketDropDetails details;
         details.setReason(INTERFACE_DOWN);
         emit(packetDroppedSignal, packet, &details);
         numDroppedPkFromHLIfaceDown++;
         delete packet;
  
         return;
     }
  
     // fill in src address if not set
     if (macHeader->getSrc().isUnspecified()) {
         // macHeader is immutable
         macHeader = nullptr;
         auto newHeader = packet->removeAtFront<EthernetMacHeader>();
         newHeader->setSrc(address);
         packet->insertAtFront(newHeader);
         macHeader = newHeader;
     }
     if (currentTxFrame != nullptr)
         throw cRuntimeError("EthernetMac already has a transmit packet when packet arrived from upper layer");
     addPaddingAndSetFcs(packet, MIN_ETHERNET_FRAME_BYTES);
     currentTxFrame = packet;
     startFrameTransmission();
 }

Referenced by handleCanPullPacketChanged(), handleEndIFGPeriod(), handleMessageWhenUp(), and handleRetransmission().

◆ initialize()

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

overrideprotectedvirtual

Reimplemented from inet::EthernetMacBase.

 {
     EthernetMacBase::initialize(stage);
  
     if (stage == INITSTAGE_LOCAL) {
         endRxTimer = new cMessage("EndReception", ENDRECEPTION);
         endBackoffTimer = new cMessage("EndBackoff", ENDBACKOFF);
         endJammingTimer = new cMessage("EndJamming", ENDJAMMING);
  
         // initialize state info
         backoffs = 0;
         setTxUpdateSupport(true);
  
         WATCH(backoffs);
     }
 }

◆ initializeFlags()

void inet::EthernetCsmaMac::initializeFlags ( )

overrideprotectedvirtual

Reimplemented from inet::EthernetMacBase.

 {
     EthernetMacBase::initializeFlags();
  
     duplexMode = par("duplexMode");
     frameBursting = !duplexMode && par("frameBursting");
     physInGate->setDeliverImmediately(true);
 }

◆ initializeStatistics()

void inet::EthernetCsmaMac::initializeStatistics ( )

overrideprotectedvirtual

Reimplemented from inet::EthernetMacBase.

 {
     EthernetMacBase::initializeStatistics();
  
     framesSentInBurst = 0;
     bytesSentInBurst = B(0);
  
     WATCH(framesSentInBurst);
     WATCH(bytesSentInBurst);
  
     // initialize statistics
     totalCollisionTime = 0.0;
     totalSuccessfulRxTxTime = 0.0;
     numCollisions = numBackoffs = 0;
  
     WATCH(numCollisions);
     WATCH(numBackoffs);
 }

◆ numInitStages()

virtual int inet::EthernetCsmaMac::numInitStages ( ) const

inlineoverrideprotectedvirtual

Reimplemented from inet::EthernetMacBase.

32 { return NUM_INIT_STAGES; }

◆ printState()

void inet::EthernetCsmaMac::printState ( )

protectedvirtual

 {
 #define CASE(x)    case x: \
         EV_DETAIL << #x; break
  
     EV_DETAIL << "transmitState: ";
     switch (transmitState) {
         CASE(TX_IDLE_STATE);
         CASE(WAIT_IFG_STATE);
         CASE(SEND_IFG_STATE);
         CASE(TRANSMITTING_STATE);
         CASE(JAMMING_STATE);
         CASE(BACKOFF_STATE);
         CASE(PAUSE_STATE);
     }
  
     EV_DETAIL << ",  receiveState: ";
     switch (receiveState) {
         CASE(RX_IDLE_STATE);
         CASE(RECEIVING_STATE);
         CASE(RX_COLLISION_STATE);
         CASE(RX_RECONNECT_STATE);
     }
  
     EV_DETAIL << ",  backoffs: " << backoffs;
     EV_DETAIL << ",  numConcurrentRxTransmissions: " << rxSignals.size();
     EV_DETAIL << ",  queueLength: " << txQueue->getNumPackets();
     EV_DETAIL << endl;
  
 #undef CASE
 }

Referenced by handleMessageWhenUp(), and startFrameTransmission().

◆ processConnectDisconnect()

void inet::EthernetCsmaMac::processConnectDisconnect ( )

overrideprotectedvirtual

Reimplemented from inet::EthernetMacBase.

 {
     if (!connected) {
         for (auto& rx : rxSignals)
             delete rx.signal;
         rxSignals.clear();
         cancelEvent(endRxTimer);
         cancelEvent(endBackoffTimer);
         cancelEvent(endJammingTimer);
         bytesSentInBurst = B(0);
         framesSentInBurst = 0;
     }
  
     EthernetMacBase::processConnectDisconnect();
  
     if (connected) {
         if (!duplexMode) {
             // start RX_RECONNECT_STATE
             changeReceptionState(RX_RECONNECT_STATE);
             simtime_t reconnectEndTime = simTime() + b(MAX_ETHERNET_FRAME_BYTES + JAM_SIGNAL_BYTES).get() / curEtherDescr->txrate;
             for (auto& rx : rxSignals)
                 delete rx.signal;
             rxSignals.clear();
             EthernetSignalBase *signal = new EthernetSignalBase("RECONNECT");
             signal->setBitError(true);
             signal->setDuration(reconnectEndTime);
             updateRxSignals(signal, reconnectEndTime);
         }
     }
 }

◆ processDetectedCollision()

void inet::EthernetCsmaMac::processDetectedCollision ( )

protectedvirtual

 {
     if (receiveState != RX_COLLISION_STATE) {
         numCollisions++;
         emit(collisionSignal, 1L);
         // go to collision state
         changeReceptionState(RX_COLLISION_STATE);
     }
 }

Referenced by handleSignalFromNetwork(), processMsgFromNetwork(), and startFrameTransmission().

◆ processMsgFromNetwork()

void inet::EthernetCsmaMac::processMsgFromNetwork ( EthernetSignalBase * msg )

protectedvirtual

 {
     simtime_t endRxTime = simTime() + signal->getRemainingDuration();
  
     if (!duplexMode && receiveState == RX_RECONNECT_STATE) {
         updateRxSignals(signal, endRxTime);
     }
     else if (!duplexMode && (transmitState == TRANSMITTING_STATE || transmitState == SEND_IFG_STATE)) {
         // since we're half-duplex, receiveState must be RX_IDLE_STATE (asserted at top of handleMessage)
         // set receive state and schedule end of reception
         updateRxSignals(signal, endRxTime);
         changeReceptionState(RX_COLLISION_STATE);
  
         EV_DETAIL << "Transmission interrupted by incoming frame, handling collision\n";
         cancelEvent((transmitState == TRANSMITTING_STATE) ? endTxTimer : endIfgTimer);
  
         EV_DETAIL << "Transmitting jam signal\n";
         sendJamSignal(); // backoff will be executed when jamming finished
  
         numCollisions++;
         emit(collisionSignal, 1L);
     }
     else if (receiveState == RX_IDLE_STATE) {
         ASSERT(!signal->isUpdate());
         channelBusySince = simTime();
         EV_INFO << "Reception of " << signal << " started.\n";
         emit(receptionStartedSignal, signal);
         updateRxSignals(signal, endRxTime);
         changeReceptionState(RECEIVING_STATE);
     }
     else if (!signal->isUpdate() && receiveState == RECEIVING_STATE && endRxTimer->getArrivalTime() - simTime() < curEtherDescr->halfBitTime) {
         // With the above condition we filter out "false" collisions that may occur with
         // back-to-back frames. That is: when "beginning of frame" message (this one) occurs
         // BEFORE "end of previous frame" event (endRxMsg) -- same simulation time,
         // only wrong order.
  
         EV_DETAIL << "Back-to-back frames: completing reception of current frame, starting reception of next one\n";
  
         // complete reception of previous frame
         cancelEvent(endRxTimer);
         frameReceptionComplete();
  
         // calculate usability
         totalSuccessfulRxTxTime += simTime() - channelBusySince;
         channelBusySince = simTime();
  
         // start receiving next frame
         updateRxSignals(signal, endRxTime);
         changeReceptionState(RECEIVING_STATE);
     }
     else { // (receiveState==RECEIVING_STATE || receiveState==RX_COLLISION_STATE)
            // handle overlapping receptions
         // EtherFrame or EtherPauseFrame
         updateRxSignals(signal, endRxTime);
         if (rxSignals.size() > 1) {
             EV_DETAIL << "Overlapping receptions -- setting collision state\n";
             processDetectedCollision();
         }
     }
 }

Referenced by handleSignalFromNetwork().

◆ processReceivedControlFrame()

void inet::EthernetCsmaMac::processReceivedControlFrame ( Packet * packet )

protectedvirtual

 {
     packet->popAtFront<EthernetMacHeader>();
     const auto& controlFrame = packet->peekAtFront<EthernetControlFrameBase>();
  
     if (controlFrame->getOpCode() == ETHERNET_CONTROL_PAUSE) {
         const auto& pauseFrame = packet->peekAtFront<EthernetPauseFrame>();
         int pauseUnits = pauseFrame->getPauseTime();
  
         numPauseFramesRcvd++;
         emit(rxPausePkUnitsSignal, pauseUnits);
  
         if (transmitState == TX_IDLE_STATE) {
             EV_DETAIL << "PAUSE frame received, pausing for " << pauseUnitsRequested << " time units\n";
             if (pauseUnits > 0)
                 scheduleEndPausePeriod(pauseUnits);
         }
         else if (transmitState == PAUSE_STATE) {
             EV_DETAIL << "PAUSE frame received, pausing for " << pauseUnitsRequested
                       << " more time units from now\n";
             cancelEvent(endPauseTimer);
  
             if (pauseUnits > 0)
                 scheduleEndPausePeriod(pauseUnits);
         }
         else {
             // transmitter busy -- wait until it finishes with current frame (endTx)
             // and then it'll go to PAUSE state
             EV_DETAIL << "PAUSE frame received, storing pause request\n";
             pauseUnitsRequested = pauseUnits;
         }
     }
     delete packet;
 }

Referenced by frameReceptionComplete().

◆ processReceivedDataFrame()

void inet::EthernetCsmaMac::processReceivedDataFrame ( Packet * frame )

protectedvirtual

 {
     // statistics
     unsigned long curBytes = packet->getByteLength();
     numFramesReceivedOK++;
     numBytesReceivedOK += curBytes;
     emit(rxPkOkSignal, packet);
  
     packet->addTagIfAbsent<DispatchProtocolReq>()->setProtocol(&Protocol::ethernetMac);
     packet->addTagIfAbsent<PacketProtocolTag>()->setProtocol(&Protocol::ethernetMac);
     if (networkInterface)
         packet->addTagIfAbsent<InterfaceInd>()->setInterfaceId(networkInterface->getInterfaceId());
  
     numFramesPassedToHL++;
     emit(packetSentToUpperSignal, packet);
     // pass up to upper layer
     EV_INFO << "Sending " << packet << " to upper layer.\n";
     send(packet, "upperLayerOut");
 }

Referenced by frameReceptionComplete().

◆ readChannelParameters()

void inet::EthernetCsmaMac::readChannelParameters ( bool errorWhenAsymmetric )

overrideprotectedvirtual

Calculates datarates, etc.

Verifies the datarates on the incoming/outgoing channels, and throws error when they differ and the parameter errorWhenAsymmetric is true.

Reimplemented from inet::EthernetMacBase.

 {
     EthernetMacBase::readChannelParameters(errorWhenAsymmetric);
  
     if (connected && !duplexMode) {
         if (curEtherDescr->halfDuplexFrameMinBytes < B(0))
             throw cRuntimeError("%g bps Ethernet only supports full-duplex links", curEtherDescr->txrate);
     }
 }

Referenced by handleMessageWhenUp().

◆ scheduleEndIFGPeriod()

void inet::EthernetCsmaMac::scheduleEndIFGPeriod ( )

protectedvirtual

 {
     bytesSentInBurst = B(0);
     framesSentInBurst = 0;
     simtime_t ifgTime = b(INTERFRAME_GAP_BITS).get() / curEtherDescr->txrate;
     scheduleAfter(ifgTime, endIfgTimer);
     changeTransmissionState(WAIT_IFG_STATE);
 }

Referenced by handleEndBackoffPeriod(), handleEndIFGPeriod(), handleEndRxPeriod(), and handleEndTxPeriod().

◆ scheduleEndPausePeriod()

void inet::EthernetCsmaMac::scheduleEndPausePeriod ( int pauseUnits )

protectedvirtual

 {
     // length is interpreted as 512-bit-time units
     simtime_t pausePeriod = pauseUnits * PAUSE_UNIT_BITS / curEtherDescr->txrate;
     scheduleAfter(pausePeriod, endPauseTimer);
     changeTransmissionState(PAUSE_STATE);
 }

Referenced by handleEndTxPeriod(), and processReceivedControlFrame().

◆ sendJamSignal()

void inet::EthernetCsmaMac::sendJamSignal ( )

protectedvirtual

 {
     // abort current transmission
     ASSERT(curTxSignal != nullptr);
     simtime_t duration = simTime() - curTxSignal->getCreationTime(); // TODO save and use start tx time
     cutEthernetSignalEnd(curTxSignal, duration); // TODO save and use start tx time
     emit(transmissionEndedSignal, curTxSignal);
     send(curTxSignal, SendOptions().finishTx(curTxSignal->getId()).duration(duration), physOutGate);
     curTxSignal = nullptr;
  
     // send JAM
     EthernetJamSignal *jam = new EthernetJamSignal("JAM_SIGNAL");
     jam->setByteLength(B(JAM_SIGNAL_BYTES).get());
     jam->setBitrate(curEtherDescr->txrate);
 //    emit(packetSentToLowerSignal, jam);
     duration = jam->getBitLength() / this->curEtherDescr->txrate;
     sendSignal(jam, duration);
  
     scheduleAfter(duration, endJammingTimer);
     changeTransmissionState(JAMMING_STATE);
 }

Referenced by processMsgFromNetwork(), and startFrameTransmission().

◆ sendSignal()

void inet::EthernetCsmaMac::sendSignal	(	EthernetSignalBase *	signal,
		simtime_t_cref	duration
	)

protectedvirtual

 {
     ASSERT(curTxSignal == nullptr);
     signal->setDuration(duration);
     curTxSignal = signal->dup();
     emit(transmissionStartedSignal, curTxSignal);
     send(signal, SendOptions().transmissionId(curTxSignal->getId()).duration(duration), physOutGate);
 }

Referenced by fillIFGInBurst(), sendJamSignal(), and startFrameTransmission().

◆ startFrameTransmission()

void inet::EthernetCsmaMac::startFrameTransmission ( )

protectedvirtual

 {
     ASSERT(currentTxFrame);
     EV_DETAIL << "Transmitting a copy of frame " << currentTxFrame << endl;
  
     Packet *frame = currentTxFrame->dup();
  
     const auto& hdr = frame->peekAtFront<EthernetMacHeader>();
     ASSERT(hdr);
     ASSERT(!hdr->getSrc().isUnspecified());
  
     B minFrameLengthWithExtension = calculateMinFrameLength();
     B extensionLength = minFrameLengthWithExtension > frame->getDataLength() ? (minFrameLengthWithExtension - frame->getDataLength()) : B(0);
  
     // add preamble and SFD (Starting Frame Delimiter), then send out
     encapsulate(frame);
  
     B sentFrameByteLength = frame->getDataLength() + extensionLength;
     auto& oldPacketProtocolTag = frame->removeTag<PacketProtocolTag>();
     frame->clearTags();
     auto newPacketProtocolTag = frame->addTag<PacketProtocolTag>();
     *newPacketProtocolTag = *oldPacketProtocolTag;
     EV_INFO << "Transmission of " << frame << " started.\n";
     auto signal = new EthernetSignal(frame->getName());
     signal->setSrcMacFullDuplex(duplexMode);
     signal->setBitrate(curEtherDescr->txrate);
     if (sendRawBytes) {
         auto bytes = frame->peekDataAsBytes();
         frame->eraseAll();
         frame->insertAtFront(bytes);
     }
     signal->encapsulate(frame);
     signal->addByteLength(extensionLength.get());
     simtime_t duration = signal->getBitLength() / this->curEtherDescr->txrate;
  
     sendSignal(signal, duration);
  
     // check for collisions (there might be an ongoing reception which we don't know about, see below)
     if (!duplexMode && receiveState != RX_IDLE_STATE) {
         // During the IFG period the hardware cannot listen to the channel,
         // so it might happen that receptions have begun during the IFG,
         // and even collisions might be in progress.
         //
         // But we don't know of any ongoing transmission so we blindly
         // start transmitting, immediately collide and send a jam signal.
         //
  
         processDetectedCollision();
         EV_DETAIL << "startFrameTransmission(): sending JAM signal.\n";
         printState();
         sendJamSignal();
     }
     else {
         // no collision
  
         // update burst variables
         if (frameBursting) {
             bytesSentInBurst += sentFrameByteLength;
             framesSentInBurst++;
         }
  
         scheduleAfter(duration, endTxTimer);
         changeTransmissionState(TRANSMITTING_STATE);
  
         // only count transmissions in totalSuccessfulRxTxTime if channel is half-duplex
         if (!duplexMode)
             channelBusySince = simTime();
     }
 }

Referenced by beginSendFrames(), handleEndIFGPeriod(), and handleUpperPacket().

◆ updateRxSignals()

void inet::EthernetCsmaMac::updateRxSignals	(	EthernetSignalBase *	signal,
		simtime_t	endRxTime
	)

protectedvirtual

 {
     simtime_t maxEndRxTime = endRxTime;
     bool found = false;
     bool isUpdate = signal->isUpdate();
     long signalTransmissionId = signal->getTransmissionId();
  
     for (auto& rx : rxSignals) {
         if (isUpdate && rx.transmissionId == signalTransmissionId) {
             ASSERT(!found);
             found = true;
             delete rx.signal;
             rx.signal = signal;
             rx.endRxTime = endRxTime;
         }
  
         if (rx.endRxTime > maxEndRxTime)
             maxEndRxTime = rx.endRxTime;
     }
  
     if (!found)
         rxSignals.push_back(RxSignal(signalTransmissionId, signal, endRxTime));
  
     if (endRxTimer->getArrivalTime() != maxEndRxTime || endRxTime == maxEndRxTime) {
         rescheduleAt(maxEndRxTime, endRxTimer);
     }
 }

Referenced by handleSignalFromNetwork(), processConnectDisconnect(), and processMsgFromNetwork().

Member Data Documentation

◆ backoffs

int inet::EthernetCsmaMac::backoffs = 0

protected

Referenced by handleEndTxPeriod(), handleRetransmission(), initialize(), and printState().

◆ backoffSlotsGeneratedSignal

simsignal_t inet::EthernetCsmaMac::backoffSlotsGeneratedSignal = registerSignal("backoffSlotsGenerated")

staticprotected

Referenced by handleRetransmission().

◆ bytesSentInBurst

B inet::EthernetCsmaMac::bytesSentInBurst = B(0)

protected

Referenced by canContinueBurst(), fillIFGInBurst(), initializeStatistics(), processConnectDisconnect(), scheduleEndIFGPeriod(), and startFrameTransmission().

◆ channelBusySince

simtime_t inet::EthernetCsmaMac::channelBusySince

protected

Referenced by handleEndRxPeriod(), handleEndTxPeriod(), processMsgFromNetwork(), and startFrameTransmission().

◆ collisionSignal

simsignal_t inet::EthernetCsmaMac::collisionSignal = registerSignal("collision")

staticprotected

Referenced by processDetectedCollision(), and processMsgFromNetwork().

◆ endBackoffTimer

cMessage* inet::EthernetCsmaMac::endBackoffTimer = nullptr

protected

Referenced by handleRetransmission(), initialize(), processConnectDisconnect(), and ~EthernetCsmaMac().

◆ endJammingTimer

cMessage* inet::EthernetCsmaMac::endJammingTimer = nullptr

protected

Referenced by initialize(), processConnectDisconnect(), sendJamSignal(), and ~EthernetCsmaMac().

◆ endRxTimer

cMessage* inet::EthernetCsmaMac::endRxTimer = nullptr

protected

Referenced by initialize(), processConnectDisconnect(), processMsgFromNetwork(), updateRxSignals(), and ~EthernetCsmaMac().

◆ framesSentInBurst

int inet::EthernetCsmaMac::framesSentInBurst = 0

protected

Referenced by calculateMinFrameLength(), canContinueBurst(), fillIFGInBurst(), initializeStatistics(), processConnectDisconnect(), scheduleEndIFGPeriod(), and startFrameTransmission().

◆ numBackoffs

unsigned long inet::EthernetCsmaMac::numBackoffs = 0

protected

Referenced by finish(), handleRetransmission(), and initializeStatistics().

◆ numCollisions

unsigned long inet::EthernetCsmaMac::numCollisions = 0

protected

Referenced by finish(), initializeStatistics(), processDetectedCollision(), and processMsgFromNetwork().

◆ rxSignals

std::vector<RxSignal> inet::EthernetCsmaMac::rxSignals

protected

Referenced by frameReceptionComplete(), handleEndRxPeriod(), printState(), processConnectDisconnect(), processMsgFromNetwork(), updateRxSignals(), and ~EthernetCsmaMac().

◆ totalCollisionTime

simtime_t inet::EthernetCsmaMac::totalCollisionTime

protected

Referenced by finish(), handleEndRxPeriod(), and initializeStatistics().

◆ totalSuccessfulRxTxTime

simtime_t inet::EthernetCsmaMac::totalSuccessfulRxTxTime

protected

Referenced by finish(), handleEndRxPeriod(), handleEndTxPeriod(), initializeStatistics(), and processMsgFromNetwork().

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

Classes

Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ EthernetCsmaMac()

◆ ~EthernetCsmaMac()

Member Function Documentation

◆ beginSendFrames()

◆ calculateMinFrameLength()

◆ canContinueBurst()

◆ dropCurrentTxFrame()

◆ fillIFGInBurst()

◆ finish()

◆ frameReceptionComplete()

◆ handleCanPullPacketChanged()

◆ handleEndBackoffPeriod()

◆ handleEndIFGPeriod()

◆ handleEndJammingPeriod()

◆ handleEndPausePeriod()

◆ handleEndRxPeriod()

◆ handleEndTxPeriod()

◆ handleMessageWhenUp()

◆ handleRetransmission()

◆ handleSelfMessage()

◆ handleSignalFromNetwork()

◆ handleUpperPacket()

◆ initialize()

◆ initializeFlags()

◆ initializeStatistics()

◆ numInitStages()

◆ printState()

◆ processConnectDisconnect()

◆ processDetectedCollision()

◆ processMsgFromNetwork()

◆ processReceivedControlFrame()

◆ processReceivedDataFrame()

◆ readChannelParameters()

◆ scheduleEndIFGPeriod()

◆ scheduleEndPausePeriod()

◆ sendJamSignal()

◆ sendSignal()

◆ startFrameTransmission()

◆ updateRxSignals()

Member Data Documentation

◆ backoffs

◆ backoffSlotsGeneratedSignal

◆ bytesSentInBurst

◆ channelBusySince

◆ collisionSignal

◆ endBackoffTimer

◆ endJammingTimer

◆ endRxTimer

◆ framesSentInBurst

◆ numBackoffs

◆ numCollisions

◆ rxSignals

◆ totalCollisionTime

◆ totalSuccessfulRxTxTime