inet::LMac Class Reference

Implementation of L-MAC (Lightweight Medium Access Protocol for Wireless Sensor Networks [van Hoesel 04] ). More...

#include <LMac.h>

Inheritance diagram for inet::LMac:

Public Member Functions
	LMac ()
virtual	~LMac ()
	Clean up messges. More...
virtual void	initialize (int) override
	Initialization of the module and some variables. 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 void	encapsulate (Packet *)
	Encapsulate the NetwPkt into an MacPkt. More...
virtual void	decapsulate (Packet *)
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 Types
enum	States {   INIT, SLEEP, CCA, WAIT_CONTROL,   WAIT_DATA, SEND_CONTROL, SEND_DATA }
	MAC states. More...
Protected Types inherited from inet::OperationalMixin< cSimpleModule >
enum	State

Protected Member Functions
virtual void	configureNetworkInterface () override
	Generate new interface address. More...
virtual void	handleCommand (cMessage *msg)
void	findNewSlot ()
	find a new slot More...
void	attachSignal (Packet *macPkt)
	Internal function to attach a signal to the packet. 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 ()

Protected Attributes
bool	SETUP_PHASE
	the setup phase is the beginning of the simulation, where only control packets at very small slot durations are exchanged. More...
cOutVector *	slotChange
	indicate how often the node needs to change its slot because of collisions More...
States	macState
	keep track of MAC state More...
double	slotDuration
	Duration of a slot. More...
b	headerLength
	Length of the header. More...
b	ctrlFrameLength
	Length of the control frames. More...
double	controlDuration
	Duration of teh control time in each slot. More...
int	myId
	my ID More...
int	mySlot
	my slot ID More...
int	numSlots
	how many slots are there More...
int	currSlot
	The current slot of the simulation. More...
MacAddress	occSlotsDirect [64]
	Occupied slots from nodes, from which I hear directly. More...
MacAddress	occSlotsAway [64]
	Occupied slots of two-hop neighbors. More...
int	reservedMobileSlots
	The first couple of slots are reserved for nodes with special needs to avoid changing slots for them (mobile nodes) More...
ModuleRefByPar< physicallayer::IRadio >	radio
	The radio. More...
physicallayer::IRadio::TransmissionState	transmissionState
cMessage *	wakeup
cMessage *	timeout
cMessage *	sendData
cMessage *	initChecker
cMessage *	checkChannel
cMessage *	start_lmac
cMessage *	send_control
double	bitrate
	the bit rate at which we transmit More...
Protected Attributes inherited from inet::MacProtocolBase
int	upperLayerInGateId = -1
	Gate ids. More...
int	upperLayerOutGateId = -1
int	lowerLayerInGateId = -1
int	lowerLayerOutGateId = -1
opp_component_ptr< NetworkInterface >	networkInterface
opp_component_ptr< cModule >	hostModule
Packet *	currentTxFrame = nullptr
	Currently transmitted frame if any. More...
opp_component_ptr< queueing::IPacketQueue >	txQueue
	Messages received from upper layer and to be transmitted later. More...
Protected Attributes inherited from inet::OperationalMixin< cSimpleModule >
State	operationalState
simtime_t	lastChange
Operation	activeOperation
cMessage *	activeOperationTimeout
cMessage *	activeOperationExtraTimer

Static Protected Attributes
static const MacAddress	LMAC_NO_RECEIVER
	dummy receiver address to indicate no pending packets in the control packet More...
static const MacAddress	LMAC_FREE_SLOT

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

Detailed Description

Implementation of L-MAC (Lightweight Medium Access Protocol for Wireless Sensor Networks [van Hoesel 04] ).

Each node has its own unique timeslot. Nodes can use their timeslots to transfer data without having to contend for the medium or having to deal with energy wasting collisions or retransmissions.

During the first 5 full frames nodes will be waking up every controlDuration to setup the network first by assigning a different timeslot to each node. Normal packets will be queued, but will be send only after the setup phase.

During its timeslot a node wakes up, checks the channel for a short random period (CCA) to check for possible collision in the slot and, if the channel is free, sends a control packet. If there is a collision it tries to change its timeslot to an empty one. After the transmission of the control packet it checks its packet queue and if its non-empty it sends a data packet.

