rfid_reader_mac.hpp

#ifndef RFID_READER_MAC_H
#define RFID_READER_MAC_H

#include <vector>
using namespace std;
#include <boost/shared_ptr.hpp>

#include "simulator.hpp"
#include "mac_protocol.hpp"
#include "packet.hpp"

class RfidTagMacData;
typedef boost::shared_ptr<RfidTagMacData> RfidTagMacDataPtr;
class RfidReaderApp;
typedef boost::shared_ptr<RfidReaderApp> RfidReaderAppPtr;

// PacketData Subclass

class RfidReaderMacData : public PacketData {
friend ostream& operator<< (ostream& s, const RfidReaderMacData& data);
public:
   typedef boost::shared_ptr<RfidReaderMacData> RfidReaderMacDataPtr;

   enum Types {
      Types_Generic, 
      Types_Request, 
      Types_Ack, 
      Types_Select 
   };

   static inline RfidReaderMacDataPtr create();

   static inline RfidReaderMacDataPtr create(
      const RfidReaderMacData& rhs);

   virtual inline t_uint getSizeInBytes() const;

   void setSenderId(const NodeId& nodeId);

   NodeId getSenderId() const;

   void setReceiverId(const NodeId& nodeId);

   NodeId getReceiverId() const;

   inline void setType(Types type);

   inline Types getType() const;

   inline void setNumberOfSlots(t_uchar numberOfSlots);

   inline t_uchar getNumberOfSlots() const;

   inline ostream& print(ostream& s) const;

protected:

   RfidReaderMacData();

   RfidReaderMacData(const RfidReaderMacData& rhs);

   virtual PacketDataPtr clone() const;

private:

   static const t_uint m_senderIdBytes = 4;

   static const t_uint m_receiverIdBytes = 12;

   static const t_uint m_typeBytes = 1;

   static const t_uint m_numberOfSlotsBytes = 1;

   t_uchar m_senderId[m_senderIdBytes];

   t_uchar m_receiverId[m_receiverIdBytes];

   t_uchar m_numberOfSlots;

   Types m_type;

};
typedef boost::shared_ptr<RfidReaderMacData> RfidReaderMacDataPtr;

// RfidReaderMac Class

class RfidReaderMac : public SlottedMac {
friend class RfidMacCycleEvent;
public:
   typedef boost::shared_ptr<RfidReaderMac> RfidReaderMacPtr;

   virtual ~RfidReaderMac();

   static inline RfidReaderMacPtr create(NodePtr node, 
      RfidReaderAppPtr readerApp);

   virtual inline RfidReaderMacPtr thisRfidReaderMac();

   virtual inline SlottedMacPtr thisSlottedMac();

   virtual inline MacProtocolPtr thisMacProtocol();

   virtual inline SimulationEndListenerPtr thisSimulationEndListener();

   virtual void simulationEndHandler();

   bool handleRecvdMacPacket(PacketPtr packet, t_uint sendingLayerIdx);

   bool handleRecvdUpperLayerPacket(PacketPtr packet, 
      t_uint sendingLayerIdx);

   virtual void handleChannelBusy(PacketPtr packet);

   virtual void handlePacketSent(PacketPtr packet);

protected:

   static const double m_READER_IFS;

   static const t_uint m_DEFAULT_NUMBER_OF_SLOTS;

   static const double m_DEFAULT_CYCLE_TIME;

   static const t_uint m_MISSED_READ_THRESHOLD;


   static const string m_MISSED_READ_TOTAL_STRING;
   static const string m_MISSED_READ_SLOT_AVG_STRING;
   static const string m_WINNING_SLOT_AVG_STRING;

   bool m_doResetSlot;

   t_uint m_resetSlotNumber;

   bool m_doEntireReadCycle;

   t_uint m_missedReadCount;

   TimerPtr m_cycleTimer;

   PacketPtr m_currentAppReadPacket;

   t_uint m_nextCycleNumberOfSlots;

   SimTime m_nextCycleTime;

   RfidReaderAppPtr m_readerApp;

   vector<pair<NodeId,t_uint> > m_winningSlotNumbers;

   vector<t_uint> m_missedReads;

   RfidReaderMac(NodePtr node, RfidReaderAppPtr readerApp);

   virtual void beginSlotEvent();

   virtual void endRequestCycleEvent();

   PacketPtr createRequestPacket() const;

   PacketPtr createAckPacket(NodeId destination) const;

   void addGenericHeader(PacketPtr packet, NodeId receiverId) const;

   void addSelectHeader(PacketPtr packet, NodeId receiverId) const;

   bool packetIsForMe(RfidTagMacDataPtr macData) const;

   bool isEnoughTimeForContentionCycle() const;

   void startNextContentionCycle();

   bool isPacketType(PacketPtr packet, 
      RfidReaderMacData::Types type) const;

private:

   static const bool m_DEBUG = true;

   static const bool m_DEBUG_CONTENTION_CYCLE_TIME = false;

