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

#include <LMacLayer.h>

Inheritance diagram for inet::LMacLayer:

Public Member Functions
	LMacLayer ()

virtual	~LMacLayer ()
	Clean up messges. More...

virtual void	initialize (int) override
	Initialization of the module and some variables. 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...

virtual LMacFrame *	encapsMsg (cPacket *)
	Encapsulate the NetwPkt into an MacPkt. More...

virtual cPacket *	decapsMsg (LMacFrame *)

cObject *	setUpControlInfo (cMessage *const pMsg, const MACAddress &pSrcAddr)
	Attaches a "control info" (MacToNetw) structure (object) to the message pMsg. 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, WAIT_CONTROL, WAIT_DATA, SEND_CONTROL, SEND_DATA }
	MAC states. More...

enum	TYPES { LMAC_CONTROL = 167, LMAC_TIMEOUT = 168, LMAC_WAKEUP = 169, LMAC_SEND_DATA = 170, LMAC_SETUP_PHASE_END = 171, LMAC_CHECK_CHANNEL = 172, LMAC_SOMEBODY = 173, LMAC_DATA = 174, LMAC_START_LMAC = 175, LMAC_SEND_CONTROL = 176 }

typedef std::list< LMacFrame * >	MacQueue

Protected Member Functions
virtual void	initializeMACAddress ()
	Generate new interface address. More...

virtual InterfaceEntry *	createInterfaceEntry () override

virtual void	handleCommand (cMessage *msg)

void	findNewSlot ()
	find a new slot More...

void	attachSignal (LMacFrame *macPkt)
	Internal function to attach a signal to the packet. More...

virtual void	flushQueue ()

virtual void	clearQueue ()

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 int	numInitStages () const override

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
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...

int	headerLength
	Length of the header. More...

double	controlDuration
	Duration of teh control time in each slot. 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...

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
	The radio. More...

IRadio::TransmissionState	transmissionState

unsigned	queueLength
	length of the queue More...

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::OperationalBase
bool	isOperational

simtime_t	lastChange

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
	LMacLayer (const LMacLayer &)
	Copy constructor is not allowed. More...

LMacLayer &	operator= (const LMacLayer &)
	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 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 Typedef Documentation

typedef std::list<LMacFrame *> inet::LMacLayer::MacQueue

protected

Member Enumeration Documentation

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

enum inet::LMacLayer::TYPES

protected

Enumerator
LMAC_CONTROL
LMAC_TIMEOUT
LMAC_WAKEUP
LMAC_SEND_DATA
LMAC_SETUP_PHASE_END
LMAC_CHECK_CHANNEL
LMAC_SOMEBODY
LMAC_DATA
LMAC_START_LMAC
LMAC_SEND_CONTROL

                {
         LMAC_CONTROL = 167,
         LMAC_TIMEOUT = 168,
         LMAC_WAKEUP = 169,
         LMAC_SEND_DATA = 170,
         LMAC_SETUP_PHASE_END = 171,
         LMAC_CHECK_CHANNEL = 172,
         LMAC_SOMEBODY = 173,
         LMAC_DATA = 174,
         LMAC_START_LMAC = 175,
         LMAC_SEND_CONTROL = 176
     };

Constructor & Destructor Documentation

inet::LMacLayer::LMacLayer ( const LMacLayer & )

private

Copy constructor is not allowed.

inet::LMacLayer::LMacLayer ( )

inline

         : MACProtocolBase()
         , SETUP_PHASE(true)
         , slotChange()
         , macState()
         , slotDuration(0)
         , headerLength(0)
         , controlDuration(0)
         , mySlot(0)
         , numSlots(0)
         , currSlot()
         , reservedMobileSlots(0)
         , macQueue()
         , radio(nullptr)
         , transmissionState(IRadio::TRANSMISSION_STATE_UNDEFINED)
         , queueLength(0)
         , wakeup(nullptr)
         , timeout(nullptr)
         , sendData(nullptr)
         , initChecker(nullptr)
         , checkChannel(nullptr)
         , start_lmac(nullptr)
         , send_control(nullptr)
         , bitrate(0)
     {}

