inet::XMac Class Reference

Implementation of X-MAC. More...

#include <XMac.h>

Inheritance diagram for inet::XMac:

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

Protected Member Functions
virtual void	configureNetworkInterface () override
	implements MacBase functions More...
Protected Member Functions inherited from inet::MacProtocolBase
	MacProtocolBase ()
virtual	~MacProtocolBase ()
virtual void	registerInterface ()
virtual MacAddress	parseMacAddressParameter (const char *addrstr)
virtual void	deleteCurrentTxFrame ()
virtual void	dropCurrentTxFrame (PacketDropDetails &details)
virtual void	handleMessageWhenDown (cMessage *msg) override
virtual void	sendUp (cMessage *message)
virtual void	sendDown (cMessage *message)
virtual bool	isUpperMessage (cMessage *message) const override
virtual bool	isLowerMessage (cMessage *message) const override
virtual bool	isInitializeStage (int stage) const override
virtual bool	isModuleStartStage (int stage) const override
virtual bool	isModuleStopStage (int stage) const override
virtual void	flushQueue (PacketDropDetails &details)
	should clear queue and emit signal "packetDropped" with entire packets More...
virtual void	clearQueue ()
	should clear queue silently More...
virtual void	receiveSignal (cComponent *source, simsignal_t signalID, cObject *obj, cObject *details) override
virtual void	handleStartOperation (LifecycleOperation *operation) override
virtual void	handleStopOperation (LifecycleOperation *operation) override
virtual void	handleCrashOperation (LifecycleOperation *operation) override
queueing::IPacketQueue *	getQueue (cGate *gate) const
virtual bool	canDequeuePacket () const
virtual Packet *	dequeuePacket ()
Protected Member Functions inherited from inet::LayeredProtocolBase
virtual void	handleMessageWhenUp (cMessage *message) override
virtual void	handleUpperMessage (cMessage *message)
virtual void	handleLowerMessage (cMessage *message)
virtual void	handleUpperCommand (cMessage *message)
virtual void	handleLowerCommand (cMessage *message)
Protected Member Functions inherited from inet::OperationalMixin< cSimpleModule >
virtual int	numInitStages () const override
virtual void	refreshDisplay () const override
virtual void	handleMessage (cMessage *msg) override
virtual bool	handleOperationStage (LifecycleOperation *operation, IDoneCallback *doneCallback) override
	Perform one stage of a lifecycle operation. More...
virtual State	getInitialOperationalState () const
	Returns initial operational state: OPERATING or NOT_OPERATING. More...
virtual void	handleActiveOperationTimeout (cMessage *message)
virtual bool	isUp () const
	utility functions More...
virtual bool	isDown () const
virtual void	setOperationalState (State newState)
virtual void	scheduleOperationTimeout (simtime_t timeout)
virtual void	setupActiveOperation (LifecycleOperation *operation, IDoneCallback *doneCallback, State)
virtual void	delayActiveOperationFinish (simtime_t timeout)
virtual void	startActiveOperationExtraTime (simtime_t delay=SIMTIME_ZERO)
virtual void	startActiveOperationExtraTimeOrFinish (simtime_t extraTime)
virtual void	finishActiveOperation ()

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

Different tracked statistics.
enum	States {   INIT, SLEEP, CCA, SEND_PREAMBLE,   WAIT_DATA, SEND_DATA, WAIT_TX_DATA_OVER, WAIT_ACK,   SEND_ACK, WAIT_ACK_TX }
	MAC states. More...
long	nbTxDataPackets
long	nbTxPreambles
long	nbRxDataPackets
long	nbRxPreambles
long	nbMissedAcks
long	nbRecvdAcks
long	nbDroppedDataPackets
long	nbTxAcks
long	nbRxBrokenDataPackets
States	macState
	The current state of the protocol. More...
cMessage *	resend_data
cMessage *	ack_timeout
cMessage *	start_xmac
cMessage *	wakeup
cMessage *	send_ack
cMessage *	cca_timeout
cMessage *	ack_tx_over
cMessage *	send_preamble
cMessage *	switch_preamble_phase
cMessage *	delay_for_ack_within_remote_rx
cMessage *	stop_preambles
cMessage *	data_tx_over
cMessage *	data_timeout
cMessage *	switching_done

Help variables for the acknowledgment process.
enum	XMAC_COLORS {   GREEN = 1, BLUE = 2, RED = 3, BLACK = 4,   YELLOW = 5 }
	Possible colors of the node for animation. More...
MacAddress	lastDataPktSrcAddr
MacAddress	lastDataPktDestAddr
MacAddress	lastPreamblePktSrcAddr
b	headerLength = b(0)
b	ctrlFrameLength = b(0)
ModuleRefByPar< physicallayer::IRadio >	radio
	The radio. More...
physicallayer::IRadio::TransmissionState	transmissionState = physicallayer::IRadio::TRANSMISSION_STATE_UNDEFINED
int	txAttempts
bool	animation
	Animate (colorize) the nodes. More...
double	slotDuration
	The duration of the slot in secs. More...