   boost::weak_ptr<RfidReaderMac> m_weakThis;

};
typedef boost::shared_ptr<RfidReaderMac> RfidReaderMacPtr;

// Event Subclasses

class RfidMacCycleEvent : public Event {
public:
   typedef boost::shared_ptr<RfidMacCycleEvent> 
      RfidMacCycleEventPtr;

   static inline RfidMacCycleEventPtr create(
      RfidReaderMacPtr rfidReaderMac)
   {
      RfidMacCycleEventPtr p(
         new RfidMacCycleEvent(rfidReaderMac));
      return p;
   }

   void execute()
   {
      m_rfidReaderMac->endRequestCycleEvent();
   }

protected:
   RfidMacCycleEvent(RfidReaderMacPtr rfidReaderMac) 
      : Event()
   { 
      m_rfidReaderMac = rfidReaderMac;
   }
private:
   RfidReaderMacPtr m_rfidReaderMac;
};
typedef boost::shared_ptr<RfidMacCycleEvent> 
   RfidMacCycleEventPtr;

// Back to RfidReaderMac

// Inline Functions

inline RfidReaderMacPtr RfidReaderMac::create(NodePtr node, 
   RfidReaderAppPtr readerApp)
{
   RfidReaderMacPtr p(new RfidReaderMac(node, readerApp));
   // weakThis *must* be set before the this* functions are called.
   p->m_weakThis = p;

   SlottedMacSlotEventPtr slotEvent = 
      SlottedMacSlotEvent::create(p->thisSlottedMac());
   p->m_slotTimer = Timer::create(p->getNode(), slotEvent);
   p->m_slotTimer->start(SimTime(0.0));

   RfidMacCycleEventPtr cycleEvent =
      RfidMacCycleEvent::create(p->thisRfidReaderMac());
   p->m_cycleTimer = Timer::create(p->getNode(), cycleEvent);

   Simulator::instance()->addSimulationEndListener(
      p->thisSimulationEndListener());

   return p;
}

inline RfidReaderMacPtr RfidReaderMac::thisRfidReaderMac()
{
   RfidReaderMacPtr p(m_weakThis);
   return p;
}

inline SlottedMacPtr RfidReaderMac::thisSlottedMac()
{
   SlottedMacPtr p(m_weakThis);
   return p;
}

inline MacProtocolPtr RfidReaderMac::thisMacProtocol()
{
   MacProtocolPtr p(m_weakThis);
   return p;
}

inline SimulationEndListenerPtr RfidReaderMac::thisSimulationEndListener()
{
   SimulationEndListenerPtr p(m_weakThis);
   return p;
}

// Overloaded Operators

// RfidReaderMacData Inline Functions

inline RfidReaderMacDataPtr RfidReaderMacData::create()
{
   RfidReaderMacDataPtr p(new RfidReaderMacData());
   return p;
}

inline RfidReaderMacDataPtr RfidReaderMacData::create(
   const RfidReaderMacData& rhs)
{
   RfidReaderMacDataPtr p = 
      boost::dynamic_pointer_cast<RfidReaderMacData>(rhs.clone());
   // If the shared_ptr is empty, then the cast failed.
   assert(p.get() != 0);
   return p;
}

inline t_uint RfidReaderMacData::getSizeInBytes() const
{
   t_uint byteCount = (m_senderIdBytes + m_receiverIdBytes + m_typeBytes);

   switch(getType()) {
   case Types_Request:
      byteCount += m_numberOfSlotsBytes;
      break;
   default:
      break;
   }

   return byteCount;
}

inline void RfidReaderMacData::setType(RfidReaderMacData::Types type)
{
   m_type = type;
}

inline RfidReaderMacData::Types RfidReaderMacData::getType() const
{
   return m_type;
}

inline void RfidReaderMacData::setNumberOfSlots(t_uchar numberOfSlots)
{
   m_numberOfSlots = numberOfSlots;
}

inline t_uchar RfidReaderMacData::getNumberOfSlots() const
{
   return m_numberOfSlots;
}

// Overloaded Operators

inline ostream& operator<< (ostream& s, 
      const RfidReaderMacData::Types& dataType)
{
   switch(dataType) {
   case RfidReaderMacData::Types_Generic:
      s << "GENERIC";
      break;
   case RfidReaderMacData::Types_Request:
      s << "REQUEST";
      break;
   case RfidReaderMacData::Types_Ack:
      s << "ACK";
      break;
   case RfidReaderMacData::Types_Select:
      s << "SELECT";
      break;
   }
   return s;
}

inline ostream& RfidReaderMacData::print(ostream& s) const
{
   s << "type=" << m_type << ", " <<
      "senderId=" << 
      NodeId(m_senderId, m_senderIdBytes) << ", " <<
      "receiverId=" << 
      NodeId(m_receiverId, m_receiverIdBytes) << ", " <<
      "numberOfSlots=" << static_cast<t_uint>(m_numberOfSlots);
   return s;
}

#endif // RFID_READER_MAC_H

---