inet::BMac Class Reference

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

#include <BMac.h>

Inheritance diagram for inet::BMac:

Public Member Functions
	BMac ()
virtual	~BMac ()
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 (Packet *packet) override
	Handle messages from lower layer. More...
virtual void	handleUpperPacket (Packet *packet) 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, intval_t value, cObject *details) override
	Handle control messages from lower layer. 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
void	scheduleWakeUp ()
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 ()

Protected Attributes
ModuleRefByPar< physicallayer::IRadio >	radio
	The radio. More...
physicallayer::IRadio::TransmissionState	transmissionState = physicallayer::IRadio::TRANSMISSION_STATE_UNDEFINED
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

Private Member Functions
	BMac (const BMac &)
	Copy constructor is not allowed. More...
BMac &	operator= (const BMac &)
	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 = 0
long	nbTxPreambles = 0
long	nbRxDataPackets = 0
long	nbRxPreambles = 0
long	nbMissedAcks = 0
long	nbRecvdAcks = 0
long	nbDroppedDataPackets = 0
long	nbTxAcks = 0
States	macState = static_cast<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

Help variables for the acknowledgment process.
MacAddress	lastDataPktSrcAddr
MacAddress	lastDataPktDestAddr
int	txAttempts = 0
bool	animation = false
	Animate (colorize) the nodes. More...
double	slotDuration = 0
	The duration of the slot in secs. More...
b	headerLength = b(0)
	Length of the header. More...
b	ctrlFrameLength = b(0)
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...
virtual void	configureNetworkInterface () override
	Generate new interface address. More...
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 (Packet *macPkt)
	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

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 Enumeration Documentation

States

enum inet::BMac::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
    };

Constructor & Destructor Documentation

BMac() [1/2]

inet::BMac::BMac ( const BMac &  )

private

Copy constructor is not allowed.

BMac() [2/2]

inet::BMac::BMac ( )

inline

{}

~BMac()

inet::BMac::~BMac ( )

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);
}

Member Function Documentation

attachSignal()

void inet::BMac::attachSignal ( Packet *  macPkt )

protected

Internal function to attach a signal to the packet.

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

configureNetworkInterface()

void inet::BMac::configureNetworkInterface ( )

overrideprotectedvirtual

Generate new interface address.

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::BMac::decapsulate ( Packet *  packet )

protected

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

encapsulate()

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

protected

{
    auto pkt = makeShared<BMacDataFrameHeader>();
    pkt->setChunkLength(headerLength);
 
    pkt->setType(BMAC_DATA);
    // 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());
 
    // encapsulate the network packet
    packet->insertAtFront(pkt);
    EV_DETAIL << "pkt encapsulated\n";
    packet->addTagIfAbsent<PacketProtocolTag>()->setProtocol(&Protocol::bmac);
}

finish()

void inet::BMac::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);
}

getProvider()

queueing::IPassivePacketSource * inet::BMac::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::BMac::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.1f, wakeup);
    }
}

handleCommand()

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

inlineprotectedvirtual

{}

handleLowerPacket()

void inet::BMac::handleLowerPacket ( Packet *  packet )

overridevirtual

Handle messages from lower layer.

Handle BMAC preambles and received data packets.

Reimplemented from inet::LayeredProtocolBase.

{
    if (packet->hasBitError()) {
        EV << "Received " << packet << " contains bit errors or collision, dropping it\n";
        PacketDropDetails details;
        details.setReason(INCORRECTLY_RECEIVED);
        emit(packetDroppedSignal, packet, &details);
        delete packet;
        return;
    }
    else {
        const auto& hdr = packet->peekAtFront<BMacHeaderBase>();
        packet->setKind(hdr->getType());
        // simply pass the message as self message, to be processed by the FSM.
        handleSelfMessage(packet);
    }
}

handlePullPacketProcessed()

void inet::BMac::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::BMac::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.