double	bitrate
	The bitrate of transmission. More...
double	checkInterval
	The duration of CCA. More...
double	txPower
	Transmission power of the node. More...
bool	useMacAcks
	Use MAC level acks or not. More...
int	maxTxAttempts
	Maximum transmission attempts per data packet, when ACKs are used. More...
bool	stats
	Gather stats at the end of the simulation. More...
void	changeDisplayColor (XMAC_COLORS color)
	Internal function to change the color of the node. More...
void	sendDataPacket ()
	Internal function to send the first packet in the queue. More...
void	sendMacAck ()
	Internal function to send an ACK. More...
void	sendPreamble (MacAddress destination)
	Internal function to send one preamble. More...
void	attachSignal (Packet *packet, simtime_t_cref startTime)
	Internal function to attach a signal to the packet. More...
void	decapsulate (Packet *packet)
void	encapsulate (Packet *packet)

Additional Inherited Members
Protected Types inherited from inet::OperationalMixin< cSimpleModule >
enum	State
Protected Attributes inherited from inet::MacProtocolBase
int	upperLayerInGateId = -1
	Gate ids. More...
int	upperLayerOutGateId = -1
int	lowerLayerInGateId = -1
int	lowerLayerOutGateId = -1
opp_component_ptr< NetworkInterface >	networkInterface
opp_component_ptr< cModule >	hostModule
Packet *	currentTxFrame = nullptr
	Currently transmitted frame if any. More...
opp_component_ptr< queueing::IPacketQueue >	txQueue
	Messages received from upper layer and to be transmitted later. More...
Protected Attributes inherited from inet::OperationalMixin< cSimpleModule >
State	operationalState
simtime_t	lastChange
Operation	activeOperation
cMessage *	activeOperationTimeout
cMessage *	activeOperationExtraTimer

Detailed Description

Implementation of X-MAC.

This implementation was created for the MiXiM framework by Joaquim Oller. It was ported to the INET framework by Jan Peter Drees.

A paper describing the X-MAC protocol can be found at: http://www.cs.cmu.edu/~andersoe/papers/xmac-sensys.pdf

A paper analyzing this MiXiM implementation can be found at: http://ieeexplore.ieee.org/document/7024195/

Author

Joaquim Oller and Jan Peter Drees

Member Enumeration Documentation

States

enum inet::XMac::States

protected

MAC states.

The MAC states help to keep track what the MAC is actually trying to do. INIT – node has just started and its status is unclear SLEEP – node sleeps, but accepts packets from the network layer CCA – Clear Channel Assessment - MAC checks whether medium is busy SEND_PREAMBLE – node sends preambles to wake up all nodes WAIT_DATA – node has received at least one preamble from another node and wiats for the actual data packet SEND_DATA – node has sent enough preambles and sends the actual data packet WAIT_TX_DATA_OVER – node waits until the data packet sending is ready WAIT_ACK – node has sent the data packet and waits for ack from the receiving node SEND_ACK – node send an ACK back to the sender WAIT_ACK_TX – node waits until the transmission of the ack packet is over

Enumerator
INIT
SLEEP
CCA
SEND_PREAMBLE
WAIT_DATA
SEND_DATA
WAIT_TX_DATA_OVER
WAIT_ACK
SEND_ACK
WAIT_ACK_TX

                {
        INIT, // 0
        SLEEP, // 1
        CCA, // 2
        SEND_PREAMBLE, // 3
        WAIT_DATA, // 4
        SEND_DATA, // 5
        WAIT_TX_DATA_OVER, // 6
        WAIT_ACK, // ~7: think this is not used
        SEND_ACK, // 8
        WAIT_ACK_TX // 9
    };

XMAC_COLORS

enum inet::XMac::XMAC_COLORS

protected

Possible colors of the node for animation.

Enumerator
GREEN
BLUE
RED
BLACK
YELLOW

                     {
        GREEN  = 1,
        BLUE   = 2,
        RED    = 3,
        BLACK  = 4,
        YELLOW = 5
    };

Constructor & Destructor Documentation

XMac() [1/2]

inet::XMac::XMac ( const XMac &  )

private

Copy constructor is not allowed.

XMac() [2/2]

inet::XMac::XMac ( )

inline

        : MacProtocolBase()
        , nbTxDataPackets(0), nbTxPreambles(0), nbRxDataPackets(0), nbRxPreambles(0)
        , nbMissedAcks(0), nbRecvdAcks(0), nbDroppedDataPackets(0), nbTxAcks(0)
        , macState(INIT)
        , resend_data(nullptr), ack_timeout(nullptr), start_xmac(nullptr), wakeup(nullptr)
        , send_ack(nullptr), cca_timeout(nullptr), ack_tx_over(nullptr), send_preamble(nullptr), stop_preambles(nullptr)
        , data_tx_over(nullptr), data_timeout(nullptr)
        , lastDataPktSrcAddr()
        , lastDataPktDestAddr()
        , txAttempts(0)
        , animation(false)
        , slotDuration(0), bitrate(0), checkInterval(0), txPower(0)
        , useMacAcks(0)
        , maxTxAttempts(0)
        , stats(false)
    {}

