inet::BMacLayer Class Reference

Implementation of B-MAC (called also Berkeley MAC, Low Power Listening or LPL). More...

#include <BMacLayer.h>

Inheritance diagram for inet::BMacLayer:

Public Member Functions
	BMacLayer ()
virtual	~BMacLayer ()
virtual int	numInitStages () const override
	Initialization of the module and some variables. More...
virtual void	initialize (int) override
virtual void	refreshDisplay () const override
	Change the color of the node for animation purposes. More...
virtual void	finish () override
	Delete all dynamically allocated objects of the module. More...
virtual void	handleLowerPacket (cPacket *) override
	Handle messages from lower layer. More...
virtual void	handleUpperPacket (cPacket *) override
	Handle messages from upper layer. More...
virtual void	handleSelfMessage (cMessage *) override
	Handle self messages such as timers. More...
virtual void	receiveSignal (cComponent *source, simsignal_t signalID, long value, cObject *details) override
	Handle control messages from lower layer. More...
Public Member Functions inherited from inet::OperationalBase
	OperationalBase ()
Public Member Functions inherited from inet::ILifecycle
virtual	~ILifecycle ()
Public Member Functions inherited from inet::IMACProtocol
virtual	~IMACProtocol ()

Protected Types
enum	States {   INIT, SLEEP, CCA, SEND_PREAMBLE,   WAIT_DATA, SEND_DATA, WAIT_TX_DATA_OVER, WAIT_ACK,   SEND_ACK, WAIT_ACK_TX }
	MAC states. More...
enum	TYPES {   BMAC_PREAMBLE = 191, BMAC_DATA, BMAC_ACK, BMAC_RESEND_DATA,   BMAC_ACK_TIMEOUT, BMAC_START_BMAC, BMAC_WAKE_UP, BMAC_SEND_ACK,   BMAC_CCA_TIMEOUT, BMAC_ACK_TX_OVER, BMAC_SEND_PREAMBLE, BMAC_STOP_PREAMBLES,   BMAC_DATA_TX_OVER, BMAC_DATA_TIMEOUT }
	Types of messages (self messages and packets) the node can process. More...
typedef std::list< BMacFrame * >	MacQueue

Protected Member Functions
virtual void	initializeMACAddress ()
	Generate new interface address. More...
virtual InterfaceEntry *	createInterfaceEntry () override
virtual void	handleCommand (cMessage *msg)
void	sendDataPacket ()
	Internal function to send the first packet in the queue. More...
void	sendMacAck ()
	Internal function to send an ACK. More...
void	sendPreamble ()
	Internal function to send one preamble. More...
void	attachSignal (BMacFrame *macPkt)
	Internal function to attach a signal to the packet. More...
bool	addToQueue (cMessage *msg)
	Internal function to add a new packet from upper to the queue. More...
virtual void	flushQueue ()
virtual void	clearQueue ()
cPacket *	decapsMsg (BMacFrame *msg)
BMacFrame *	encapsMsg (cPacket *netwPkt)
cObject *	setUpControlInfo (cMessage *const pMsg, const MACAddress &pSrcAddr)
	Attaches a "control info" (MacToNetw) structure (object) to the message pMsg. More...
Protected Member Functions inherited from inet::MACProtocolBase
	MACProtocolBase ()
virtual void	registerInterface ()
virtual void	sendUp (cMessage *message)
virtual void	sendDown (cMessage *message)
virtual bool	isUpperMessage (cMessage *message) override
virtual bool	isLowerMessage (cMessage *message) override
virtual bool	isInitializeStage (int stage) override
virtual bool	isNodeStartStage (int stage) override
virtual bool	isNodeShutdownStage (int stage) override
Protected Member Functions inherited from inet::LayeredProtocolBase
virtual void	handleMessageWhenUp (cMessage *message) override
virtual void	handleUpperCommand (cMessage *message)
virtual void	handleLowerCommand (cMessage *message)
Protected Member Functions inherited from inet::OperationalBase
virtual void	handleMessage (cMessage *msg) override
virtual void	handleMessageWhenDown (cMessage *msg)
virtual bool	handleOperationStage (LifecycleOperation *operation, int stage, IDoneCallback *doneCallback) override
	Perform one stage of a lifecycle operation. More...
virtual bool	handleNodeStart (IDoneCallback *doneCallback)
virtual bool	handleNodeShutdown (IDoneCallback *doneCallback)
virtual void	handleNodeCrash ()
virtual void	setOperational (bool isOperational)

Protected Attributes
MACAddress	address
	The MAC address of the interface. More...
MacQueue	macQueue
	A queue to store packets from upper layer in case another packet is still waiting for transmission. More...
IRadio *	radio = nullptr
	The radio. More...
IRadio::TransmissionState	transmissionState = IRadio::TRANSMISSION_STATE_UNDEFINED
States	macState = (States)-1
	The current state of the protocol. More...