inet::LMacLayer::~LMacLayer ( )

virtual

Clean up messges.

 {
     delete slotChange;
     cancelAndDelete(timeout);
     cancelAndDelete(wakeup);
     cancelAndDelete(checkChannel);
     cancelAndDelete(sendData);
     cancelAndDelete(initChecker);
     cancelAndDelete(start_lmac);
     cancelAndDelete(send_control);
 
     for (auto & elem : macQueue) {
         delete (elem);
     }
     macQueue.clear();
 }

Member Function Documentation

void inet::LMacLayer::attachSignal ( LMacFrame * 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);
 }

void inet::LMacLayer::clearQueue ( )

protectedvirtual

 {
     macQueue.clear();
 }

InterfaceEntry * inet::LMacLayer::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::LMacLayer::decapsMsg ( LMacFrame * msg )

virtual

Referenced by handleSelfMessage().

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

LMacFrame * inet::LMacLayer::encapsMsg ( cPacket * netwPkt )

virtual

Encapsulate the NetwPkt into an MacPkt.

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

Referenced by handleUpperPacket().

 {
     LMacFrame *pkt = new LMacFrame(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::LMacLayer::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)

Referenced by handleSelfMessage().

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

void inet::LMacLayer::flushQueue ( )

protectedvirtual

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

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

inlineprotectedvirtual

126 {}

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

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.

Implements inet::LayeredProtocolBase.

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

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

Referenced by handleLowerPacket().

 {
     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
                 scheduleAt(slotDuration * 5 * numSlots, initChecker);
                 EV << "Startup time =" << slotDuration * 5 * numSlots << endl;
 
                 EV_DETAIL << "Scheduling the first wakeup at : " << slotDuration << endl;
 
                 scheduleAt(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();
                     scheduleAt(simTime() + 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
                         scheduleAt(simTime() + 2.f * controlDuration, timeout);
                 }
                 if (SETUP_PHASE) {
                     scheduleAt(simTime() + 2.f * controlDuration, wakeup);
                     EV_DETAIL << "setup phase slot duration:" << 2.f * controlDuration << "while controlduration is" << controlDuration << endl;
                 }
                 else
                     scheduleAt(simTime() + slotDuration, wakeup);
             }
             else if (msg->getKind() == LMAC_SETUP_PHASE_END) {
                 EV_DETAIL << "Setup phase end. Start normal work at the next slot.\n";
                 if (wakeup->isScheduled())
                     cancelEvent(wakeup);
 
                 scheduleAt(simTime() + 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) {
                 LMacFrame *const mac = static_cast<LMacFrame *>(msg);
                 const MACAddress& dest = mac->getDestAddr();
                 EV_DETAIL << " I have received a control packet from src " << mac->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] = mac->getOccupiedSlots(s);
                     EV_DETAIL << "Occupied slot " << s << ": " << occSlotsAway[s] << endl;
                     EV_DETAIL << "Occupied direct slot " << s << ": " << occSlotsDirect[s] << endl;
                 }
 
                 if (mac->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] == mac->getSrcAddr())
                             occSlotsDirect[i] = LMAC_FREE_SLOT;
                         if (occSlotsAway[i] == mac->getSrcAddr())
                             occSlotsAway[i] = LMAC_FREE_SLOT;
                     }
                     occSlotsAway[mac->getMySlot()] = mac->getSrcAddr();
                     occSlotsDirect[mac->getMySlot()] = mac->getSrcAddr();
                 }
                 collision = collision || (mac->getMySlot() == mySlot);
                 if (((mySlot > -1) && (mac->getOccupiedSlots(mySlot) > LMAC_FREE_SLOT) && (mac->getOccupiedSlots(mySlot) != address)) || collision) {
                     EV_DETAIL << "My slot is taken by " << mac->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 mac;
             }
             //probably it never happens
             else if (msg->getKind() == LMAC_DATA) {
                 LMacFrame *const mac = static_cast<LMacFrame *>(msg);
                 const MACAddress& dest = mac->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";
                     sendUp(decapsMsg(mac));
                 }
                 else {
                     EV_DETAIL << "packet not for me, deleting...\n";
                     delete mac;
                 }
                 // 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";
                 if (wakeup->isScheduled())
                     cancelEvent(wakeup);
 
                 scheduleAt(simTime() + 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) {
                 LMacFrame *const mac = static_cast<LMacFrame *>(msg);
                 const MACAddress& dest = mac->getDestAddr();
                 EV_DETAIL << " I have received a control packet from src " << mac->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] = mac->getOccupiedSlots(s);
                     EV_DETAIL << "Occupied slot " << s << ": " << occSlotsAway[s] << endl;
                     EV_DETAIL << "Occupied direct slot " << s << ": " << occSlotsDirect[s] << endl;
                 }
 
                 if (mac->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] == mac->getSrcAddr())
                             occSlotsDirect[i] = LMAC_FREE_SLOT;
                         if (occSlotsAway[i] == mac->getSrcAddr())
                             occSlotsAway[i] = LMAC_FREE_SLOT;
                     }
                     occSlotsAway[mac->getMySlot()] = mac->getSrcAddr();
                     occSlotsDirect[mac->getMySlot()] = mac->getSrcAddr();
                 }
 
                 collision = collision || (mac->getMySlot() == mySlot);
                 if (((mySlot > -1) && (mac->getOccupiedSlots(mySlot) > LMAC_FREE_SLOT) && (mac->getOccupiedSlots(mySlot) != address)) || collision) {
                     EV_DETAIL << "My slot is taken by " << mac->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 mac;
             }
             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;
                 scheduleAt(simTime(), wakeup);
             }
             else if (msg->getKind() == LMAC_SETUP_PHASE_END) {
                 EV_DETAIL << "Setup phase end. Start normal work at the next slot.\n";
                 if (wakeup->isScheduled())
                     cancelEvent(wakeup);
 
                 scheduleAt(simTime() + slotDuration, wakeup);
 
                 SETUP_PHASE = false;
             }
             else {
                 EV << "Unknown packet" << msg->getKind() << "in state" << macState << endl;
             }
 
             break;
 
         case SEND_CONTROL:
 
             if (msg->getKind() == LMAC_SEND_CONTROL) {
                 // send first a control message, so that non-receiving nodes can switch off.
                 EV << "Sending a control packet.\n";
                 LMacFrame *control = new LMacFrame();
                 control->setKind(LMAC_CONTROL);
                 if ((macQueue.size() > 0) && !SETUP_PHASE)
                     control->setDestAddr((macQueue.front())->getDestAddr());
                 else
                     control->setDestAddr(LMAC_NO_RECEIVER);
 
                 control->setSrcAddr(address);
                 control->setMySlot(mySlot);
                 control->setBitLength(headerLength + numSlots);
                 control->setOccupiedSlotsArraySize(numSlots);
                 for (int i = 0; i < numSlots; i++)
                     control->setOccupiedSlots(i, occSlotsDirect[i]);
 
                 sendDown(control);
                 if ((macQueue.size() > 0) && (!SETUP_PHASE))
                     scheduleAt(simTime() + 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;
                 }
                 LMacFrame *data = macQueue.front()->dup();
                 data->setKind(LMAC_DATA);
                 data->setMySlot(mySlot);
                 data->setOccupiedSlotsArraySize(numSlots);
                 for (int i = 0; i < numSlots; i++)
                     data->setOccupiedSlots(i, occSlotsDirect[i]);
 
                 EV << "Sending down data packet\n";
                 sendDown(data);
                 delete macQueue.front();
                 macQueue.pop_front();
                 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";
                 if (wakeup->isScheduled())
                     cancelEvent(wakeup);
 
                 scheduleAt(simTime() + 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) {
                 LMacFrame *const mac = static_cast<LMacFrame *>(msg);
                 const MACAddress& dest = mac->getDestAddr();
 
                 EV_DETAIL << " I have received a data packet.\n";
                 if (dest == address || dest.isBroadcast()) {
                     EV_DETAIL << "sending pkt to upper...\n";
                     sendUp(decapsMsg(mac));
                 }
                 else {
                     EV_DETAIL << "packet not for me, deleting...\n";
                     delete mac;
                 }
                 // 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;
                 scheduleAt(simTime(), wakeup);
             }
             else {
                 EV << "Unknown packet" << msg->getKind() << "in state" << macState << endl;
             }
             break;
 
         default:
             throw cRuntimeError("Unknown mac state: %d", macState);
             break;
     }
 }

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