~XMac()

inet::XMac::~XMac ( )

virtual

{
    cancelAndDelete(wakeup);
    cancelAndDelete(data_timeout);
    cancelAndDelete(data_tx_over);
    cancelAndDelete(stop_preambles);
    cancelAndDelete(send_preamble);
    cancelAndDelete(ack_tx_over);
    cancelAndDelete(cca_timeout);
    cancelAndDelete(send_ack);
    cancelAndDelete(start_xmac);
    cancelAndDelete(ack_timeout);
    cancelAndDelete(resend_data);
    cancelAndDelete(switch_preamble_phase);
    cancelAndDelete(delay_for_ack_within_remote_rx);
    cancelAndDelete(switching_done);
}

Member Function Documentation

attachSignal()

void inet::XMac::attachSignal ( Packet *  packet, simtime_t_cref  startTime  )

protected

Internal function to attach a signal to the packet.

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

changeDisplayColor()

void inet::XMac::changeDisplayColor ( XMAC_COLORS  color )

protected

Internal function to change the color of the node.

Change the color of the node for animation purposes.

{
    if (!animation)
        return;
    cDisplayString& dispStr = getContainingNode(this)->getDisplayString();
    switch (macState) {
        case INIT:
            dispStr.setTagArg("t", 0, "INIT");
            break;
 
        case SLEEP:
            dispStr.setTagArg("t", 0, "SLEEP");
            break;
 
        case CCA:
            dispStr.setTagArg("t", 0, "CCA");
            break;
 
        case SEND_ACK:
        case SEND_PREAMBLE:
        case SEND_DATA:
            dispStr.setTagArg("t", 0, "SEND");
            break;
 
        case WAIT_ACK:
        case WAIT_DATA:
        case WAIT_TX_DATA_OVER:
        case WAIT_ACK_TX:
            dispStr.setTagArg("t", 0, "WAIT");
            break;
 
        default:
            dispStr.setTagArg("t", 0, "");
            break;
    }
}

configureNetworkInterface()

void inet::XMac::configureNetworkInterface ( )

overrideprotectedvirtual

implements MacBase functions

Implements inet::MacProtocolBase.

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

decapsulate()

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

protected

{
    const auto& xmacHeader = packet->popAtFront<XMacDataFrameHeader>();
    packet->addTagIfAbsent<MacAddressInd>()->setSrcAddress(xmacHeader->getSrcAddr());
    packet->addTagIfAbsent<InterfaceInd>()->setInterfaceId(networkInterface->getInterfaceId());
    auto payloadProtocol = ProtocolGroup::ethertype.getProtocol(xmacHeader->getNetworkProtocol());
    packet->addTagIfAbsent<DispatchProtocolReq>()->setProtocol(payloadProtocol);
    packet->addTagIfAbsent<PacketProtocolTag>()->setProtocol(payloadProtocol);
    packet->setKind(0);
    EV_DETAIL << " message decapsulated " << endl;
}

encapsulate()

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

protected

{
    auto pkt = makeShared<XMacDataFrameHeader>();
    pkt->setChunkLength(headerLength);
 
    // copy dest address from the Control Info attached to the network
    // message by the network layer
    auto dest = packet->getTag<MacAddressReq>()->getDestAddress();
    EV_DETAIL << "CInfo removed, mac addr=" << dest << endl;
    pkt->setNetworkProtocol(ProtocolGroup::ethertype.getProtocolNumber(packet->getTag<PacketProtocolTag>()->getProtocol()));
    pkt->setDestAddr(dest);
 
    // delete the control info
    delete packet->removeControlInfo();
 
    // set the src address to own mac address (nic module getId())
    pkt->setSrcAddr(networkInterface->getMacAddress());
 
    pkt->setType(XMAC_DATA);
    packet->setKind(XMAC_DATA);
 
    // encapsulate the network packet
    packet->insertAtFront(pkt);
    packet->getTagForUpdate<PacketProtocolTag>()->setProtocol(&Protocol::xmac);
    EV_DETAIL << "pkt encapsulated\n";
}

finish()

void inet::XMac::finish ( )

overridevirtual

Delete all dynamically allocated objects of the module.

{
    // record stats
    if (stats) {
        recordScalar("nbTxDataPackets", nbTxDataPackets);
        recordScalar("nbTxPreambles", nbTxPreambles);
        recordScalar("nbRxDataPackets", nbRxDataPackets);
        recordScalar("nbRxPreambles", nbRxPreambles);
        recordScalar("nbMissedAcks", nbMissedAcks);
        recordScalar("nbRecvdAcks", nbRecvdAcks);
        recordScalar("nbTxAcks", nbTxAcks);
        recordScalar("nbDroppedDataPackets", nbDroppedDataPackets);
        recordScalar("nbRxBrokenDataPackets", nbRxBrokenDataPackets);
//        recordScalar("timeSleep", timeSleep);
//        recordScalar("timeRX", timeRX);
//        recordScalar("timeTX", timeTX);
    }
}

