The default implementation of ITx. More...

#include <Tx.h>

Inheritance diagram for inet::ieee80211::Tx:

Public Member Functions
	Tx ()

	~Tx ()

virtual void	transmitFrame (Packet packet, const Ptr< const Ieee80211MacHeader > &header, ITx::ICallback txCallback) override

virtual void	transmitFrame (Packet packet, const Ptr< const Ieee80211MacHeader > &header, simtime_t ifs, ITx::ICallback txCallback) override

virtual void	radioTransmissionFinished () override

Public Member Functions inherited from inet::ieee80211::ITx
virtual	~ITx ()

Protected Member Functions
virtual int	numInitStages () const override

virtual void	initialize (int stage) override

virtual void	handleMessage (cMessage *msg) override

virtual void	refreshDisplay () const override

Protected Attributes
ITx::ICallback *	txCallback = nullptr

Ieee80211Mac *	mac = nullptr

IRx *	rx = nullptr

Packet *	frame = nullptr

cMessage *	endIfsTimer = nullptr

bool	transmitting = false

Detailed Description

The default implementation of ITx.

Constructor & Destructor Documentation

◆ Tx()

inet::ieee80211::Tx::Tx ( )

inline

39 {}

◆ ~Tx()

inet::ieee80211::Tx::~Tx ( )

 {
     cancelAndDelete(endIfsTimer);
     if (frame)
         delete frame;
 }

Member Function Documentation

◆ handleMessage()

void inet::ieee80211::Tx::handleMessage ( cMessage * msg )

overrideprotectedvirtual

 {
     if (msg == endIfsTimer) {
         EV_DETAIL << "Tx: endIfsTimer expired\n";
         transmitting = true;
         mac->sendDownFrame(frame->dup());
     }
     else
         ASSERT(false);
 }

◆ initialize()

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

overrideprotectedvirtual

 {
     if (stage == INITSTAGE_LOCAL) {
         mac = check_and_cast<Ieee80211Mac *>(getContainingNicModule(this)->getSubmodule("mac"));
         endIfsTimer = new cMessage("endIFS");
         rx = dynamic_cast<IRx *>(findModuleByPath(par("rxModule")));
         WATCH(transmitting);
     }
 }

◆ numInitStages()

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

inlineoverrideprotectedvirtual

33 { return NUM_INIT_STAGES; }

◆ radioTransmissionFinished()

void inet::ieee80211::Tx::radioTransmissionFinished ( )

overridevirtual

Implements inet::ieee80211::ITx.

 {
     Enter_Method("radioTransmissionFinished");
     if (transmitting) {
         EV_DETAIL << "Tx: radioTransmissionFinished()\n";
         transmitting = false;
         ASSERT(txCallback != nullptr);
         const auto& header = frame->peekAtFront<Ieee80211MacHeader>();
         auto duration = header->getDurationField();
         auto tmpFrame = frame;
         auto tmpTxCallback = txCallback;
         frame = nullptr;
         txCallback = nullptr;
         tmpTxCallback->transmissionComplete(tmpFrame, tmpFrame->peekAtFront<Ieee80211MacHeader>());
         delete tmpFrame;
         rx->frameTransmitted(duration);
     }
 }

◆ refreshDisplay()

void inet::ieee80211::Tx::refreshDisplay ( ) const

overrideprotectedvirtual

 {
     const char *stateName = endIfsTimer != nullptr && endIfsTimer->isScheduled() ? "WAIT_IFS" : transmitting ? "TRANSMIT" : "IDLE";
     // faster version is just to display the state: getDisplayString().setTagArg("t", 0, stateName);
     std::stringstream os;
     if (frame)
         os << frame->getName() << "\n";
     os << stateName;
     getDisplayString().setTagArg("t", 0, os.str().c_str());
 }

◆ transmitFrame() [1/2]

void inet::ieee80211::Tx::transmitFrame	(	Packet *	packet,
		const Ptr< const Ieee80211MacHeader > &	header,
		ITx::ICallback *	txCallback
	)

overridevirtual

Implements inet::ieee80211::ITx.

 {
     transmitFrame(packet, header, SIMTIME_ZERO, txCallback);
 }

Referenced by transmitFrame().

◆ transmitFrame() [2/2]

void inet::ieee80211::Tx::transmitFrame	(	Packet *	packet,
		const Ptr< const Ieee80211MacHeader > &	header,
		simtime_t	ifs,
		ITx::ICallback *	txCallback
	)

overridevirtual

Implements inet::ieee80211::ITx.

 {
     Enter_Method("transmitFrame(\"%s\")", packet->getName());
     ASSERT(this->txCallback == nullptr);
     this->txCallback = txCallback;
     auto macAddressInd = packet->addTagIfAbsent<MacAddressInd>();
     const auto& updatedHeader = packet->removeAtFront<Ieee80211MacHeader>();
     if (auto oneAddressHeader = dynamicPtrCast<Ieee80211OneAddressHeader>(updatedHeader)) {
         macAddressInd->setDestAddress(oneAddressHeader->getReceiverAddress());
     }
     if (auto twoAddressHeader = dynamicPtrCast<Ieee80211TwoAddressHeader>(updatedHeader)) {
         twoAddressHeader->setTransmitterAddress(mac->getAddress());
         macAddressInd->setSrcAddress(twoAddressHeader->getTransmitterAddress());
     }
     packet->insertAtFront(updatedHeader);
     const auto& updatedTrailer = packet->removeAtBack<Ieee80211MacTrailer>(B(4));
     updatedTrailer->setFcsMode(mac->getFcsMode());
     if (mac->getFcsMode() == FCS_COMPUTED) {
         const auto& fcsBytes = packet->peekAllAsBytes();
         auto bufferLength = B(fcsBytes->getChunkLength()).get();
         auto buffer = new uint8_t[bufferLength];
         fcsBytes->copyToBuffer(buffer, bufferLength);
         auto fcs = ethernetCRC(buffer, bufferLength);
         updatedTrailer->setFcs(fcs);
         delete[] buffer;
     }
     packet->insertAtBack(updatedTrailer);
     this->frame = packet->dup();
     ASSERT(!endIfsTimer->isScheduled() && !transmitting); // we are idle
     if (ifs == 0) {
         // do directly what handleMessage() would do
         transmitting = true;
         mac->sendDownFrame(frame->dup());
     }
     else
         scheduleAfter(ifs, endIfsTimer);
 }