During a foreign timeslot a node wakes up, checks the channel for 2*controlDuration period for an incoming control packet and if there in nothing it goes back to sleep and conserves energy for the rest of the timeslot. If it receives a control packet addressed for itself it stays awake for the rest of the timeslot to receive the incoming data packet.

The finite state machine of the protocol is given in the below figure:

State chart for LMAC layer

A paper describing the protocol is:

L. van Hoesel and P. Havinga. A lightweight medium access protocol (LMAC) for wireless sensor networks. In Proceedings of the 3rd International Symposium on Information Processing in Sensor Networks (IPSN), pages 55-60, Berkeley, CA, February 2004. April.

Member Enumeration Documentation

States

enum inet::LMac::States

protected

MAC states.

The MAC states help to keep track what the MAC is actually trying to do – this is esp. useful when radio switching takes some time. SLEEP – the node sleeps but accepts packets from the network layer RX – MAC accepts packets from PHY layer TX – MAC transmits a packet CCA – Clear Channel Assessment - MAC checks whether medium is busy

Enumerator
INIT
SLEEP
CCA
WAIT_CONTROL
WAIT_DATA
SEND_CONTROL
SEND_DATA

                {
        INIT, SLEEP, CCA, WAIT_CONTROL, WAIT_DATA, SEND_CONTROL, SEND_DATA
    };

Constructor & Destructor Documentation

LMac() [1/2]

inet::LMac::LMac ( const LMac &  )

private

Copy constructor is not allowed.

LMac() [2/2]

inet::LMac::LMac ( )

inline

        : MacProtocolBase()
        , SETUP_PHASE(true)
        , slotChange()
        , macState()
        , slotDuration(0)
        , headerLength(b(0))
        , ctrlFrameLength(b(0))
        , controlDuration(0)
        , myId(0)
        , mySlot(0)
        , numSlots(0)
        , currSlot()
        , reservedMobileSlots(0)
        , transmissionState(physicallayer::IRadio::TRANSMISSION_STATE_UNDEFINED)
        , wakeup(nullptr)
        , timeout(nullptr)
        , sendData(nullptr)
        , initChecker(nullptr)
        , checkChannel(nullptr)
        , start_lmac(nullptr)
        , send_control(nullptr)
        , bitrate(0)
    {}

~LMac()

inet::LMac::~LMac ( )

virtual

Clean up messges.

{
    delete slotChange;
    cancelAndDelete(timeout);
    cancelAndDelete(wakeup);
    cancelAndDelete(checkChannel);
    cancelAndDelete(sendData);
    cancelAndDelete(initChecker);
    cancelAndDelete(start_lmac);
    cancelAndDelete(send_control);
}

Member Function Documentation

attachSignal()

void inet::LMac::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::LMac::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::LMac::decapsulate ( Packet *  packet )

virtual

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

encapsulate()

void inet::LMac::encapsulate ( Packet *  netwPkt )

virtual

Encapsulate the NetwPkt into an MacPkt.

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

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

findNewSlot()

void inet::LMac::findNewSlot ( )

protected

find a new slot

Try to find a new slot after collision.

If not possible, set own slot to -1 (not able to send anything)

{
    // pick a random slot at the beginning and schedule the next wakeup
    // free the old one first
    int counter = 0;
 
    mySlot = intrand((numSlots - reservedMobileSlots));
    while ((occSlotsAway[mySlot] != LMAC_FREE_SLOT) && (counter < (numSlots - reservedMobileSlots))) {
        counter++;
        mySlot--;
        if (mySlot < 0)
            mySlot = (numSlots - reservedMobileSlots) - 1;
    }
    if (occSlotsAway[mySlot] != LMAC_FREE_SLOT) {
        EV << "ERROR: I cannot find a free slot. Cannot send data.\n";
        mySlot = -1;
    }
    else {
        EV << "ERROR: My new slot is : " << mySlot << endl;
    }
    EV << "ERROR: I needed to find new slot\n";
    slotChange->recordWithTimestamp(simTime(), FindModule<>::findHost(this)->getId() - 4);
}

getProvider()

queueing::IPassivePacketSource * inet::LMac::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::LMac::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");
    // packed arrived from upper layer
}

handleCommand()

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

inlineprotectedvirtual

{}

handleLowerPacket()

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