getProvider()

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

overridevirtual

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

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

Implements inet::queueing::IActivePacketSink.

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

handleCanPullPacketChanged()

void inet::XMac::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");
    // force wakeup now
    if (gate->getId() == upperLayerInGateId && (macState == SLEEP) && wakeup->isScheduled()
            && canDequeuePacket())
    {
        rescheduleAfter(dblrand() * 0.01f, wakeup);
    }
}

handleLowerPacket()

void inet::XMac::handleLowerPacket ( Packet *  msg )

overridevirtual

Handle messages from lower layer.

Handle XMAC preambles and received data packets.

Reimplemented from inet::LayeredProtocolBase.

{
    if (msg->hasBitError()) {
        EV << "Received " << msg << " contains bit errors or collision, dropping it\n";
        nbRxBrokenDataPackets++;
        delete msg;
        return;
    }
    // simply pass the massage as self message, to be processed by the FSM.
    const auto& hdr = msg->peekAtFront<XMacHeaderBase>();
    msg->setKind(hdr->getType());
    handleSelfMessage(msg);
}

handlePullPacketProcessed()

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

overridevirtual

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

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

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

Implements inet::queueing::IActivePacketSink.

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

handleSelfMessage()

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

overridevirtual

Handle self messages such as timers.

Handle own messages:

Reimplemented from inet::LayeredProtocolBase.