cMessage *	resend_data = nullptr
cMessage *	ack_timeout = nullptr
cMessage *	start_bmac = nullptr
cMessage *	wakeup = nullptr
cMessage *	send_ack = nullptr
cMessage *	cca_timeout = nullptr
cMessage *	ack_tx_over = nullptr
cMessage *	send_preamble = nullptr
cMessage *	stop_preambles = nullptr
cMessage *	data_tx_over = nullptr
cMessage *	data_timeout = nullptr
unsigned int	queueLength = 0
	The maximum length of the queue. More...
bool	animation = false
	Animate (colorize) the nodes. More...
double	slotDuration = 0
	The duration of the slot in secs. More...
int	headerLength = 0
	Length of the header. More...
double	bitrate = 0
	The bitrate of transmission. More...
double	checkInterval = 0
	The duration of CCA. More...
bool	useMacAcks = false
	Use MAC level acks or not. More...
int	maxTxAttempts = 0
	Maximum transmission attempts per data packet, when ACKs are used. More...
bool	stats = false
	Gather stats at the end of the simulation. More...
Different tracked statistics.
long	nbTxDataPackets = 0
long	nbTxPreambles = 0
long	nbRxDataPackets = 0
long	nbRxPreambles = 0
long	nbMissedAcks = 0
long	nbRecvdAcks = 0
long	nbDroppedDataPackets = 0
long	nbTxAcks = 0
Help variables for the acknowledgment process.
MACAddress	lastDataPktSrcAddr
MACAddress	lastDataPktDestAddr
int	txAttempts = 0
Protected Attributes inherited from inet::OperationalBase
bool	isOperational
simtime_t	lastChange

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

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

Detailed Description

Implementation of B-MAC (called also Berkeley MAC, Low Power Listening or LPL).

The protocol works as follows: each node is allowed to sleep for slotDuration. After waking up, it first checks the channel for ongoing transmissions. If a transmission is catched (a preamble is received), the node stays awake for at most slotDuration and waits for the actual data packet. If a node wants to send a packet, it first sends preambles for at least slotDuration, thus waking up all nodes in its transmission radius and then sends out the data packet. If a mac-level ack is required, then the receiver sends the ack immediately after receiving the packet (no preambles) and the sender waits for some time more before going back to sleep.

B-MAC is designed for low traffic, low power communication in WSN and is one of the most widely used protocols (e.g. it is part of TinyOS). The finite state machine of the protocol is given in the below figure:

B-MAC Layer - finite state machine

A paper describing this implementation can be found at: http://www.omnet-workshop.org/2011/uploads/slides/OMNeT_WS2011_S5_C1_Foerster.pdf

Author

Anna Foerster

Member Typedef Documentation

typedef std::list<BMacFrame *> inet::BMacLayer::MacQueue

protected

Member Enumeration Documentation

enum inet::BMacLayer::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
        SEND_ACK,    //8
        WAIT_ACK_TX    //9
    };

enum inet::BMacLayer::TYPES

protected

Types of messages (self messages and packets) the node can process.

Enumerator
BMAC_PREAMBLE
BMAC_DATA
BMAC_ACK
BMAC_RESEND_DATA
BMAC_ACK_TIMEOUT
BMAC_START_BMAC
BMAC_WAKE_UP
BMAC_SEND_ACK
BMAC_CCA_TIMEOUT
BMAC_ACK_TX_OVER
BMAC_SEND_PREAMBLE
BMAC_STOP_PREAMBLES
BMAC_DATA_TX_OVER
BMAC_DATA_TIMEOUT

               {
        // packet types
        BMAC_PREAMBLE = 191,
        BMAC_DATA,
        BMAC_ACK,
        // self message types
        BMAC_RESEND_DATA,
        BMAC_ACK_TIMEOUT,
        BMAC_START_BMAC,
        BMAC_WAKE_UP,
        BMAC_SEND_ACK,
        BMAC_CCA_TIMEOUT,
        BMAC_ACK_TX_OVER,
        BMAC_SEND_PREAMBLE,
        BMAC_STOP_PREAMBLES,
        BMAC_DATA_TX_OVER,
        BMAC_DATA_TIMEOUT
    };

Constructor & Destructor Documentation

inet::BMacLayer::BMacLayer ( const BMacLayer &  )

private

Copy constructor is not allowed.

inet::BMacLayer::BMacLayer ( )

inline

{}

inet::BMacLayer::~BMacLayer ( )

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_bmac);
    cancelAndDelete(ack_timeout);
    cancelAndDelete(resend_data);

    for (auto & elem : macQueue) {
        delete (elem);
    }
    macQueue.clear();
}

Member Function Documentation

bool inet::BMacLayer::addToQueue ( cMessage *  msg )

protected

Internal function to add a new packet from upper to the queue.

