rfid_reader_mac.hpp

RFID reader 语 tag 模拟器

 #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