{
    MacAddress address = networkInterface->getMacAddress();
 
    switch (macState) {
        case INIT:
            if (msg->getKind() == XMAC_START_XMAC) {
                EV_DEBUG << "State INIT, message XMAC_START, new state SLEEP" << endl;
                changeDisplayColor(BLACK);
                radio->setRadioMode(IRadio::RADIO_MODE_SLEEP);
                macState = SLEEP;
                scheduleAfter(dblrand() * slotDuration, wakeup);
                return;
            }
            break;
        case SLEEP:
            if (msg->getKind() == XMAC_WAKE_UP) {
                EV_DEBUG << "node " << address << " : State SLEEP, message XMAC_WAKEUP, new state CCA, simTime "
                         << simTime() << " to " << simTime() + 1.7f * checkInterval << endl;
                // this CCA is useful when in RX to detect preamble and has to make room for
                // 0.2f = Tx switch, 0.5f = Tx send_preamble, 1f = time_for_ack_back
                scheduleAfter(1.7f * checkInterval, cca_timeout);
                radio->setRadioMode(IRadio::RADIO_MODE_RECEIVER);
                changeDisplayColor(GREEN);
                macState = CCA;
                return;
            }
            // we receive an ACK back but it is too late
            else if (msg->getKind() == XMAC_ACK) {
                nbMissedAcks++;
                delete msg;
                return;
            }
            // received messages prior real-switching to SLEEP? I'm sorry, out
            else {
                return;
            }
            break;
        case CCA:
            if (msg->getKind() == XMAC_CCA_TIMEOUT) {
                // channel is clear and we wanna SEND
                if (!txQueue->isEmpty()) {
                    radio->setRadioMode(IRadio::RADIO_MODE_TRANSMITTER);
                    changeDisplayColor(YELLOW);
                    macState = SEND_PREAMBLE;
                    // We send the preamble for a whole SLOT duration :)
                    scheduleAfter(slotDuration, stop_preambles);
                    // if 0.2f * CI = 2ms to switch to TX -> has to be accounted for RX_preamble_detection
                    scheduleAfter(0.2f * checkInterval, switch_preamble_phase);
                    return;
                }
                // if anything to send, go back to sleep and wake up after a full period
                else {
                    scheduleAfter(slotDuration, wakeup);
                    macState = SLEEP;
                    radio->setRadioMode(IRadio::RADIO_MODE_SLEEP);
                    changeDisplayColor(BLACK);
                    return;
                }
            }
            // during CCA, we received a preamble. Go to state WAIT_DATA and
            // schedule the timeout.
            if (msg->getKind() == XMAC_PREAMBLE) {
                auto incoming_preamble = check_and_cast<Packet *>(msg)->peekAtFront<XMacControlFrame>();
 
                // preamble is for me
                if (incoming_preamble->getDestAddr() == address || incoming_preamble->getDestAddr().isBroadcast() || incoming_preamble->getDestAddr().isMulticast()) {
                    cancelEvent(cca_timeout);
                    nbRxPreambles++;
                    EV << "node " << address << " : State CCA, message XMAC_PREAMBLE received, new state SEND_ACK" << endl;
                    macState = SEND_ACK;
                    lastPreamblePktSrcAddr = incoming_preamble->getSrcAddr();
                    changeDisplayColor(YELLOW);
                    radio->setRadioMode(IRadio::RADIO_MODE_TRANSMITTER);
                }
                // the preamble is not for us
                else {
                    EV << "node " << address << " : State CCA, message XMAC_PREAMBLE not for me." << endl;
                    // ~ better overhearing management? :)
                    cancelEvent(cca_timeout);
                    scheduleAfter(slotDuration, wakeup);
                    macState = SLEEP;
                    radio->setRadioMode(IRadio::RADIO_MODE_SLEEP);
                    changeDisplayColor(BLACK);
                }
 
                delete msg;
                return;
            }
            // in case we get an ACK, we simply dicard it, because it means the end
            // of another communication
            if (msg->getKind() == XMAC_ACK) {
                EV_DEBUG << "State CCA, message XMAC_ACK, new state CCA" << endl;
                delete msg;
                return;
            }
            // this case is very, very, very improbable, but let's do it.
            // if in CCA the node receives directly the data packet, accept it
            // even if we increased nbMissedAcks in state SLEEP
            if (msg->getKind() == XMAC_DATA) {
                auto incoming_data = check_and_cast<Packet *>(msg)->peekAtFront<XMacDataFrameHeader>();
 
                // packet is for me
                if (incoming_data->getDestAddr() == address) {
                    EV << "node " << address << " : State CCA, received XMAC_DATA, accepting it." << endl;
                    cancelEvent(cca_timeout);
                    cancelEvent(switch_preamble_phase);
                    cancelEvent(stop_preambles);
                    macState = WAIT_DATA;
                    scheduleAfter(SIMTIME_ZERO, msg);
                }
                return;
            }
            break;
 
        case SEND_PREAMBLE:
            if (msg->getKind() == SWITCH_PREAMBLE_PHASE) {
                // ~ make room for preamble + time_for_ack_back, check_interval is 10ms by default (from NetworkXMAC.ini)
                // 0.5f* = 5ms
                if (radio->getRadioMode() == IRadio::RADIO_MODE_RECEIVER) {
                    radio->setRadioMode(IRadio::RADIO_MODE_TRANSMITTER);
                    changeDisplayColor(YELLOW);
                    EV_DEBUG << "node " << address << " : preamble_phase tx, simTime = " << simTime() << endl;
                    scheduleAfter(0.5f * checkInterval, switch_preamble_phase);
                }
                // 1.0f* = 10ms
                else if (radio->getRadioMode() == IRadio::RADIO_MODE_TRANSMITTER) {
                    radio->setRadioMode(IRadio::RADIO_MODE_RECEIVER);
                    changeDisplayColor(GREEN);
                    EV_DEBUG << "node " << address << " : preamble_phase rx, simTime = " << simTime() << endl;
                    scheduleAfter(1.0f * checkInterval, switch_preamble_phase);
                }
                return;
            }
            // radio switch from above
            if (msg->getKind() == XMAC_SWITCHING_FINISHED) {
                if (radio->getRadioMode() == IRadio::RADIO_MODE_TRANSMITTER) {
                    if (currentTxFrame == nullptr) {
                        currentTxFrame = dequeuePacket();
                        encapsulate(currentTxFrame);
                    }
                    auto pkt_preamble = currentTxFrame->peekAtFront<XMacHeaderBase>();
                    sendPreamble(pkt_preamble->getDestAddr());
                }
                return;
            }
            // ack_rx within sending_preamble or preamble_timeout without an ACK
            if ((msg->getKind() == XMAC_ACK) || (msg->getKind() == XMAC_STOP_PREAMBLES)) {
                // ~ ADDED THE SECOND CONDITION! :) if not, below
                if (msg->getKind() == XMAC_ACK) {
                    delete msg;
                    EV << "node " << address << " : State SEND_PREAMBLE, message XMAC_ACK, new state SEND_DATA" << endl;
                }
                else if (msg->getKind() == XMAC_STOP_PREAMBLES) {
                    EV << "node " << address << " : State SEND_PREAMBLE, message XMAC_STOP_PREAMBLES" << endl;
                }
                macState = SEND_DATA;
                cancelEvent(stop_preambles);
                cancelEvent(switch_preamble_phase);
                changeDisplayColor(RED);
                radio->setRadioMode(IRadio::RADIO_MODE_TRANSMITTER);
                txAttempts = 1;
                return;
            }
 
            // next is the case of a node receiving 1 preamble or data while in his preamble gaps, ignore, we are sending!
            if ((msg->getKind() == XMAC_PREAMBLE) || (msg->getKind() == XMAC_DATA)) {
                if (msg->getKind() == XMAC_DATA) {
                    nbDroppedDataPackets++;
                }
                delete msg;
                return;
            }
            else {
                EV << "**node " << address << " : State SEND_PREAMBLE, received message " << msg->getKind() << endl;
                return;
            }
            break;
 
        case SEND_DATA:
            if (msg->getKind() == XMAC_STOP_PREAMBLES) {
                EV << "node " << address << " : State SEND_DATA, message XMAC_STOP_PREAMBLES" << endl;
                // send the data packet
                sendDataPacket();
                macState = WAIT_TX_DATA_OVER;
                return;
            }
            else if (msg->getKind() == XMAC_SWITCHING_FINISHED) {
                EV << "node " << address << " : State SEND_DATA, message RADIO_SWITCHING OVER, sending packet..." << endl;
                // send the data packet
                sendDataPacket();
                macState = WAIT_TX_DATA_OVER;
                return;
            }
            else {
                return;
            }
            break;
 
        case WAIT_TX_DATA_OVER:
            if (msg->getKind() == XMAC_DATA_TX_OVER) {
                EV_DEBUG << "node " << address << " : State WAIT_TX_DATA_OVER, message XMAC_DATA_TX_OVER, new state  SLEEP" << endl;
                // remove the packet just served from the queue
                deleteCurrentTxFrame();
                // if something in the queue, wakeup soon.
                if (!txQueue->isEmpty())
                    scheduleAfter(dblrand() * checkInterval, wakeup);
                else
                    scheduleAfter(slotDuration, wakeup);
                macState = SLEEP;
                radio->setRadioMode(IRadio::RADIO_MODE_SLEEP);
                changeDisplayColor(BLACK);
                return;
            }
            break;
        case WAIT_ACK:
            // not used
            break;
        case WAIT_DATA:
            if (msg->getKind() == XMAC_PREAMBLE) {
                // nothing happens
                nbRxPreambles++;
                delete msg;
                return;
            }
            if (msg->getKind() == XMAC_ACK) {
                // nothing happens
                delete msg;
                return;
            }
            if (msg->getKind() == XMAC_DATA) {
                auto packet = check_and_cast<Packet *>(msg);
                auto mac = packet->peekAtFront<XMacDataFrameHeader>();
                const MacAddress& dest = mac->getDestAddr();
 
                if ((dest == address) || dest.isBroadcast() || dest.isMulticast()) {
                    decapsulate(packet);
                    sendUp(packet);
                    nbRxDataPackets++;
                    cancelEvent(data_timeout);
 
                    // if something in the queue, wakeup soon.
                    if (!txQueue->isEmpty())
                        scheduleAfter(dblrand() * checkInterval, wakeup);
                    else
                        scheduleAfter(slotDuration, wakeup);
                    macState = SLEEP;
                    radio->setRadioMode(IRadio::RADIO_MODE_SLEEP);
                    changeDisplayColor(BLACK);
 
                }
                else {
                    delete msg;
                    msg = nullptr;
                    mac = nullptr;
                }
 
                EV << "node " << address << " : State WAIT_DATA, message XMAC_DATA, new state  SLEEP" << endl;
                return;
            }
            // data does not arrives in time
            if (msg->getKind() == XMAC_DATA_TIMEOUT) {
                EV << "node " << address << " : State WAIT_DATA, message XMAC_DATA_TIMEOUT, new state SLEEP" << endl;
                // if something in the queue, wakeup soon.
                if (!txQueue->isEmpty())
                    scheduleAfter(dblrand() * checkInterval, wakeup);
                else
                    scheduleAfter(slotDuration, wakeup);
                macState = SLEEP;
                radio->setRadioMode(IRadio::RADIO_MODE_SLEEP);
                changeDisplayColor(BLACK);
                return;
            }
            break;
        case SEND_ACK:
            // send now the ack packet
            if (msg->getKind() == DELAY_FOR_ACK_WITHIN_REMOTE_RX) {
                EV_DEBUG << "node " << address << " : State SEND_ACK, message XMAC_SEND_ACK, new state WAIT_ACK_TX" << endl;
                sendMacAck();
                macState = WAIT_ACK_TX;
                return;
            }
            break;
        case WAIT_ACK_TX:
            // wait for the ACK to be sent back to the Transmitter
            if (msg->getKind() == XMAC_ACK_TX_OVER) {
                EV_DEBUG << "node " << address << " : State WAIT_ACK_TX, message XMAC_ACK_TX_OVER, new state WAIT_DATA" << endl;
                changeDisplayColor(GREEN);
                macState = WAIT_DATA;
                cancelEvent(cca_timeout);
                scheduleAfter((slotDuration / 2), data_timeout);
                radio->setRadioMode(IRadio::RADIO_MODE_RECEIVER);
                return;
            }
            break;
    }
    throw cRuntimeError("Undefined event of type %d in state %d (Radio state %d)!",
            msg->getKind(), macState, radio->getRadioMode());
}