Encapsulates the received network-layer packet into a BMacFrame and set all needed header fields.

Referenced by handleUpperPacket().

{
    if (macQueue.size() >= queueLength) {
        // queue is full, message has to be deleted
        EV_DETAIL << "New packet arrived, but queue is FULL, so new packet is"
                     " deleted\n";
        emit(packetFromUpperDroppedSignal, msg);
        nbDroppedDataPackets++;
        return false;
    }

    BMacFrame *macPkt = encapsMsg((cPacket *)msg);
    macQueue.push_back(macPkt);
    EV_DETAIL << "Max queue length: " << queueLength << ", packet put in queue"
                                                        "\n  queue size: " << macQueue.size() << " macState: "
              << macState << endl;
    return true;
}

void inet::BMacLayer::attachSignal ( BMacFrame *  macPkt )

protected

Internal function to attach a signal to the packet.

Referenced by sendDataPacket(), sendMacAck(), and sendPreamble().

{
    //calc signal duration
    simtime_t duration = macPkt->getBitLength() / bitrate;
    //create and initialize control info with new signal
    macPkt->setDuration(duration);
}

void inet::BMacLayer::clearQueue ( )

protectedvirtual

{
    macQueue.clear();
}

InterfaceEntry * inet::BMacLayer::createInterfaceEntry ( )

overrideprotectedvirtual

Implements inet::MACProtocolBase.

{
    InterfaceEntry *e = new InterfaceEntry(this);

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

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

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

    return e;
}

cPacket * inet::BMacLayer::decapsMsg ( BMacFrame *  msg )

protected

Referenced by handleSelfMessage().

{
    cPacket *m = msg->decapsulate();
    setUpControlInfo(m, msg->getSrcAddr());
    // delete the macPkt
    delete msg;
    EV_DETAIL << " message decapsulated " << endl;
    return m;
}

BMacFrame * inet::BMacLayer::encapsMsg ( cPacket *  netwPkt )

protected

Referenced by addToQueue().

{
    BMacFrame *pkt = new BMacFrame(netwPkt->getName(), netwPkt->getKind());
    pkt->setBitLength(headerLength);

    // copy dest address from the Control Info attached to the network
    // message by the network layer
    IMACProtocolControlInfo *cInfo = check_and_cast<IMACProtocolControlInfo *>(netwPkt->removeControlInfo());
    EV_DETAIL << "CInfo removed, mac addr=" << cInfo->getDestinationAddress() << endl;
    pkt->setDestAddr(cInfo->getDestinationAddress());

    //delete the control info
    delete cInfo;

    //set the src address to own mac address (nic module getId())
    pkt->setSrcAddr(address);

    //encapsulate the network packet
    pkt->encapsulate(netwPkt);
    EV_DETAIL << "pkt encapsulated\n";

    return pkt;
}

void inet::BMacLayer::finish ( )

overridevirtual

Delete all dynamically allocated objects of the module.

{
    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("timeSleep", timeSleep);
    //recordScalar("timeRX", timeRX);
    //recordScalar("timeTX", timeTX);
}

void inet::BMacLayer::flushQueue ( )

protectedvirtual

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

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

inlineprotectedvirtual

{}

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

overridevirtual

Handle messages from lower layer.

Handle BMAC preambles and received data packets.

Implements inet::LayeredProtocolBase.

{
    if (msg->hasBitError()) {
        EV << "Received " << msg << " contains bit errors or collision, dropping it\n";
        delete msg;
        return;
    }
    else
        // simply pass the massage as self message, to be processed by the FSM.
        handleSelfMessage(msg);
}

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

overridevirtual

Handle self messages such as timers.

Handle own messages: BMAC_WAKEUP: wake up the node, check the channel for some time.

BMAC_CHECK_CHANNEL: if the channel is free, check whether there is something in the queue and switch the radio to TX. When switched to TX, the node will start sending preambles for a full slot duration. If the channel is busy, stay awake to receive message. Schedule a timeout to handle false alarms. BMAC_SEND_PREAMBLES: sending of preambles over. Next time the data packet will be send out (single one). BMAC_TIMEOUT_DATA: timeout the node after a false busy channel alarm. Go back to sleep.

Reimplemented from inet::LayeredProtocolBase.

Referenced by handleLowerPacket().

