rfid_tag_mac.hpp

RFID reader 语 tag 模拟器

 #ifndef RFID_TAG_MAC_H
 #define RFID_TAG_MAC_H

 #include <boost/shared_ptr.hpp>

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

 class RfidReaderMacData;
 typedef boost::shared_ptr<RfidReaderMacData> RfidReaderMacDataPtr;
 class RfidTagApp;
 typedef boost::shared_ptr<RfidTagApp> RfidTagAppPtr;

 // PacketData Subclass

 class RfidTagMacData : public PacketData {
 public:
    typedef boost::shared_ptr<RfidTagMacData> RfidTagMacDataPtr;

    enum Types {
       Types_Generic,
       Types_Reply
    };

    static inline RfidTagMacDataPtr create();

    static inline RfidTagMacDataPtr create(
       const RfidTagMacData& 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 ostream& print(ostream& s) const;

 protected:

    RfidTagMacData();

    RfidTagMacData(const RfidTagMacData& rhs);

    virtual PacketDataPtr clone() const;

 private:

    static const t_uint m_senderIdBytes = 12;

    static const t_uint m_receiverIdBytes = 4;

    static const t_uint m_typeBytes = 1;

    t_uchar m_senderId[m_senderIdBytes];

    t_uchar m_receiverId[m_receiverIdBytes];

    Types m_type;

 };
 typedef boost::shared_ptr<RfidTagMacData> RfidTagMacDataPtr;

 // RfidTagMac Class

 class RfidTagMac : public SlottedMac {
 public:
    typedef boost::shared_ptr<RfidTagMac> RfidTagMacPtr;

    virtual ~RfidTagMac();

    static inline RfidTagMacPtr create(NodePtr node,
       RfidTagAppPtr tagApp);

    virtual inline RfidTagMacPtr thisRfidTagMac();

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

    static const double m_TAG_REPLY_IFS;

    RfidTagAppPtr m_tagApp;

    RfidTagMac(NodePtr node, RfidTagAppPtr tagApp);

    virtual void beginSlotEvent();

    bool handleRequestPacket(RfidReaderMacDataPtr macData,
       t_uint sendingLayerIdx);

    PacketPtr createReplyPacket(NodeId receiverId) const;

    void addGenericHeader(PacketPtr packet, NodeId receiverId) const;

    bool packetIsForMe(RfidReaderMacDataPtr macData) const;

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

 private:

    static const bool m_DEBUG = true;

    boost::weak_ptr<RfidTagMac> m_weakThis;

 };
 typedef boost::shared_ptr<RfidTagMac> RfidTagMacPtr;

 // Inline Functions

 inline RfidTagMacPtr RfidTagMac::create(NodePtr node,
    RfidTagAppPtr tagApp)
 {
    RfidTagMacPtr p(new RfidTagMac(node, tagApp));
    // 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));

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

    return p;
 }

 inline RfidTagMacPtr RfidTagMac::thisRfidTagMac()
 {
    RfidTagMacPtr p(m_weakThis);
    return p;
 }

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

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

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

 // Overloaded Operators

 // RfidTagMacData Inline Functions

 inline RfidTagMacDataPtr RfidTagMacData::create()
 {
    RfidTagMacDataPtr p(new RfidTagMacData());
    return p;
 }

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

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

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


 inline t_uint RfidTagMacData::getSizeInBytes() const
 {
    return (m_senderIdBytes + m_receiverIdBytes + m_typeBytes);
 }

 // Overloaded Operators

 inline ostream& operator<< (ostream& s,
       const RfidTagMacData::Types& dataType)
 {
    switch(dataType) {
    case RfidTagMacData::Types_Generic:
       s << "GENERIC";
       break;
    case RfidTagMacData::Types_Reply:
       s << "REPLY";
       break;
    }
    return s;
 }

 inline ostream& RfidTagMacData::print(ostream& s) const
 {
    s << "type=" << m_type << ", " <<
       "senderId=" <<
       NodeId(m_senderId, m_senderIdBytes) << ", " <<
       "receiverId=" <<
       NodeId(m_receiverId, m_receiverIdBytes);
    return s;
 }


 #endif // RFID_TAG_MAC_H