handleUpperPacket()

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

overridevirtual

Handle messages from upper layer.

Check whether the queue is not full: if yes, print a warning and drop the packet.

Then initiate sending of the packet, if the node is sleeping. Do nothing, if node is working.

Reimplemented from inet::LayeredProtocolBase.

{
    throw cRuntimeError("Model error: this module should pull packet from upper queue, direct incoming packet not accepted");
}

initialize()

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

overridevirtual

Initialization of the module and some variables.

Initialize method of XMac.

Init all parameters, schedule timers.

Reimplemented from inet::MacProtocolBase.

{
    MacProtocolBase::initialize(stage);
    if (stage == INITSTAGE_LOCAL) {
        animation = par("animation");
        slotDuration = par("slotDuration");
        bitrate = par("bitrate");
        headerLength = b(par("headerLength"));
        ctrlFrameLength = b(par("ctrlFrameLength"));
        checkInterval = par("checkInterval");
        txPower = par("txPower");
        useMacAcks = par("useMACAcks");
        maxTxAttempts = par("maxTxAttempts");
        EV_DEBUG << "headerLength: " << headerLength << "ctrlFrameLength: " << ctrlFrameLength << ", bitrate: " << bitrate << endl;
 
        stats = par("stats");
        nbTxDataPackets = 0;
        nbTxPreambles = 0;
        nbRxDataPackets = 0;
        nbRxPreambles = 0;
        nbMissedAcks = 0;
        nbRecvdAcks = 0;
        nbDroppedDataPackets = 0;
        nbRxBrokenDataPackets = 0;
        nbTxAcks = 0;
 
        txAttempts = 0;
        lastDataPktDestAddr = MacAddress::BROADCAST_ADDRESS;
        lastDataPktSrcAddr = MacAddress::BROADCAST_ADDRESS;
 
        macState = INIT;
        txQueue = getQueue(gate(upperLayerInGateId));
        WATCH(macState);
    }
    else if (stage == INITSTAGE_LINK_LAYER) {
        radio.reference(this, "radioModule", true);
        cModule *radioModule = check_and_cast<cModule *>(radio.get());
        radioModule->subscribe(IRadio::radioModeChangedSignal, this);
        radioModule->subscribe(IRadio::transmissionStateChangedSignal, this);
 
        wakeup = new cMessage("wakeup", XMAC_WAKE_UP);
 
        data_timeout = new cMessage("data_timeout", XMAC_DATA_TIMEOUT);
        data_timeout->setSchedulingPriority(100);
 
        data_tx_over = new cMessage("data_tx_over", XMAC_DATA_TX_OVER);
        stop_preambles = new cMessage("stop_preambles", XMAC_STOP_PREAMBLES);
        send_preamble = new cMessage("send_preamble", XMAC_SEND_PREAMBLE);
        ack_tx_over = new cMessage("ack_tx_over", XMAC_ACK_TX_OVER);
        cca_timeout = new cMessage("cca_timeout", XMAC_CCA_TIMEOUT);
        cca_timeout->setSchedulingPriority(100);
        send_ack = new cMessage("send_ack", XMAC_SEND_ACK);
        start_xmac = new cMessage("start_xmac", XMAC_START_XMAC);
        ack_timeout = new cMessage("ack_timeout", XMAC_ACK_TIMEOUT);
        resend_data = new cMessage("resend_data", XMAC_RESEND_DATA);
        resend_data->setSchedulingPriority(100);
        switch_preamble_phase = new cMessage("switch_preamble_phase", SWITCH_PREAMBLE_PHASE);
        delay_for_ack_within_remote_rx = new cMessage("delay_for_ack_within_remote_rx", DELAY_FOR_ACK_WITHIN_REMOTE_RX);
        switching_done = new cMessage("switching_done", XMAC_SWITCHING_FINISHED);
 
        scheduleAfter(SIMTIME_ZERO, start_xmac);
    }
}