{
    switch (macState) {
        case INIT:
            if (msg->getKind() == BMAC_START_BMAC) {
                EV_DETAIL << "State INIT, message BMAC_START, new state SLEEP" << endl;
                radio->setRadioMode(IRadio::RADIO_MODE_SLEEP);
                macState = SLEEP;
                scheduleAt(simTime() + dblrand() * slotDuration, wakeup);
                return;
            }
            break;

        case SLEEP:
            if (msg->getKind() == BMAC_WAKE_UP) {
                EV_DETAIL << "State SLEEP, message BMAC_WAKEUP, new state CCA" << endl;
                scheduleAt(simTime() + checkInterval, cca_timeout);
                radio->setRadioMode(IRadio::RADIO_MODE_RECEIVER);
                macState = CCA;
                return;
            }
            break;

        case CCA:
            if (msg->getKind() == BMAC_CCA_TIMEOUT) {
                // channel is clear
                // something waiting in eth queue?
                if (macQueue.size() > 0) {
                    EV_DETAIL << "State CCA, message CCA_TIMEOUT, new state"
                                 " SEND_PREAMBLE" << endl;
                    macState = SEND_PREAMBLE;
                    radio->setRadioMode(IRadio::RADIO_MODE_TRANSMITTER);
                    scheduleAt(simTime() + slotDuration, stop_preambles);
                    return;
                }
                // if not, go back to sleep and wake up after a full period
                else {
                    EV_DETAIL << "State CCA, message CCA_TIMEOUT, new state SLEEP"
                              << endl;
                    scheduleAt(simTime() + slotDuration, wakeup);
                    macState = SLEEP;
                    radio->setRadioMode(IRadio::RADIO_MODE_SLEEP);
                    return;
                }
            }
            // during CCA, we received a preamble. Go to state WAIT_DATA and
            // schedule the timeout.
            if (msg->getKind() == BMAC_PREAMBLE) {
                nbRxPreambles++;
                EV_DETAIL << "State CCA, message BMAC_PREAMBLE received, new state"
                             " WAIT_DATA" << endl;
                macState = WAIT_DATA;
                cancelEvent(cca_timeout);
                scheduleAt(simTime() + slotDuration + checkInterval, data_timeout);
                delete msg;
                return;
            }
            // this case is very, very, very improbable, but let's do it.
            // if in CCA and the node receives directly the data packet, switch to
            // state WAIT_DATA and re-send the message
            if (msg->getKind() == BMAC_DATA) {
                nbRxDataPackets++;
                EV_DETAIL << "State CCA, message BMAC_DATA, new state WAIT_DATA"
                          << endl;
                macState = WAIT_DATA;
                cancelEvent(cca_timeout);
                scheduleAt(simTime() + slotDuration + checkInterval, data_timeout);
                scheduleAt(simTime(), msg);
                return;
            }
            //in case we get an ACK, we simply dicard it, because it means the end
            //of another communication
            if (msg->getKind() == BMAC_ACK) {
                EV_DETAIL << "State CCA, message BMAC_ACK, new state CCA" << endl;
                delete msg;
                return;
            }
            break;

        case SEND_PREAMBLE:
            if (msg->getKind() == BMAC_SEND_PREAMBLE) {
                EV_DETAIL << "State SEND_PREAMBLE, message BMAC_SEND_PREAMBLE, new"
                             " state SEND_PREAMBLE" << endl;
                sendPreamble();
                scheduleAt(simTime() + 0.5f * checkInterval, send_preamble);
                macState = SEND_PREAMBLE;
                return;
            }
            // simply change the state to SEND_DATA
            if (msg->getKind() == BMAC_STOP_PREAMBLES) {
                EV_DETAIL << "State SEND_PREAMBLE, message BMAC_STOP_PREAMBLES, new"
                             " state SEND_DATA" << endl;
                macState = SEND_DATA;
                txAttempts = 1;
                return;
            }
            break;

        case SEND_DATA:
            if ((msg->getKind() == BMAC_SEND_PREAMBLE)
                || (msg->getKind() == BMAC_RESEND_DATA))
            {
                EV_DETAIL << "State SEND_DATA, message BMAC_SEND_PREAMBLE or"
                             " BMAC_RESEND_DATA, new state WAIT_TX_DATA_OVER" << endl;
                // send the data packet
                sendDataPacket();
                macState = WAIT_TX_DATA_OVER;
                return;
            }
            break;

        case WAIT_TX_DATA_OVER:
            if (msg->getKind() == BMAC_DATA_TX_OVER) {
                if ((useMacAcks) && !lastDataPktDestAddr.isBroadcast()) {
                    EV_DETAIL << "State WAIT_TX_DATA_OVER, message BMAC_DATA_TX_OVER,"
                                 " new state WAIT_ACK" << endl;
                    macState = WAIT_ACK;
                    radio->setRadioMode(IRadio::RADIO_MODE_RECEIVER);
                    scheduleAt(simTime() + checkInterval, ack_timeout);
                }
                else {
                    EV_DETAIL << "State WAIT_TX_DATA_OVER, message BMAC_DATA_TX_OVER,"
                                 " new state  SLEEP" << endl;
                    delete macQueue.front();
                    macQueue.pop_front();
                    // if something in the queue, wakeup soon.
                    if (macQueue.size() > 0)
                        scheduleAt(simTime() + dblrand() * checkInterval, wakeup);
                    else
                        scheduleAt(simTime() + slotDuration, wakeup);
                    macState = SLEEP;
                    radio->setRadioMode(IRadio::RADIO_MODE_SLEEP);
                }
                return;
            }
            break;

        case WAIT_ACK:
            if (msg->getKind() == BMAC_ACK_TIMEOUT) {
                // No ACK received. try again or drop.
                if (txAttempts < maxTxAttempts) {
                    EV_DETAIL << "State WAIT_ACK, message BMAC_ACK_TIMEOUT, new state"
                                 " SEND_DATA" << endl;
                    txAttempts++;
                    macState = SEND_PREAMBLE;
                    scheduleAt(simTime() + slotDuration, stop_preambles);
                    radio->setRadioMode(IRadio::RADIO_MODE_TRANSMITTER);
                }
                else {
                    EV_DETAIL << "State WAIT_ACK, message BMAC_ACK_TIMEOUT, new state"
                                 " SLEEP" << endl;
                    //drop the packet
                    cMessage *mac = macQueue.front();
                    macQueue.pop_front();
                    emit(NF_LINK_BREAK, mac);
                    delete mac;

                    // if something in the queue, wakeup soon.
                    if (macQueue.size() > 0)
                        scheduleAt(simTime() + dblrand() * checkInterval, wakeup);
                    else
                        scheduleAt(simTime() + slotDuration, wakeup);
                    macState = SLEEP;
                    radio->setRadioMode(IRadio::RADIO_MODE_SLEEP);
                    nbMissedAcks++;
                }
                return;
            }
            //ignore and other packets
            if ((msg->getKind() == BMAC_DATA) || (msg->getKind() == BMAC_PREAMBLE)) {
                EV_DETAIL << "State WAIT_ACK, message BMAC_DATA or BMAC_PREMABLE, new"
                             " state WAIT_ACK" << endl;
                delete msg;
                return;
            }
            if (msg->getKind() == BMAC_ACK) {
                EV_DETAIL << "State WAIT_ACK, message BMAC_ACK" << endl;
                BMacFrame *mac = static_cast<BMacFrame *>(msg);
                const MACAddress src = mac->getSrcAddr();
                // the right ACK is received..
                EV_DETAIL << "We are waiting for ACK from : " << lastDataPktDestAddr
                          << ", and ACK came from : " << src << endl;
                if (src == lastDataPktDestAddr) {
                    EV_DETAIL << "New state SLEEP" << endl;
                    nbRecvdAcks++;
                    lastDataPktDestAddr = MACAddress::BROADCAST_ADDRESS;
                    cancelEvent(ack_timeout);
                    delete macQueue.front();
                    macQueue.pop_front();
                    // if something in the queue, wakeup soon.
                    if (macQueue.size() > 0)
                        scheduleAt(simTime() + dblrand() * checkInterval, wakeup);
                    else
                        scheduleAt(simTime() + slotDuration, wakeup);
                    macState = SLEEP;
                    radio->setRadioMode(IRadio::RADIO_MODE_SLEEP);
                    lastDataPktDestAddr = MACAddress::BROADCAST_ADDRESS;
                }
                delete msg;
                return;
            }
            break;

        case WAIT_DATA:
            if (msg->getKind() == BMAC_PREAMBLE) {
                //nothing happens
                EV_DETAIL << "State WAIT_DATA, message BMAC_PREAMBLE, new state"
                             " WAIT_DATA" << endl;
                nbRxPreambles++;
                delete msg;
                return;
            }
            if (msg->getKind() == BMAC_ACK) {
                //nothing happens
                EV_DETAIL << "State WAIT_DATA, message BMAC_ACK, new state WAIT_DATA"
                          << endl;
                delete msg;
                return;
            }
            if (msg->getKind() == BMAC_DATA) {
                nbRxDataPackets++;
                BMacFrame *mac = static_cast<BMacFrame *>(msg);
                const MACAddress& dest = mac->getDestAddr();
                const MACAddress& src = mac->getSrcAddr();
                if ((dest == address) || dest.isBroadcast()) {
                    EV_DETAIL << "Local delivery " << mac << endl;
                    sendUp(decapsMsg(mac));
                }
                else {
                    EV_DETAIL << "Received " << mac << " is not for us, dropping frame." << endl;
                    delete msg;
                    msg = nullptr;
                    mac = nullptr;
                }

                cancelEvent(data_timeout);
                if ((useMacAcks) && (dest == address)) {
                    EV_DETAIL << "State WAIT_DATA, message BMAC_DATA, new state"
                                 " SEND_ACK" << endl;
                    macState = SEND_ACK;
                    lastDataPktSrcAddr = src;
                    radio->setRadioMode(IRadio::RADIO_MODE_TRANSMITTER);
                }
                else {
                    EV_DETAIL << "State WAIT_DATA, message BMAC_DATA, new state SLEEP"
                              << endl;
                    // if something in the queue, wakeup soon.
                    if (macQueue.size() > 0)
                        scheduleAt(simTime() + dblrand() * checkInterval, wakeup);
                    else
                        scheduleAt(simTime() + slotDuration, wakeup);
                    macState = SLEEP;
                    radio->setRadioMode(IRadio::RADIO_MODE_SLEEP);
                }
                return;
            }
            if (msg->getKind() == BMAC_DATA_TIMEOUT) {
                EV_DETAIL << "State WAIT_DATA, message BMAC_DATA_TIMEOUT, new state"
                             " SLEEP" << endl;
                // if something in the queue, wakeup soon.
                if (macQueue.size() > 0)
                    scheduleAt(simTime() + dblrand() * checkInterval, wakeup);
                else
                    scheduleAt(simTime() + slotDuration, wakeup);
                macState = SLEEP;
                radio->setRadioMode(IRadio::RADIO_MODE_SLEEP);
                return;
            }
            break;

        case SEND_ACK:
            if (msg->getKind() == BMAC_SEND_ACK) {
                EV_DETAIL << "State SEND_ACK, message BMAC_SEND_ACK, new state"
                             " WAIT_ACK_TX" << endl;
                // send now the ack packet
                sendMacAck();
                macState = WAIT_ACK_TX;
                return;
            }
            break;

        case WAIT_ACK_TX:
            if (msg->getKind() == BMAC_ACK_TX_OVER) {
                EV_DETAIL << "State WAIT_ACK_TX, message BMAC_ACK_TX_OVER, new state"
                             " SLEEP" << endl;
                // ack sent, go to sleep now.
                // if something in the queue, wakeup soon.
                if (macQueue.size() > 0)
                    scheduleAt(simTime() + dblrand() * checkInterval, wakeup);
                else
                    scheduleAt(simTime() + slotDuration, wakeup);
                macState = SLEEP;
                radio->setRadioMode(IRadio::RADIO_MODE_SLEEP);
                lastDataPktSrcAddr = MACAddress::BROADCAST_ADDRESS;
                return;
            }
            break;
    }
    throw cRuntimeError("Undefined event of type %d in state %d (radio mode %d, radio reception state %d, radio transmission state %d)!",
            msg->getKind(), macState, radio->getRadioMode(), radio->getReceptionState(), radio->getTransmissionState());
}

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

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.