Sending of messages is automatic.

Implements inet::LayeredProtocolBase.

 {
     LMacFrame *mac = static_cast<LMacFrame *>(encapsMsg(static_cast<cPacket *>(msg)));
 
     // message has to be queued if another message is waiting to be send
     // or if we are already trying to send another message
 
     if (macQueue.size() <= queueLength) {
         macQueue.push_back(mac);
         EV_DETAIL << "packet put in queue\n  queue size: " << macQueue.size() << " macState: " << macState
                   << "; mySlot is " << mySlot << "; current slot is " << currSlot << endl;
         ;
     }
     else {
         // queue is full, message has to be deleted
         EV_DETAIL << "New packet arrived, but queue is FULL, so new packet is deleted\n";
         delete mac;
         EV_DETAIL << "ERROR: Queue is full, forced to delete.\n";
     }
 }

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

overridevirtual

Initialization of the module and some variables.

Reimplemented from inet::MACProtocolBase.

 {
     MACProtocolBase::initialize(stage);
     if (stage == INITSTAGE_LOCAL) {
         queueLength = par("queueLength");
         slotDuration = par("slotDuration");
         bitrate = par("bitrate");
         headerLength = par("headerLength");
         EV << "headerLength is: " << headerLength << endl;
         numSlots = par("numSlots");
         // the first N slots are reserved for mobile nodes to be able to function normally
         reservedMobileSlots = par("reservedMobileSlots");
 
         EV_DETAIL << "My Mac address is" << address << " and my Id is " << myId << endl;
 
         macState = INIT;
 
         slotChange = new cOutVector("slotChange");
 
         // how long does it take to send/receive a control packet
         controlDuration = ((double)headerLength + (double)numSlots + 16) / (double)bitrate;
         EV << "Control packets take : " << controlDuration << " seconds to transmit\n";
 
         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);
 
         WATCH(macState);
     }
     else if (stage == INITSTAGE_LINK_LAYER) {
         //int channel;
         //channel = hasPar("defaultChannel") ? par("defaultChannel") : 0;
 
         EV_DETAIL << "queueLength = " << queueLength
                   << " slotDuration = " << slotDuration
                   << " controlDuration = " << controlDuration
                   << " numSlots = " << numSlots
                   << " bitrate = " << bitrate << endl;
 
         timeout = new cMessage("timeout");
         timeout->setKind(LMAC_TIMEOUT);
 
         sendData = new cMessage("sendData");
         sendData->setKind(LMAC_SEND_DATA);
 
         wakeup = new cMessage("wakeup");
         wakeup->setKind(LMAC_WAKEUP);
 
         initChecker = new cMessage("setup phase");
         initChecker->setKind(LMAC_SETUP_PHASE_END);
 
         checkChannel = new cMessage("checkchannel");
         checkChannel->setKind(LMAC_CHECK_CHANNEL);
 
         start_lmac = new cMessage("start_lmac");
         start_lmac->setKind(LMAC_START_LMAC);
 
         send_control = new cMessage("send_control");
         send_control->setKind(LMAC_SEND_CONTROL);
 
         scheduleAt(0.0, start_lmac);
     }
 }

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

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

private

Assignment operator is not allowed.

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

overridevirtual

Handle control messages from lower layer.

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

 {
     if (signalID == IRadio::transmissionStateChangedSignal) {
         IRadio::TransmissionState newRadioTransmissionState = (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
             scheduleAt(simTime(), send_control);
         }
     }
 }

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

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