rfid_reader_mac.cpp

RFID reader 语 tag 模拟器

 void RfidReaderMac::startNextContentionCycle()
 {
    // TODO: Remove this before the assertion.
    if(m_packetToTransmit.get() != 0) {
       ostringstream debugStream;
       debugStream << __PRETTY_FUNCTION__ << *m_packetToTransmit <<
          " curSlot: " << m_currentSlotNumber << ", numSlots: " <<
          m_numberOfSlots;
       LogStreamManager::instance()->logDebugItem(
          debugStream.str());
    }
    assert(m_packetToTransmit.get() == 0);
    m_packetToTransmit = createRequestPacket();
    m_missedReadCount = 0;
    m_doResetSlot = false;
    //cout << "stopCycle2" << endl;
    stopContentionCycle();
    m_txSlotNumber = m_currentSlotNumber;
 }

 bool RfidReaderMac::handleRecvdMacPacket(PacketPtr packet,
    t_uint sendingLayerIdx)
 {
    RfidTagMacDataPtr macData =
       boost::dynamic_pointer_cast<RfidTagMacData>
       (packet->getData(Packet::DataTypes_Link));

    bool wasSuccessful = true;

    // For now, we'll only handle MAC packets from tags.
    if(macData.get() != 0) {
       if(packetIsForMe(macData)) {
          switch(macData->getType()) {
          case RfidTagMacData::Types_Reply:
             // If we ended the cycle early due to too many
             // consecutive missed reads, then the timer will
             // be stopped and we shouldn't handle anymore
             // REPLY packets.
             if(m_cycleTimer->isRunning()) {
                // It could be the case that this reply is received
                // in a contention cycle after the a SELECT packet
                // was lost.  In response to the SELECT packet being
                // lost in slot i, the reader will reset in
                // slot i+2 and send a REQUEST in slot i+3.
                // If this reply is received in slot i+2, we should
                // ignore it since m_packetToTransmit already
                // has a REQUEST packet pending.
                if(m_packetToTransmit.get() == 0) {
                   assert(m_currentAppReadPacket.get() != 0);
                   // Send SELECT message header on the original
                   // app packet.
                   addSelectHeader(m_currentAppReadPacket,
                      macData->getSenderId());
                   m_packetToTransmit = m_currentAppReadPacket;
                   m_txSlotNumber = m_currentSlotNumber;
                   assert(m_slotTimer.get() != 0 &&
                      m_slotTimer->isRunning());
                }
             }
             break;
          case RfidTagMacData::Types_Generic:
             // Subtract three from the winning slot number for:
             // 1. The current slot number was incremented
             // at the beginning of the slot.
             // 2. The REPLY was sent two slots prior
             // to this packet being received (the SELECT
             // packet was sent one slot prior).
             m_winningSlotNumbers.push_back(
                make_pair(macData->getSenderId(),
                (m_currentSlotNumber - 3)));
             // Just pass the packet to upper layers.
             wasSuccessful = sendToLinkLayer(
                CommunicationLayer::Directions_Upper, packet);
             m_packetToTransmit = createAckPacket(macData->getSenderId());
             m_txSlotNumber = m_currentSlotNumber;
             assert(m_slotTimer.get() != 0 &&
                m_slotTimer->isRunning());
             break;
          default:
             wasSuccessful = false;
          }
       }
    }

    return wasSuccessful;
 }

 PacketPtr RfidReaderMac::createRequestPacket() const
 {
    RfidReaderMacDataPtr macData = RfidReaderMacData::create();
    macData->setType(RfidReaderMacData::Types_Request);
    macData->setSenderId(getNode()->getNodeId());
    macData->setReceiverId(NodeId::broadcastDestination());
    // We must have at least: (1) a contention slot,
    // (2) a slot for the SELECT to be sent by the ready,
    // (3) a slot for the tag to reply with an app packet,
    // (4) a slot for the reader to reply with an ACK.
    assert(m_nextCycleNumberOfSlots >= 4);
    macData->setNumberOfSlots(m_nextCycleNumberOfSlots);
    PacketPtr packet = Packet::create();
    assert(m_currentAppReadPacket.get() != 0);
    packet->setTxPower(m_currentAppReadPacket->getTxPower());
    packet->addData(Packet::DataTypes_Link, *macData);
    return packet;
 }

 PacketPtr RfidReaderMac::createAckPacket(NodeId destination) const
 {
    RfidReaderMacDataPtr macData = RfidReaderMacData::create();
    macData->setType(RfidReaderMacData::Types_Ack);
    macData->setSenderId(getNode()->getNodeId());
    macData->setReceiverId(destination);

    PacketPtr packet = Packet::create();
    packet->setDoMaxTxPower(true);
    packet->addData(Packet::DataTypes_Link, *macData);
    return packet;
 }

 void RfidReaderMac::addGenericHeader(PacketPtr packet,
    NodeId receiverId) const
 {
    RfidReaderMacDataPtr macData = RfidReaderMacData::create();
    macData->setType(RfidReaderMacData::Types_Generic);
    macData->setSenderId(getNode()->getNodeId());
    macData->setReceiverId(receiverId);
    packet->addData(Packet::DataTypes_Link, *macData);
 }

 void RfidReaderMac::addSelectHeader(PacketPtr packet,
    NodeId receiverId) const
 {
    RfidReaderMacDataPtr macData = RfidReaderMacData::create();
    macData->setType(RfidReaderMacData::Types_Select);
    macData->setSenderId(getNode()->getNodeId());
    macData->setReceiverId(receiverId);
    packet->setDoMaxTxPower(true);
    packet->addData(Packet::DataTypes_Link, *macData);
 }

 bool RfidReaderMac::handleRecvdUpperLayerPacket(PacketPtr packet,
    t_uint sendingLayerIdx)
 {
    RfidReaderAppDataPtr appData =
       boost::dynamic_pointer_cast<RfidReaderAppData>
       (packet->getData(Packet::DataTypes_Application));

    bool wasSuccessful = false;

    if(m_DEBUG) {
       ostringstream debugStream;
       debugStream << __PRETTY_FUNCTION__;
       LogStreamManager::instance()->logDebugItem(
          debugStream.str());
    }

    // For now, we only handle application packets.
    if(appData.get() != 0) {
       switch(appData->getType()) {
       case RfidReaderAppData::Types_Read:
          // We'll only handle one packet at a time
          blockUpperQueues();

          assert(m_currentAppReadPacket.get() == 0);
          m_currentAppReadPacket = packet;
          m_doEntireReadCycle = appData->getDoEntireReadCycle();
          // Start cycle timer
          assert(m_cycleTimer.get() != 0);
          m_cycleTimer->start(m_nextCycleTime);
          if(isEnoughTimeForContentionCycle()) {
             startNextContentionCycle();
          }
          wasSuccessful = true;
          break;
       case RfidReaderAppData::Types_Reset:
          // We'll only handle one packet at a time
          blockUpperQueues();

          assert(m_packetToTransmit == 0);
          addGenericHeader(packet, NodeId::broadcastDestination());
          m_packetToTransmit = packet;
          m_txSlotNumber = m_currentSlotNumber;
          wasSuccessful = true;
          break;
       default:
          wasSuccessful = false;
       }
       assert(m_slotTimer.get() != 0 && m_slotTimer->isRunning());
    }

    return wasSuccessful;
 }

 // RfidReaderMacData functions

 RfidReaderMacData::RfidReaderMacData()
    : m_numberOfSlots(0), m_type(RfidReaderMacData::Types_Generic)
 {
    fill(m_senderId, &m_senderId[m_senderIdBytes], 0);
    fill(m_receiverId, &m_receiverId[m_receiverIdBytes], 0);
 }

 RfidReaderMacData::RfidReaderMacData(const RfidReaderMacData& rhs)
    : PacketData(rhs), m_numberOfSlots(rhs.m_numberOfSlots),
    m_type(rhs.m_type)
 {
    copy(rhs.m_senderId, &rhs.m_senderId[m_senderIdBytes], m_senderId);
    copy(rhs.m_receiverId, &rhs.m_receiverId[m_receiverIdBytes],
       m_receiverId);
 }

 PacketDataPtr RfidReaderMacData::clone() const
 {
     PacketDataPtr p(new RfidReaderMacData(*this));
     return p;
 }

 void RfidReaderMacData::setSenderId(const NodeId& nodeId)
 {
    nodeId.writeToByteArray(m_senderId, m_senderIdBytes);
 }

 NodeId RfidReaderMacData::getSenderId() const
 {
    NodeId nodeId(m_senderId, m_senderIdBytes);
    return nodeId;
 }

 void RfidReaderMacData::setReceiverId(const NodeId& nodeId)
 {
    nodeId.writeToByteArray(m_receiverId, m_receiverIdBytes);
 }

 NodeId RfidReaderMacData::getReceiverId() const
 {
    NodeId nodeId(m_receiverId, m_receiverIdBytes);
    return nodeId;
 }