Implements inet::LayeredProtocolBase.

{
    bool pktAdded = addToQueue(msg);
    if (!pktAdded)
        return;
    // force wakeup now
    if (wakeup->isScheduled() && (macState == SLEEP)) {
        cancelEvent(wakeup);
        scheduleAt(simTime() + dblrand() * 0.1f, wakeup);
    }
}

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

overridevirtual

Reimplemented from inet::MACProtocolBase.

{
    MACProtocolBase::initialize(stage);
    if (stage == INITSTAGE_LOCAL) {
        queueLength = par("queueLength");
        animation = par("animation");
        slotDuration = par("slotDuration");
        bitrate = par("bitrate");
        headerLength = par("headerLength");
        checkInterval = par("checkInterval");
        useMacAcks = par("useMACAcks");
        maxTxAttempts = par("maxTxAttempts");
        EV_DETAIL << "headerLength: " << headerLength << ", bitrate: " << bitrate << endl;

        nbTxDataPackets = 0;
        nbTxPreambles = 0;
        nbRxDataPackets = 0;
        nbRxPreambles = 0;
        nbMissedAcks = 0;
        nbRecvdAcks = 0;
        nbDroppedDataPackets = 0;
        nbTxAcks = 0;

        txAttempts = 0;
        lastDataPktDestAddr = MACAddress::BROADCAST_ADDRESS;
        lastDataPktSrcAddr = MACAddress::BROADCAST_ADDRESS;

        macState = INIT;

        initializeMACAddress();
        registerInterface();

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

        // init the dropped packet info
        WATCH(macState);
    }
    else if (stage == INITSTAGE_LINK_LAYER) {
        wakeup = new cMessage("wakeup");
        wakeup->setKind(BMAC_WAKE_UP);

        data_timeout = new cMessage("data_timeout");
        data_timeout->setKind(BMAC_DATA_TIMEOUT);
        data_timeout->setSchedulingPriority(100);

        data_tx_over = new cMessage("data_tx_over");
        data_tx_over->setKind(BMAC_DATA_TX_OVER);

        stop_preambles = new cMessage("stop_preambles");
        stop_preambles->setKind(BMAC_STOP_PREAMBLES);

        send_preamble = new cMessage("send_preamble");
        send_preamble->setKind(BMAC_SEND_PREAMBLE);

        ack_tx_over = new cMessage("ack_tx_over");
        ack_tx_over->setKind(BMAC_ACK_TX_OVER);

        cca_timeout = new cMessage("cca_timeout");
        cca_timeout->setKind(BMAC_CCA_TIMEOUT);
        cca_timeout->setSchedulingPriority(100);

        send_ack = new cMessage("send_ack");
        send_ack->setKind(BMAC_SEND_ACK);

        start_bmac = new cMessage("start_bmac");
        start_bmac->setKind(BMAC_START_BMAC);

        ack_timeout = new cMessage("ack_timeout");
        ack_timeout->setKind(BMAC_ACK_TIMEOUT);

        resend_data = new cMessage("resend_data");
        resend_data->setKind(BMAC_RESEND_DATA);
        resend_data->setSchedulingPriority(100);

        scheduleAt(0.0, start_bmac);
    }
}