operator=()

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

private

Assignment operator is not allowed.

receiveSignal()

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

override

Handle transmission over messages: either send another preambles or the data packet itself.

{
    Enter_Method("%s", cComponent::getSignalName(signalID));
 
    if (signalID == IRadio::transmissionStateChangedSignal) {
        IRadio::TransmissionState newRadioTransmissionState = (IRadio::TransmissionState)value;
        if (transmissionState == IRadio::TRANSMISSION_STATE_TRANSMITTING && newRadioTransmissionState == IRadio::TRANSMISSION_STATE_IDLE) {
            // Transmission of one packet is over
            if (macState == WAIT_TX_DATA_OVER) {
                scheduleAfter(SIMTIME_ZERO, data_tx_over);
            }
            if (macState == WAIT_ACK_TX) {
                scheduleAfter(SIMTIME_ZERO, ack_tx_over);
            }
        }
        transmissionState = newRadioTransmissionState;
    }
    else if (signalID == IRadio::radioModeChangedSignal) {
        // Radio switching (to RX or TX) is over, ignore switching to SLEEP.
        if (macState == SEND_PREAMBLE) {
            scheduleAfter(SIMTIME_ZERO, switching_done);
        }
        else if (macState == SEND_ACK) {
            scheduleAfter(0.5f * checkInterval, delay_for_ack_within_remote_rx);
        }
        else if (macState == SEND_DATA) {
            scheduleAfter(SIMTIME_ZERO, switching_done);
        }
    }
}

sendDataPacket()

void inet::XMac::sendDataPacket ( )

protected

Internal function to send the first packet in the queue.

{
    nbTxDataPackets++;
    if (currentTxFrame == nullptr) {
        currentTxFrame = dequeuePacket();
        encapsulate(currentTxFrame);
    }
    auto packet = currentTxFrame->dup();
    const auto& hdr = packet->peekAtFront<XMacHeaderBase>();
    lastDataPktDestAddr = hdr->getDestAddr();
    ASSERT(hdr->getType() == XMAC_DATA);
    attachSignal(packet, simTime());
    sendDown(packet);
}