overridevirtual

Handle messages from lower layer.

Handle LMAC control packets and data packets.

Recognize collisions, change own slot if necessary and remember who is using which slot.

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;
    }
    // simply pass the massage as self message, to be processed by the FSM.
    const auto& hdr = packet->peekAtFront<LMacHeaderBase>();
    packet->setKind(hdr->getType());
    handleSelfMessage(packet);
}

handlePullPacketProcessed()

void inet::LMac::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::LMac::handleSelfMessage ( cMessage *  msg )

overridevirtual

Handle self messages such as timers.

Handle self messages: LMAC_SETUP_PHASE_END: end of setup phase.

Change slot duration to normal and start sending data packets. The slots of the nodes should be stable now. LMAC_SEND_DATA: send the data packet. LMAC_CHECK_CHANNEL: check the channel in own slot. If busy, change the slot. If not, send a control packet. LMAC_WAKEUP: wake up the node and either check the channel before sending a control packet or wait for control packets. LMAC_TIMEOUT: go back to sleep after nothing happened.

Reimplemented from inet::LayeredProtocolBase.

{
    MacAddress address = networkInterface->getMacAddress();
 
    switch (macState) {
        case INIT:
            if (msg->getKind() == LMAC_START_LMAC) {
                // the first 5 full slots we will be waking up every controlDuration to setup the network first
                // normal packets will be queued, but will be send only after the setup phase
                scheduleAfter(slotDuration * 5 * numSlots, initChecker);
                EV << "Startup time =" << slotDuration * 5 * numSlots << endl;
 
                EV_DETAIL << "Scheduling the first wakeup at : " << slotDuration << endl;
 
                scheduleAfter(slotDuration, wakeup);
 
                for (int i = 0; i < numSlots; i++) {
                    occSlotsDirect[i] = LMAC_FREE_SLOT;
                    occSlotsAway[i] = LMAC_FREE_SLOT;
                }
 
                if (myId >= reservedMobileSlots)
                    mySlot = ((int)FindModule<>::findHost(this)->getId()) % (numSlots - reservedMobileSlots);
                else
                    mySlot = myId;
//                occSlotsDirect[mySlot] = address;
//                occSlotsAway[mySlot] = address;
                currSlot = 0;
 
                EV_DETAIL << "ID: " << FindModule<>::findHost(this)->getId() << ". Picked random slot: " << mySlot << endl;
 
                macState = SLEEP;
                EV_DETAIL << "Old state: INIT, New state: SLEEP" << endl;
                SETUP_PHASE = true;
            }
            else {
                EV << "Unknown packet" << msg->getKind() << "in state" << macState << endl;
            }
            break;
 
        case SLEEP:
            if (msg->getKind() == LMAC_WAKEUP) {
                currSlot++;
                currSlot %= numSlots;
                EV_DETAIL << "New slot starting - No. " << currSlot << ", my slot is " << mySlot << endl;
 
                if (mySlot == currSlot) {
                    EV_DETAIL << "Waking up in my slot. Switch to RECV first to check the channel.\n";
                    macState = CCA;
                    radio->setRadioMode(IRadio::RADIO_MODE_RECEIVER);
                    EV_DETAIL << "Old state: SLEEP, New state: CCA" << endl;
 
                    double small_delay = controlDuration * dblrand();
                    scheduleAfter(small_delay, checkChannel);
                    EV_DETAIL << "Checking for channel for " << small_delay << " time.\n";
                }
                else {
                    EV_DETAIL << "Waking up in a foreign slot. Ready to receive control packet.\n";
                    macState = WAIT_CONTROL;
                    radio->setRadioMode(IRadio::RADIO_MODE_RECEIVER);
                    EV_DETAIL << "Old state: SLEEP, New state: WAIT_CONTROL" << endl;
                    if (!SETUP_PHASE) // in setup phase do not sleep
                        scheduleAfter(2.f * controlDuration, timeout);
                }
                if (SETUP_PHASE) {
                    scheduleAfter(2.f * controlDuration, wakeup);
                    EV_DETAIL << "setup phase slot duration:" << 2.f * controlDuration << "while controlduration is" << controlDuration << endl;
                }
                else
                    scheduleAfter(slotDuration, wakeup);
            }
            else if (msg->getKind() == LMAC_SETUP_PHASE_END) {
                EV_DETAIL << "Setup phase end. Start normal work at the next slot.\n";
                rescheduleAfter(slotDuration, wakeup);
                SETUP_PHASE = false;
            }
            else {
                EV << "Unknown packet" << msg->getKind() << "in state" << macState << endl;
            }
            break;
 
        case CCA:
            if (msg->getKind() == LMAC_CHECK_CHANNEL) {
                // if the channel is clear, get ready for sending the control packet
                EV << "Channel is free, so let's prepare for sending.\n";
 
                macState = SEND_CONTROL;
                radio->setRadioMode(IRadio::RADIO_MODE_TRANSMITTER);
                EV_DETAIL << "Old state: CCA, New state: SEND_CONTROL" << endl;
            }
            else if (msg->getKind() == LMAC_CONTROL) {
                auto packet = check_and_cast<Packet *>(msg);
                const auto& lmacHeader = packet->peekAtFront<LMacControlFrame>();
                const MacAddress& dest = lmacHeader->getDestAddr();
                EV_DETAIL << " I have received a control packet from src " << lmacHeader->getSrcAddr() << " and dest " << dest << ".\n";
                bool collision = false;
                // if we are listening to the channel and receive anything, there is a collision in the slot.
                if (checkChannel->isScheduled()) {
                    cancelEvent(checkChannel);
                    collision = true;
                }
 
                for (int s = 0; s < numSlots; s++) {
                    occSlotsAway[s] = lmacHeader->getOccupiedSlots(s);
                    EV_DETAIL << "Occupied slot " << s << ": " << occSlotsAway[s] << endl;
                    EV_DETAIL << "Occupied direct slot " << s << ": " << occSlotsDirect[s] << endl;
                }
 
                if (lmacHeader->getMySlot() > -1) {
                    // check first whether this address didn't have another occupied slot and free it again
                    for (int i = 0; i < numSlots; i++) {
                        if (occSlotsDirect[i] == lmacHeader->getSrcAddr())
                            occSlotsDirect[i] = LMAC_FREE_SLOT;
                        if (occSlotsAway[i] == lmacHeader->getSrcAddr())
                            occSlotsAway[i] = LMAC_FREE_SLOT;
                    }
                    occSlotsAway[lmacHeader->getMySlot()] = lmacHeader->getSrcAddr();
                    occSlotsDirect[lmacHeader->getMySlot()] = lmacHeader->getSrcAddr();
                }
                collision = collision || (lmacHeader->getMySlot() == mySlot);
                if (((mySlot > -1) && (lmacHeader->getOccupiedSlots(mySlot) > LMAC_FREE_SLOT) && (lmacHeader->getOccupiedSlots(mySlot) != address)) || collision) {
                    EV_DETAIL << "My slot is taken by " << lmacHeader->getOccupiedSlots(mySlot) << ". I need to change it.\n";
                    findNewSlot();
                    EV_DETAIL << "My new slot is " << mySlot << endl;
                }
                if (mySlot < 0) {
                    EV_DETAIL << "I don;t have a slot - try to find one.\n";
                    findNewSlot();
                }
 
                if (dest == address || dest.isBroadcast()) {
                    EV_DETAIL << "I need to stay awake.\n";
                    if (timeout->isScheduled())
                        cancelEvent(timeout);
                    macState = WAIT_DATA;
                    EV_DETAIL << "Old state: CCA, New state: WAIT_DATA" << endl;
                }
                else {
                    EV_DETAIL << "Incoming data packet not for me. Going back to sleep.\n";
                    macState = SLEEP;
                    EV_DETAIL << "Old state: CCA, New state: SLEEP" << endl;
                    radio->setRadioMode(IRadio::RADIO_MODE_SLEEP);
                    if (timeout->isScheduled())
                        cancelEvent(timeout);
                }
                delete packet;
            }
            // probably it never happens
            else if (msg->getKind() == LMAC_DATA) {
                auto packet = check_and_cast<Packet *>(msg);
                const MacAddress& dest = packet->peekAtFront<LMacDataFrameHeader>()->getDestAddr();
//                bool collision = false;
                // if we are listening to the channel and receive anything, there is a collision in the slot.
                if (checkChannel->isScheduled()) {
                    cancelEvent(checkChannel);
//                    collision = true;
                }
                EV_DETAIL << " I have received a data packet.\n";
                if (dest == address || dest.isBroadcast()) {
                    EV_DETAIL << "sending pkt to upper...\n";
                    decapsulate(packet);
                    sendUp(packet);
                }
                else {
                    EV_DETAIL << "packet not for me, deleting...\n";
                    PacketDropDetails details;
                    details.setReason(NOT_ADDRESSED_TO_US);
                    emit(packetDroppedSignal, packet, &details);
                    delete packet;
                }
                // in any case, go back to sleep
                macState = SLEEP;
                EV_DETAIL << "Old state: CCA, New state: SLEEP" << endl;
                radio->setRadioMode(IRadio::RADIO_MODE_SLEEP);
            }
            else if (msg->getKind() == LMAC_SETUP_PHASE_END) {
                EV_DETAIL << "Setup phase end. Start normal work at the next slot.\n";
                rescheduleAfter(slotDuration, wakeup);
                SETUP_PHASE = false;
            }
            else {
                EV << "Unknown packet" << msg->getKind() << "in state" << macState << endl;
            }
            break;
 
        case WAIT_CONTROL:
            if (msg->getKind() == LMAC_TIMEOUT) {
                EV_DETAIL << "Control timeout. Go back to sleep.\n";
                macState = SLEEP;
                EV_DETAIL << "Old state: WAIT_CONTROL, New state: SLEEP" << endl;
                radio->setRadioMode(IRadio::RADIO_MODE_SLEEP);
            }
            else if (msg->getKind() == LMAC_CONTROL) {
                auto packet = check_and_cast<Packet *>(msg);
                const auto& lmacHeader = packet->peekAtFront<LMacControlFrame>();
                const MacAddress& dest = lmacHeader->getDestAddr();
                EV_DETAIL << " I have received a control packet from src " << lmacHeader->getSrcAddr() << " and dest " << dest << ".\n";
 
                bool collision = false;
 
                // check first the slot assignment
                // copy the current slot assignment
 
                for (int s = 0; s < numSlots; s++) {
                    occSlotsAway[s] = lmacHeader->getOccupiedSlots(s);
                    EV_DETAIL << "Occupied slot " << s << ": " << occSlotsAway[s] << endl;
                    EV_DETAIL << "Occupied direct slot " << s << ": " << occSlotsDirect[s] << endl;
                }
 
                if (lmacHeader->getMySlot() > -1) {
                    // check first whether this address didn't have another occupied slot and free it again
                    for (int i = 0; i < numSlots; i++) {
                        if (occSlotsDirect[i] == lmacHeader->getSrcAddr())
                            occSlotsDirect[i] = LMAC_FREE_SLOT;
                        if (occSlotsAway[i] == lmacHeader->getSrcAddr())
                            occSlotsAway[i] = LMAC_FREE_SLOT;
                    }
                    occSlotsAway[lmacHeader->getMySlot()] = lmacHeader->getSrcAddr();
                    occSlotsDirect[lmacHeader->getMySlot()] = lmacHeader->getSrcAddr();
                }
 
                collision = collision || (lmacHeader->getMySlot() == mySlot);
                if (((mySlot > -1) && (lmacHeader->getOccupiedSlots(mySlot) > LMAC_FREE_SLOT) && (lmacHeader->getOccupiedSlots(mySlot) != address)) || collision) {
                    EV_DETAIL << "My slot is taken by " << lmacHeader->getOccupiedSlots(mySlot) << ". I need to change it.\n";
                    findNewSlot();
                    EV_DETAIL << "My new slot is " << mySlot << endl;
                }
                if (mySlot < 0) {
                    EV_DETAIL << "I don;t have a slot - try to find one.\n";
                    findNewSlot();
                }
 
                if (dest == address || dest.isBroadcast()) {
                    EV_DETAIL << "I need to stay awake.\n";
                    macState = WAIT_DATA;
                    EV_DETAIL << "Old state: WAIT_CONTROL, New state: WAIT_DATA" << endl;
                    if (timeout->isScheduled())
                        cancelEvent(timeout);
                }
                else {
                    EV_DETAIL << "Incoming data packet not for me. Going back to sleep.\n";
                    macState = SLEEP;
                    EV_DETAIL << "Old state: WAIT_CONTROL, New state: SLEEP" << endl;
                    radio->setRadioMode(IRadio::RADIO_MODE_SLEEP);
                    if (timeout->isScheduled())
                        cancelEvent(timeout);
                }
                delete packet;
            }
            else if ((msg->getKind() == LMAC_WAKEUP)) {
                if (SETUP_PHASE == true)
                    EV_DETAIL << "End of setup-phase slot" << endl;
                else
                    EV_DETAIL << "Very unlikely transition";
 
                macState = SLEEP;
                EV_DETAIL << "Old state: WAIT_DATA, New state: SLEEP" << endl;
                scheduleAfter(SIMTIME_ZERO, wakeup);
            }
            else if (msg->getKind() == LMAC_SETUP_PHASE_END) {
                EV_DETAIL << "Setup phase end. Start normal work at the next slot.\n";
                rescheduleAfter(slotDuration, wakeup);
 
                SETUP_PHASE = false;
            }
            else if (msg->getKind() == LMAC_DATA) {
                // TODO review this delete, it's added to avoid a memory leak detected by Valgrind
                delete msg;
            }
            else {
                EV << "Unknown packet" << msg->getKind() << "in state" << macState << endl;
            }
 
            break;
 
        case SEND_CONTROL:
            if (msg->getKind() == LMAC_SEND_CONTROL) {
                if (!SETUP_PHASE && currentTxFrame == nullptr && canDequeuePacket()) {
                    currentTxFrame = dequeuePacket();
                    encapsulate(currentTxFrame);
                }
                // send first a control message, so that non-receiving nodes can switch off.
                EV << "Sending a control packet.\n";
                auto control = makeShared<LMacControlFrame>();
                if (currentTxFrame != nullptr && !SETUP_PHASE)
                    control->setDestAddr(currentTxFrame->peekAtFront<LMacHeaderBase>()->getDestAddr());
                else
                    control->setDestAddr(LMAC_NO_RECEIVER);
 
                control->setSrcAddr(address);
                control->setMySlot(mySlot);
                control->setChunkLength(ctrlFrameLength + b(numSlots)); // FIXME check it: add only 1 bit / slot?
                control->setOccupiedSlotsArraySize(numSlots);
                for (int i = 0; i < numSlots; i++)
                    control->setOccupiedSlots(i, occSlotsDirect[i]);
 
                Packet *packet = new Packet("Control");
                control->setType(LMAC_CONTROL);
                packet->insertAtFront(control);
                packet->addTag<PacketProtocolTag>()->setProtocol(&Protocol::lmac);
                sendDown(packet);
                if ((currentTxFrame != nullptr) && (!SETUP_PHASE))
                    scheduleAfter(controlDuration, sendData);
            }
            else if (msg->getKind() == LMAC_SEND_DATA) {
                // we should be in our own slot and the control packet should be already sent. receiving neighbors should wait for the data now.
                if (currSlot != mySlot) {
                    EV_DETAIL << "ERROR: Send data message received, but we are not in our slot!!! Repair.\n";
                    radio->setRadioMode(IRadio::RADIO_MODE_SLEEP);
                    if (timeout->isScheduled())
                        cancelEvent(timeout);
                    return;
                }
                Packet *data = new Packet("Data");
                const auto& lmacHeader = currentTxFrame->removeAtFront<LMacDataFrameHeader>();
                data->insertAtBack(currentTxFrame->peekData());
                lmacHeader->setType(LMAC_DATA);
                lmacHeader->setMySlot(mySlot);
                lmacHeader->setOccupiedSlotsArraySize(numSlots);
                for (int i = 0; i < numSlots; i++)
                    lmacHeader->setOccupiedSlots(i, occSlotsDirect[i]);
 
                data->insertAtFront(lmacHeader);
                data->addTag<PacketProtocolTag>()->setProtocol(&Protocol::lmac);
                EV << "Sending down data packet\n";
                sendDown(data);
                deleteCurrentTxFrame();
                macState = SEND_DATA;
                EV_DETAIL << "Old state: SEND_CONTROL, New state: SEND_DATA" << endl;
            }
            else if (msg->getKind() == LMAC_SETUP_PHASE_END) {
                EV_DETAIL << "Setup phase end. Start normal work at the next slot.\n";
                rescheduleAfter(slotDuration, wakeup);
                SETUP_PHASE = false;
            }
            else {
                EV << "Unknown packet" << msg->getKind() << "in state" << macState << endl;
            }
            break;
 
        case SEND_DATA:
            if (msg->getKind() == LMAC_WAKEUP) {
                throw cRuntimeError("I am still sending a message, while a new slot is starting!\n");
            }
            else {
                EV << "Unknown packet" << msg->getKind() << "in state" << macState << endl;
            }
            break;
 
        case WAIT_DATA:
            if (msg->getKind() == LMAC_DATA) {
                auto packet = check_and_cast<Packet *>(msg);
                const MacAddress& dest = packet->peekAtFront<LMacDataFrameHeader>()->getDestAddr();
 
                EV_DETAIL << " I have received a data packet.\n";
                if (dest == address || dest.isBroadcast()) {
                    EV_DETAIL << "sending pkt to upper...\n";
                    decapsulate(packet);
                    sendUp(packet);
                }
                else {
                    EV_DETAIL << "packet not for me, deleting...\n";
                    PacketDropDetails details;
                    details.setReason(NOT_ADDRESSED_TO_US);
                    emit(packetDroppedSignal, packet, &details);
                    delete packet;
                }
                // in any case, go back to sleep
                macState = SLEEP;
                EV_DETAIL << "Old state: WAIT_DATA, New state: SLEEP" << endl;
                radio->setRadioMode(IRadio::RADIO_MODE_SLEEP);
                if (timeout->isScheduled())
                    cancelEvent(timeout);
            }
            else if (msg->getKind() == LMAC_WAKEUP) {
                macState = SLEEP;
                EV_DETAIL << "Unlikely transition. Old state: WAIT_DATA, New state: SLEEP" << endl;
                scheduleAfter(SIMTIME_ZERO, wakeup);
            }
            else {
                EV << "Unknown packet" << msg->getKind() << "in state" << macState << endl;
            }
            break;
 
        default:
            throw cRuntimeError("Unknown mac state: %d", macState);
            break;
    }
}