void inet::BMacLayer::initializeMACAddress ( )

protectedvirtual

Generate new interface address.

Referenced by initialize().

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

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

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

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

inlineoverridevirtual

Initialization of the module and some variables.

Reimplemented from inet::OperationalBase.

{ return NUM_INIT_STAGES; }

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

private

Assignment operator is not allowed.

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

overridevirtual

Handle control messages from lower layer.

{
    Enter_Method_Silent();
    if (signalID == IRadio::radioModeChangedSignal) {
        IRadio::RadioMode radioMode = (IRadio::RadioMode)value;
        if (radioMode == IRadio::RADIO_MODE_TRANSMITTER) {
            // we just switched to TX after CCA, so simply send the first
            // sendPremable self message
            if (macState == SEND_PREAMBLE)
                scheduleAt(simTime(), send_preamble);
            else if (macState == SEND_ACK)
                scheduleAt(simTime(), send_ack);
            // we were waiting for acks, but none came. we switched to TX and now
            // need to resend data
            else if (macState == SEND_DATA)
                scheduleAt(simTime(), resend_data);
        }
    }
    // Transmission of one packet is over
    else if (signalID == IRadio::transmissionStateChangedSignal) {
        IRadio::TransmissionState newRadioTransmissionState = (IRadio::TransmissionState)value;
        if (transmissionState == IRadio::TRANSMISSION_STATE_TRANSMITTING && newRadioTransmissionState == IRadio::TRANSMISSION_STATE_IDLE) {
            if (macState == WAIT_TX_DATA_OVER)
                scheduleAt(simTime(), data_tx_over);
            else if (macState == WAIT_ACK_TX)
                scheduleAt(simTime(), ack_tx_over);
        }
        transmissionState = newRadioTransmissionState;
    }
}

