BMAC protocol data packets forwarding to SINK?

[Kamran Ali]

hi, im using 25 nodes(5*5) structure using BMAC protocol in MiXiM 2.3 library of omnet++ 4.3. sink node is fixed as 00. when i keep sink at center of 25 nodes it receives max data packets but when i keep sink at some other position , sink receives less packets as compared to other maximas.in this regard how to perform forwading function so that

1. all nodes forward their packets to sink

2. sink receive all packets , count them and then delete msg

//

// This program is free software: you can redistribute it and/or modify

// it under the terms of the GNU Lesser General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

// 

// This program is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU Lesser General Public License for more details.

// 

// You should have received a copy of the GNU Lesser General Public License

// along with this program.  If not, see http://www.gnu.org/licenses/.

// 

#ifndef BMACLAYER_H_

#define BMACLAYER_H_

#include <string>

#include <sstream>

#include <vector>

#include <list>

#include "MiXiMDefs.h"

#include "BaseMacLayer.h"

#include <DroppedPacket.h>

class MacPkt;

/**

 * @brief 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:

 *

 * \image html BMACFSM.png "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

 *

 * @class BMacLayer

 * @ingroup macLayer

 * @author Anna Foerster

 *

 */

class MIXIM_API BMacLayer : public BaseMacLayer

{

  private:

/** @brief Copy constructor is not allowed.

*/

BMacLayer(const BMacLayer&);

/** @brief Assignment operator is not allowed.

*/

BMacLayer& operator=(const BMacLayer&);

  public:

BMacLayer()

: BaseMacLayer()

, macQueue()

, nbTxDataPackets(0), nbTxPreambles(0), nbRxDataPackets(0), nbRxPreambles(0)

, nbMissedAcks(0), nbRecvdAcks(0), nbDroppedDataPackets(0), nbTxAcks(0)

, macState(INIT)

, resend_data(NULL), ack_timeout(NULL), start_bmac(NULL), wakeup(NULL)

, send_ack(NULL), cca_timeout(NULL), ack_tx_over(NULL), send_preamble(NULL), stop_preambles(NULL)

, data_tx_over(NULL), data_timeout(NULL)

, lastDataPktSrcAddr()

, lastDataPktDestAddr()

, txAttempts(0)

, droppedPacket()

, nicId(-1)

, queueLength(0)

, animation(false)

, slotDuration(0), bitrate(0), checkInterval(0), txPower(0)

, useMacAcks(0)

, maxTxAttempts(0)

, stats(false)

{}

virtual ~BMacLayer();

    /** @brief Initialization of the module and some variables*/

    virtual void initialize(int);

    /** @brief Delete all dynamically allocated objects of the module*/

    virtual void finish();

    /** @brief Handle messages from lower layer */

    virtual void handleLowerMsg(cMessage*);

    /** @brief Handle messages from upper layer */

    virtual void handleUpperMsg(cMessage*);

    /** @brief Handle self messages such as timers */

    virtual void handleSelfMsg(cMessage*);

    /** @brief Handle control messages from lower layer */

    virtual void handleLowerControl(cMessage *msg);

  protected:

    typedef std::list<macpkt_ptr_t> MacQueue;

    /** @brief A queue to store packets from upper layer in case another

packet is still waiting for transmission.*/

    MacQueue macQueue;

    /** @name Different tracked statistics.*/

/*@{*/

long nbTxDataPackets;

long nbTxPreambles;

long nbRxDataPackets;

long nbRxPreambles;

long nbMissedAcks;

long nbRecvdAcks;

long nbDroppedDataPackets;

long nbTxAcks;

/*@}*/

/** @brief 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

*/

enum States {

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

 };

/** @brief The current state of the protocol */

States macState;

/** @brief Types of messages (self messages and packets) the node can

* process **/

enum TYPES {

// packet types

BMAC_PREAMBLE = 191,

BMAC_DATA,

BMAC_ACK,

// self message types

BMAC_RESEND_DATA,

BMAC_ACK_TIMEOUT,

BMAC_START_BMAC,

BMAC_WAKE_UP,

BMAC_SEND_ACK,

BMAC_CCA_TIMEOUT,

BMAC_ACK_TX_OVER,

BMAC_SEND_PREAMBLE,

BMAC_STOP_PREAMBLES,

BMAC_DATA_TX_OVER,

BMAC_DATA_TIMEOUT

};

// messages used in the FSM

cMessage *resend_data;

cMessage *ack_timeout;

cMessage *start_bmac;

cMessage *wakeup;

cMessage *send_ack;

cMessage *cca_timeout;

cMessage *ack_tx_over;

cMessage *send_preamble;

cMessage *stop_preambles;

cMessage *data_tx_over;

cMessage *data_timeout;

/** @name Help variables for the acknowledgment process. */

/*@{*/

LAddress::L2Type lastDataPktSrcAddr;

LAddress::L2Type lastDataPktDestAddr;

int              txAttempts;

/*@}*/

/** @brief Inspect reasons for dropped packets */

DroppedPacket droppedPacket;

/** @brief publish dropped packets nic wide */

int nicId;

/** @brief The maximum length of the queue */

unsigned int queueLength;

/** @brief 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

*/

bool animation;

/** @brief The duration of the slot in secs. */

double slotDuration;

/** @brief The bitrate of transmission */

double bitrate;

/** @brief The duration of CCA */

double checkInterval;

/** @brief Transmission power of the node */

double txPower;

/** @brief Use MAC level acks or not */

bool useMacAcks;

/** @brief Maximum transmission attempts per data packet, when ACKs are

* used */

int maxTxAttempts;

/** @brief Gather stats at the end of the simulation */

bool stats;

/** @brief Possible colors of the node for animation */

enum BMAC_COLORS {

GREEN = 1,

BLUE = 2,

RED = 3,

BLACK = 4,

YELLOW = 5

};

/** @brief Internal function to change the color of the node */

void changeDisplayColor(BMAC_COLORS color);

/** @brief Internal function to send the first packet in the queue */

void sendDataPacket();

/** @brief Internal function to send an ACK */

void sendMacAck();

/** @brief Internal function to send one preamble */

void sendPreamble();

/** @brief Internal function to attach a signal to the packet */

void attachSignal(macpkt_ptr_t macPkt);

/** @brief Internal function to add a new packet from upper to the queue */

bool addToQueue(cMessage * msg);

void dutycycle();

};

#endif /* BMACLAYER_H_ */