#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