void inet::BMacLayer::refreshDisplay ( ) const

overridevirtual

Change the color of the node for animation purposes.

{
    if (!animation)
        return;
    cDisplayString& dispStr = findContainingNode(this)->getDisplayString();

    switch (macState) {
        case INIT:
        case SLEEP:
            dispStr.setTagArg("b", 3, "black");
            break;

        case CCA:
            dispStr.setTagArg("b", 3, "green");
            break;

        case SEND_ACK:
        case SEND_PREAMBLE:
        case SEND_DATA:
            dispStr.setTagArg("b", 3, "blue");
            break;

        case WAIT_ACK:
        case WAIT_DATA:
        case WAIT_TX_DATA_OVER:
        case WAIT_ACK_TX:
            dispStr.setTagArg("b", 3, "yellow");
            break;

        default:
            dispStr.setTagArg("b", 3, "");
            break;
    }
}

void inet::BMacLayer::sendDataPacket ( )

protected

Internal function to send the first packet in the queue.

Referenced by handleSelfMessage().

{
    nbTxDataPackets++;
    BMacFrame *pkt = macQueue.front()->dup();
    attachSignal(pkt);
    lastDataPktDestAddr = pkt->getDestAddr();
    pkt->setKind(BMAC_DATA);
    sendDown(pkt);
}

void inet::BMacLayer::sendMacAck ( )

protected

Internal function to send an ACK.

Send one short preamble packet immediately.

Referenced by handleSelfMessage().

{
    BMacFrame *ack = new BMacFrame();
    ack->setSrcAddr(address);
    ack->setDestAddr(lastDataPktSrcAddr);
    ack->setKind(BMAC_ACK);
    ack->setBitLength(headerLength);

    //attach signal and send down
    attachSignal(ack);
    sendDown(ack);
    nbTxAcks++;
    //endSimulation();
}

void inet::BMacLayer::sendPreamble ( )

protected

Internal function to send one preamble.

Send one short preamble packet immediately.

Referenced by handleSelfMessage().

{
    BMacFrame *preamble = new BMacFrame();
    preamble->setSrcAddr(address);
    preamble->setDestAddr(MACAddress::BROADCAST_ADDRESS);
    preamble->setKind(BMAC_PREAMBLE);
    preamble->setBitLength(headerLength);

    //attach signal and send down
    attachSignal(preamble);
    sendDown(preamble);
    nbTxPreambles++;
}

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