handleUpperPacket()

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

Sending of messages is automatic.

Reimplemented from inet::LayeredProtocolBase.

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

initialize()

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

overridevirtual

Initialization of the module and some variables.

Reimplemented from inet::MacProtocolBase.

{
    MacProtocolBase::initialize(stage);
    if (stage == INITSTAGE_LOCAL) {
        slotDuration = par("slotDuration");
        bitrate = par("bitrate");
        headerLength = b(par("headerLength"));
        EV << "headerLength is: " << headerLength << endl;
        ctrlFrameLength = b(par("ctrlFrameLength"));
        numSlots = par("numSlots");
        // the first N slots are reserved for mobile nodes to be able to function normally
        reservedMobileSlots = par("reservedMobileSlots");
 
        auto node = getContainingNode(this);
        myId = node->isVector() ? node->getIndex() : getId() % numSlots;
 
        macState = INIT;
 
        slotChange = new cOutVector("slotChange");
 
        // how long does it take to send/receive a control packet
        controlDuration = (double)(b(headerLength).get() + numSlots + 16) / (double)bitrate; // FIXME replace 16 to a constant
        EV << "Control packets take : " << controlDuration << " seconds to transmit\n";
 
        txQueue = getQueue(gate(upperLayerInGateId));
    }
    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);
 
        WATCH(macState);
 
        EV_DETAIL << " slotDuration = " << slotDuration
                  << " controlDuration = " << controlDuration
                  << " numSlots = " << numSlots
                  << " bitrate = " << bitrate << endl;
 
        timeout = new cMessage("timeout", LMAC_TIMEOUT);
        sendData = new cMessage("sendData", LMAC_SEND_DATA);
        wakeup = new cMessage("wakeup", LMAC_WAKEUP);
        initChecker = new cMessage("setup phase", LMAC_SETUP_PHASE_END);
        checkChannel = new cMessage("checkchannel", LMAC_CHECK_CHANNEL);
        start_lmac = new cMessage("start_lmac", LMAC_START_LMAC);
        send_control = new cMessage("send_control", LMAC_SEND_CONTROL);
 
        scheduleAfter(SIMTIME_ZERO, start_lmac);
        EV_DETAIL << "My Mac address is" << networkInterface->getMacAddress() << " and my Id is " << myId << endl;
    }
}