{
    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;
                scheduleAfter(dblrand() * slotDuration, wakeup);
                return;
            }
            break;
 
        case SLEEP:
            if (msg->getKind() == BMAC_WAKE_UP) {
                EV_DETAIL << "State SLEEP, message BMAC_WAKEUP, new state CCA" << endl;
                scheduleAfter(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 (!txQueue->isEmpty()) {
                    EV_DETAIL << "State CCA, message CCA_TIMEOUT, new state"
                                 " SEND_PREAMBLE" << endl;
                    macState = SEND_PREAMBLE;
                    radio->setRadioMode(IRadio::RADIO_MODE_TRANSMITTER);
                    scheduleAfter(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;
                    scheduleAfter(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);
                scheduleAfter(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);
                scheduleAfter(slotDuration + checkInterval, data_timeout);
                scheduleAfter(SIMTIME_ZERO, 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();
                scheduleAfter(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
                if (msg->getKind() == BMAC_SEND_PREAMBLE) {
                    if (currentTxFrame != nullptr)
                        throw cRuntimeError("Model error: incomplete transmission exists");
                    currentTxFrame = dequeuePacket();
                    encapsulate(currentTxFrame);
                }
                ASSERT(currentTxFrame != nullptr);
                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);
                    scheduleAfter(checkInterval, ack_timeout);
                }
                else {
                    EV_DETAIL << "State WAIT_TX_DATA_OVER, message BMAC_DATA_TX_OVER,"
                                 " new state  SLEEP" << endl;
                    deleteCurrentTxFrame();
                    scheduleWakeUp();
                    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;
                    scheduleAfter(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
                    emit(linkBrokenSignal, currentTxFrame);
                    PacketDropDetails details;
                    details.setReason(OTHER_PACKET_DROP);
                    dropCurrentTxFrame(details);
                    scheduleWakeUp();
                    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;
                auto packet = check_and_cast<Packet *>(msg);
                const MacAddress src = packet->peekAtFront<BMacControlFrame>()->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);
                    deleteCurrentTxFrame();
                    scheduleWakeUp();
                    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) {
                MacAddress address = networkInterface->getMacAddress();
                nbRxDataPackets++;
                auto packet = check_and_cast<Packet *>(msg);
                const auto bmacHeader = packet->peekAtFront<BMacDataFrameHeader>();
                const MacAddress& dest = bmacHeader->getDestAddr();
                const MacAddress& src = bmacHeader->getSrcAddr();
                if ((dest == address) || dest.isBroadcast()) {
                    EV_DETAIL << "Local delivery " << packet << endl;
                    decapsulate(packet);
                    sendUp(packet);
                }
                else {
                    EV_DETAIL << "Received " << packet << " is not for us, dropping frame." << endl;
                    PacketDropDetails details;
                    details.setReason(NOT_ADDRESSED_TO_US);
                    emit(packetDroppedSignal, msg, &details);
                    delete msg;
                    msg = nullptr;
                    packet = 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;
                    scheduleWakeUp();
                    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;
                scheduleWakeUp();
                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.
                scheduleWakeUp();
                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());
}

handleUpperPacket()

void inet::BMac::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::BMac::initialize ( int  stage )

overridevirtual

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");
        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;
        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);
 
        // init the dropped packet info
        WATCH(macState);
 
        wakeup = new cMessage("wakeup", BMAC_WAKE_UP);
 
        data_timeout = new cMessage("data_timeout", BMAC_DATA_TIMEOUT);
        data_timeout->setSchedulingPriority(100);
 
        data_tx_over = new cMessage("data_tx_over", BMAC_DATA_TX_OVER);
 
        stop_preambles = new cMessage("stop_preambles", BMAC_STOP_PREAMBLES);
 
        send_preamble = new cMessage("send_preamble", BMAC_SEND_PREAMBLE);
 
        ack_tx_over = new cMessage("ack_tx_over", BMAC_ACK_TX_OVER);
 
        cca_timeout = new cMessage("cca_timeout", BMAC_CCA_TIMEOUT);
        cca_timeout->setSchedulingPriority(100);
 
        send_ack = new cMessage("send_ack", BMAC_SEND_ACK);
 
        start_bmac = new cMessage("start_bmac", BMAC_START_BMAC);
 
        ack_timeout = new cMessage("ack_timeout", BMAC_ACK_TIMEOUT);
 
        resend_data = new cMessage("resend_data", BMAC_RESEND_DATA);
        resend_data->setSchedulingPriority(100);
 
        scheduleAfter(SIMTIME_ZERO, start_bmac);
    }
}

numInitStages()

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

inlineoverridevirtual

Initialization of the module and some variables.

{ return NUM_INIT_STAGES; }

operator=()

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

private

Assignment operator is not allowed.

receiveSignal()

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

overridevirtual

Handle control messages from lower layer.

{
    Enter_Method("%s", cComponent::getSignalName(signalID));
 
    if (signalID == IRadio::radioModeChangedSignal) {
        IRadio::RadioMode radioMode = static_cast<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)
                scheduleAfter(SIMTIME_ZERO, send_preamble);
            else if (macState == SEND_ACK)
                scheduleAfter(SIMTIME_ZERO, 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)
                scheduleAfter(SIMTIME_ZERO, resend_data);
        }
    }
    // Transmission of one packet is over
    else if (signalID == IRadio::transmissionStateChangedSignal) {
        IRadio::TransmissionState newRadioTransmissionState = static_cast<IRadio::TransmissionState>(value);
        if (transmissionState == IRadio::TRANSMISSION_STATE_TRANSMITTING && newRadioTransmissionState == IRadio::TRANSMISSION_STATE_IDLE) {
            if (macState == WAIT_TX_DATA_OVER)
                scheduleAfter(SIMTIME_ZERO, data_tx_over);
            else if (macState == WAIT_ACK_TX)
                scheduleAfter(SIMTIME_ZERO, ack_tx_over);
        }
        transmissionState = newRadioTransmissionState;
    }
}

refreshDisplay()

void inet::BMac::refreshDisplay ( ) const

overridevirtual

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;
    }
}

scheduleWakeUp()