protected

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

Referenced by decapsMsg().

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

Member Data Documentation

cMessage* inet::BMacLayer::ack_timeout = nullptr

protected

Referenced by handleSelfMessage(), initialize(), and ~BMacLayer().

cMessage* inet::BMacLayer::ack_tx_over = nullptr

protected

Referenced by initialize(), receiveSignal(), and ~BMacLayer().

MACAddress inet::BMacLayer::address

protected

The MAC address of the interface.

Referenced by createInterfaceEntry(), encapsMsg(), handleSelfMessage(), initializeMACAddress(), sendMacAck(), and sendPreamble().

bool inet::BMacLayer::animation = false

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

Referenced by initialize(), and refreshDisplay().

double inet::BMacLayer::bitrate = 0

protected

The bitrate of transmission.

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

cMessage* inet::BMacLayer::cca_timeout = nullptr

protected

Referenced by handleSelfMessage(), initialize(), and ~BMacLayer().

double inet::BMacLayer::checkInterval = 0

protected

The duration of CCA.

Referenced by handleSelfMessage(), and initialize().

cMessage* inet::BMacLayer::data_timeout = nullptr

protected

Referenced by handleSelfMessage(), initialize(), and ~BMacLayer().

cMessage* inet::BMacLayer::data_tx_over = nullptr

protected

Referenced by initialize(), receiveSignal(), and ~BMacLayer().

int inet::BMacLayer::headerLength = 0

protected

Length of the header.

Referenced by encapsMsg(), initialize(), sendMacAck(), and sendPreamble().

MACAddress inet::BMacLayer::lastDataPktDestAddr

protected

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

MACAddress inet::BMacLayer::lastDataPktSrcAddr

protected

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

MacQueue inet::BMacLayer::macQueue

protected

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

Referenced by addToQueue(), clearQueue(), flushQueue(), handleSelfMessage(), sendDataPacket(), and ~BMacLayer().

States inet::BMacLayer::macState = (States)-1

protected

The current state of the protocol.

Referenced by addToQueue(), handleSelfMessage(), handleUpperPacket(), initialize(), receiveSignal(), and refreshDisplay().

int inet::BMacLayer::maxTxAttempts = 0

protected

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

Referenced by handleSelfMessage(), and initialize().

long inet::BMacLayer::nbDroppedDataPackets = 0

protected

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

long inet::BMacLayer::nbMissedAcks = 0

protected

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

long inet::BMacLayer::nbRecvdAcks = 0

protected

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

long inet::BMacLayer::nbRxDataPackets = 0

protected

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

long inet::BMacLayer::nbRxPreambles = 0

protected

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

long inet::BMacLayer::nbTxAcks = 0

protected

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

long inet::BMacLayer::nbTxDataPackets = 0

protected

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

long inet::BMacLayer::nbTxPreambles = 0

protected

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

unsigned int inet::BMacLayer::queueLength = 0

protected

The maximum length of the queue.

Referenced by addToQueue(), and initialize().

IRadio* inet::BMacLayer::radio = nullptr

protected

The radio.

Referenced by handleSelfMessage(), and initialize().

cMessage* inet::BMacLayer::resend_data = nullptr

protected

Referenced by initialize(), receiveSignal(), and ~BMacLayer().

cMessage* inet::BMacLayer::send_ack = nullptr

protected

Referenced by initialize(), receiveSignal(), and ~BMacLayer().

cMessage* inet::BMacLayer::send_preamble = nullptr

protected

Referenced by handleSelfMessage(), initialize(), receiveSignal(), and ~BMacLayer().

double inet::BMacLayer::slotDuration = 0

protected

The duration of the slot in secs.

Referenced by handleSelfMessage(), and initialize().

cMessage* inet::BMacLayer::start_bmac = nullptr

protected

Referenced by initialize(), and ~BMacLayer().

bool inet::BMacLayer::stats = false

protected

Gather stats at the end of the simulation.

cMessage* inet::BMacLayer::stop_preambles = nullptr

protected

Referenced by handleSelfMessage(), initialize(), and ~BMacLayer().

IRadio::TransmissionState inet::BMacLayer::transmissionState = IRadio::TRANSMISSION_STATE_UNDEFINED

protected

Referenced by receiveSignal().

int inet::BMacLayer::txAttempts = 0

protected

Referenced by handleSelfMessage(), and initialize().

bool inet::BMacLayer::useMacAcks = false

protected

Use MAC level acks or not.

Referenced by handleSelfMessage(), and initialize().

cMessage* inet::BMacLayer::wakeup = nullptr

protected

Referenced by handleSelfMessage(), handleUpperPacket(), initialize(), and ~BMacLayer().

---

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

• BMacLayer.h
• BMacLayer.cc