operator=()

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

private

Assignment operator is not allowed.

receiveSignal()

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

overridevirtual

Handle control messages from lower layer.

Handle transmission over messages: send the data packet or don;t do anyhting.

{
    Enter_Method("%s", cComponent::getSignalName(signalID));
 
    if (signalID == IRadio::transmissionStateChangedSignal) {
        IRadio::TransmissionState newRadioTransmissionState = static_cast<IRadio::TransmissionState>(value);
        if (transmissionState == IRadio::TRANSMISSION_STATE_TRANSMITTING && newRadioTransmissionState == IRadio::TRANSMISSION_STATE_IDLE) {
            // if data is scheduled for transfer, don;t do anything.
            if (sendData->isScheduled()) {
                EV_DETAIL << " transmission of control packet over. data transfer will start soon." << endl;
            }
            else {
                EV_DETAIL << " transmission over. nothing else is scheduled, get back to sleep." << endl;
                macState = SLEEP;
                EV_DETAIL << "Old state: ?, New state: SLEEP" << endl;
                radio->setRadioMode(IRadio::RADIO_MODE_SLEEP);
                if (timeout->isScheduled())
                    cancelEvent(timeout);
            }
        }
        transmissionState = newRadioTransmissionState;
    }
    else if (signalID == IRadio::radioModeChangedSignal) {
        IRadio::RadioMode radioMode = (IRadio::RadioMode)value;
        if (macState == SEND_CONTROL && radioMode == IRadio::RADIO_MODE_TRANSMITTER) {
            // we just switched to TX after CCA, so simply send the first sendPremable self message
            scheduleAfter(SIMTIME_ZERO, send_control);
        }
    }
}