void inet::BMac::scheduleWakeUp ( )

protected

{
    // if something in the queue, wakeup soon.
    if (!txQueue->isEmpty())
        scheduleAfter(dblrand() * checkInterval, wakeup);
    else
        scheduleAfter(slotDuration, wakeup);
}

sendDataPacket()

void inet::BMac::sendDataPacket ( )

protected

Internal function to send the first packet in the queue.

{
    nbTxDataPackets++;
 
    Packet *pkt = currentTxFrame->dup();
    attachSignal(pkt);
    const auto& hdr = pkt->peekAtFront<BMacDataFrameHeader>();
    lastDataPktDestAddr = hdr->getDestAddr();
    ASSERT(hdr->getType() == BMAC_DATA);
    sendDown(pkt);
}

sendMacAck()

void inet::BMac::sendMacAck ( )

protected

Internal function to send an ACK.

Send one short preamble packet immediately.

{
    auto ack = makeShared<BMacControlFrame>();
    ack->setSrcAddr(networkInterface->getMacAddress());
    ack->setDestAddr(lastDataPktSrcAddr);
    ack->setChunkLength(ctrlFrameLength);
 
    // attach signal and send down
    auto packet = new Packet("BMacAck");
    ack->setType(BMAC_ACK);
    packet->insertAtFront(ack);
    packet->addTag<PacketProtocolTag>()->setProtocol(&Protocol::bmac);
    attachSignal(packet);
    sendDown(packet);
    nbTxAcks++;
//    endSimulation();
}

sendPreamble()

void inet::BMac::sendPreamble ( )

protected

Internal function to send one preamble.

Send one short preamble packet immediately.

{
    auto preamble = makeShared<BMacControlFrame>();
    preamble->setSrcAddr(networkInterface->getMacAddress());
    preamble->setDestAddr(MacAddress::BROADCAST_ADDRESS);
    preamble->setChunkLength(ctrlFrameLength);
 
    // attach signal and send down
    auto packet = new Packet("Preamble");
    preamble->setType(BMAC_PREAMBLE);
    packet->insertAtFront(preamble);
    packet->addTag<PacketProtocolTag>()->setProtocol(&Protocol::bmac);
    attachSignal(packet);
    sendDown(packet);
    nbTxPreambles++;
}

Member Data Documentation

ack_timeout

cMessage* inet::BMac::ack_timeout = nullptr

protected

ack_tx_over

cMessage* inet::BMac::ack_tx_over = nullptr

protected

animation

bool inet::BMac::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

bitrate

double inet::BMac::bitrate = 0

protected

The bitrate of transmission.

cca_timeout

cMessage* inet::BMac::cca_timeout = nullptr

protected

checkInterval

double inet::BMac::checkInterval = 0

protected

The duration of CCA.

ctrlFrameLength

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

protected

data_timeout

cMessage* inet::BMac::data_timeout = nullptr

protected

data_tx_over

cMessage* inet::BMac::data_tx_over = nullptr

protected

headerLength

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

protected

Length of the header.

lastDataPktDestAddr

MacAddress inet::BMac::lastDataPktDestAddr

protected

lastDataPktSrcAddr

MacAddress inet::BMac::lastDataPktSrcAddr

protected

macState

States inet::BMac::macState = static_cast<States>(-1)

protected

The current state of the protocol.

maxTxAttempts

int inet::BMac::maxTxAttempts = 0

protected

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

nbDroppedDataPackets

long inet::BMac::nbDroppedDataPackets = 0

protected

nbMissedAcks

long inet::BMac::nbMissedAcks = 0

protected

nbRecvdAcks

long inet::BMac::nbRecvdAcks = 0

protected

nbRxDataPackets

long inet::BMac::nbRxDataPackets = 0

protected

nbRxPreambles

long inet::BMac::nbRxPreambles = 0

protected

nbTxAcks

long inet::BMac::nbTxAcks = 0

protected

nbTxDataPackets

long inet::BMac::nbTxDataPackets = 0

protected

nbTxPreambles

long inet::BMac::nbTxPreambles = 0

protected

radio

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

protected

The radio.

resend_data

cMessage* inet::BMac::resend_data = nullptr

protected

send_ack

cMessage* inet::BMac::send_ack = nullptr

protected

send_preamble

cMessage* inet::BMac::send_preamble = nullptr

protected

slotDuration

double inet::BMac::slotDuration = 0

protected

The duration of the slot in secs.

start_bmac

cMessage* inet::BMac::start_bmac = nullptr

protected

stats

bool inet::BMac::stats = false

protected

Gather stats at the end of the simulation.

stop_preambles

cMessage* inet::BMac::stop_preambles = nullptr

protected

transmissionState

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

protected

txAttempts

int inet::BMac::txAttempts = 0

protected

useMacAcks

bool inet::BMac::useMacAcks = false

protected

Use MAC level acks or not.

wakeup

cMessage* inet::BMac::wakeup = nullptr

protected

---

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

• BMac.h
• BMac.cc