sendMacAck()

void inet::XMac::sendMacAck ( )

protected

Internal function to send an ACK.

Send one short preamble packet immediately.

{
    auto ack = makeShared<XMacControlFrame>();
    ack->setSrcAddr(networkInterface->getMacAddress());
    // ~ diff with XMAC, ack_preamble_based
    ack->setDestAddr(lastPreamblePktSrcAddr);
    ack->setChunkLength(ctrlFrameLength);
    ack->setType(XMAC_ACK);
    auto packet = new Packet("XMacAck", ack);
    packet->addTag<PacketProtocolTag>()->setProtocol(&Protocol::xmac);
    attachSignal(packet, simTime());
    sendDown(packet);
    nbTxAcks++;
}

sendPreamble()

void inet::XMac::sendPreamble ( MacAddress  destination )

protected

Internal function to send one preamble.

Send one short preamble packet immediately.

{
    // ~ diff with XMAC, @ in preamble!
    auto preamble = makeShared<XMacControlFrame>();
    preamble->setSrcAddr(networkInterface->getMacAddress());
    preamble->setDestAddr(preamble_address);
    preamble->setChunkLength(ctrlFrameLength);
    preamble->setType(XMAC_PREAMBLE);
    auto packet = new Packet("Preamble", preamble);
    packet->addTag<PacketProtocolTag>()->setProtocol(&Protocol::xmac);
    attachSignal(packet, simTime());
    sendDown(packet);
    nbTxPreambles++;
}

Member Data Documentation

ack_timeout

cMessage* inet::XMac::ack_timeout

protected

ack_tx_over

cMessage* inet::XMac::ack_tx_over

protected

animation

bool inet::XMac::animation

protected

Animate (colorize) the nodes.

The color of the node reflects its basic status (not the exact state!) BLACK - node is sleeping GREEN - node is receiving YELLOW - node is sending

bitrate

double inet::XMac::bitrate

protected

The bitrate of transmission.

cca_timeout

cMessage* inet::XMac::cca_timeout

protected

checkInterval

double inet::XMac::checkInterval

protected

The duration of CCA.

ctrlFrameLength

b inet::XMac::ctrlFrameLength = b(0)

protected

data_timeout

cMessage* inet::XMac::data_timeout

protected

data_tx_over

cMessage* inet::XMac::data_tx_over

protected

delay_for_ack_within_remote_rx

cMessage* inet::XMac::delay_for_ack_within_remote_rx

protected

headerLength

b inet::XMac::headerLength = b(0)

protected

lastDataPktDestAddr

MacAddress inet::XMac::lastDataPktDestAddr

protected

lastDataPktSrcAddr

MacAddress inet::XMac::lastDataPktSrcAddr

protected

lastPreamblePktSrcAddr

MacAddress inet::XMac::lastPreamblePktSrcAddr

protected

macState

States inet::XMac::macState

protected

The current state of the protocol.

maxTxAttempts

int inet::XMac::maxTxAttempts

protected

Maximum transmission attempts per data packet, when ACKs are used.

nbDroppedDataPackets

long inet::XMac::nbDroppedDataPackets

protected

nbMissedAcks

long inet::XMac::nbMissedAcks

protected

nbRecvdAcks

long inet::XMac::nbRecvdAcks

protected

nbRxBrokenDataPackets

long inet::XMac::nbRxBrokenDataPackets

protected

nbRxDataPackets

long inet::XMac::nbRxDataPackets

protected

nbRxPreambles

long inet::XMac::nbRxPreambles

protected

nbTxAcks

long inet::XMac::nbTxAcks

protected

nbTxDataPackets

long inet::XMac::nbTxDataPackets

protected

nbTxPreambles

long inet::XMac::nbTxPreambles

protected

radio

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

protected

The radio.

resend_data

cMessage* inet::XMac::resend_data

protected

send_ack

cMessage* inet::XMac::send_ack

protected

send_preamble

cMessage* inet::XMac::send_preamble

protected

slotDuration

double inet::XMac::slotDuration

protected

The duration of the slot in secs.

start_xmac

cMessage* inet::XMac::start_xmac

protected

stats

bool inet::XMac::stats

protected

Gather stats at the end of the simulation.

stop_preambles

cMessage* inet::XMac::stop_preambles

protected

switch_preamble_phase

cMessage* inet::XMac::switch_preamble_phase

protected

switching_done

cMessage* inet::XMac::switching_done

protected

transmissionState

physicallayer::IRadio::TransmissionState inet::XMac::transmissionState = physicallayer::IRadio::TRANSMISSION_STATE_UNDEFINED

protected

txAttempts

int inet::XMac::txAttempts

protected

txPower

double inet::XMac::txPower

protected

Transmission power of the node.

useMacAcks

bool inet::XMac::useMacAcks

protected

Use MAC level acks or not.

wakeup

cMessage* inet::XMac::wakeup

protected

---

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

• XMac.h
• XMac.cc