Member Data Documentation

bitrate

double inet::LMac::bitrate

protected

the bit rate at which we transmit

checkChannel

cMessage* inet::LMac::checkChannel

protected

controlDuration

double inet::LMac::controlDuration

protected

Duration of teh control time in each slot.

ctrlFrameLength

b inet::LMac::ctrlFrameLength

protected

Length of the control frames.

currSlot

int inet::LMac::currSlot

protected

The current slot of the simulation.

headerLength

b inet::LMac::headerLength

protected

Length of the header.

initChecker

cMessage* inet::LMac::initChecker

protected

LMAC_FREE_SLOT

const MacAddress inet::LMac::LMAC_FREE_SLOT

staticprotected

LMAC_NO_RECEIVER

const MacAddress inet::LMac::LMAC_NO_RECEIVER

staticprotected

dummy receiver address to indicate no pending packets in the control packet

macState

States inet::LMac::macState

protected

keep track of MAC state

myId

int inet::LMac::myId

protected

my ID

mySlot

int inet::LMac::mySlot

protected

my slot ID

numSlots

int inet::LMac::numSlots

protected

how many slots are there

occSlotsAway

MacAddress inet::LMac::occSlotsAway[64]

protected

Occupied slots of two-hop neighbors.

occSlotsDirect

MacAddress inet::LMac::occSlotsDirect[64]

protected

Occupied slots from nodes, from which I hear directly.

radio

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

protected

The radio.

reservedMobileSlots

int inet::LMac::reservedMobileSlots

protected

The first couple of slots are reserved for nodes with special needs to avoid changing slots for them (mobile nodes)

send_control

cMessage* inet::LMac::send_control

protected

sendData

cMessage* inet::LMac::sendData

protected

SETUP_PHASE

bool inet::LMac::SETUP_PHASE

protected

the setup phase is the beginning of the simulation, where only control packets at very small slot durations are exchanged.

slotChange

cOutVector* inet::LMac::slotChange

protected

indicate how often the node needs to change its slot because of collisions

slotDuration

double inet::LMac::slotDuration

protected

Duration of a slot.

start_lmac

cMessage* inet::LMac::start_lmac

protected

timeout

cMessage* inet::LMac::timeout

protected

transmissionState

physicallayer::IRadio::TransmissionState inet::LMac::transmissionState

protected

wakeup

cMessage* inet::LMac::wakeup

protected

---

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

• LMac.h
• LMac.cc