physical_layer.hpp

RFID reader 语 tag 模拟器

 #ifndef PHYSICAL_LAYER_H
 #define PHYSICAL_LAYER_H

 #include <map>
 #include <boost/shared_ptr.hpp>

 #include "utility.hpp"
 #include "communication_layer.hpp"
 #include "wireless_comm_signal.hpp"
 #include "wireless_channel_manager.hpp"
 #include "log_stream_manager.hpp"
 #include "node.hpp"
 #include "timer.hpp"

 typedef map<WirelessCommSignalPtr,double> SignalStrengthMap;

 class PhysicalLayer : public CommunicationLayer {
 friend class SignalRecvEvent;
 public:
    typedef boost::shared_ptr<PhysicalLayer> PhysicalLayerPtr;

    virtual ~PhysicalLayer();

    virtual PhysicalLayerPtr thisPhysicalLayer() = 0;

    inline void setWirelessChannelManager(
       WirelessChannelManagerPtr wirelessChannelManager);

    bool recvPendingSignal(WirelessCommSignalPtr signal,
       double recvdSignalStrength);

    virtual bool sendSignal(WirelessCommSignalPtr signal);

    bool isTransmitting() const;

    inline void setSignalSendingDelay(SimTime signalSendingDelay);

    inline SimTime getSignalSendingDelay() const;

    bool recvFromLayer(CommunicationLayer::Directions direction,
       PacketPtr packet, t_uint sendingLayerIdx);

    Location getLocation() const;

    void addSignal(WirelessCommSignalPtr signal,
       double signalStrength);

    void removeSignal(WirelessCommSignalPtr signal);

    bool pendingSignalIsWeak();

    bool captureSignal(double signalStrength) const;

    double getCulmulativeSignalStrength() const;

    inline double getNoiseFloor() const;

    void setPendingSignal(WirelessCommSignalPtr signal);

    inline void setPendingSignalError(bool hasError);

    inline bool getPendingSignalError() const;

    ConstWirelessCommSignalPtr getPendingSignal() const;

    double getPendingSignalStrength();

    double getPendingSignalSinr();

    void resetPendingSignal();

    void resetRecvSignals();

    bool channelCarrierSensedBusy() const;

    inline void setCurrentTxPower(double txPower);

    inline double getCurrentTxPower() const;

    inline double getMaxTxPower() const;

    inline void setRxThreshold(double rxThreshold);

    inline double getRxThreshold() const;

    inline void setCsThreshold(double csThreshold);

    inline double getCsThreshold() const;

    inline void setCaptureThreshold(double captureThreshold);

    inline double getCaptureThreshold() const;

    inline void setMinimumSignalStrength(double minimumSignalStrength);

    inline double getMinimumSignalStrength() const;

    inline void setDataRate(double dataRate);

    inline double getDataRate() const;

    inline void setBandwidth(double bandwidth);

    inline double getBandwidth() const;

    inline double getGain() const;

    inline double getWavelength() const;

    inline CommunicationLayer::Types getLayerType() const;

 protected:

    WirelessChannelManagerPtr m_wirelessChannelManagerPtr;

    PhysicalLayer(NodePtr node);

    virtual void recvdErrorFreeSignal(WirelessCommSignalPtr signal,
       double recvdSignalStrength);

    inline void setMaxTxPower(double txPower);

    bool scheduleSignal(WirelessCommSignalPtr signal);

 private:

    static const double m_DEFAULT_TX_POWER;

    static const double m_DEFAULT_MAX_TX_POWER;

    static const double m_DEFAULT_RX_THRESHOLD;

    static const double m_DEFAULT_CS_THRESHOLD;

    static const double m_DEFAULT_CAPTURE_THRESHOLD;

    static const double m_DEFAULT_MINIMUM_SIGNAL_STRENGTH;

    static const double m_DEFAULT_DATA_RATE;

    static const double m_DEFAULT_BANDWIDTH;

    static const double m_RADIO_TEMPERATURE;

    static const double m_RADIO_NOISE_FACTOR;

    static const double m_BOLTZMANNS_CONSTANT;

    static const t_uint m_PHYSICAL_QUEUE_LENGTH;

    static const bool m_DEBUG_SIGNAL_CAPTURE = true;
    static const bool m_DEBUG_TRANSMIT_POWER = true;

    double m_currentTxPower;

    double m_maxTxPower;

    double m_rxThreshold;

    double m_csThreshold;

    double m_captureThreshold;

    double m_minimumSignalStrength;

    double m_dataRate;

    double m_bandwidth;

    bool m_pendingRecvSignalError;

    SignalStrengthMap m_signalStrengths;

    WirelessCommSignalPtr m_pendingRecvSignal;

    SimTime m_signalSendingDelay;

    TimerPtr m_transmittingTimer;

 };
 typedef boost::shared_ptr<PhysicalLayer> PhysicalLayerPtr;

 // Inline Functions

 inline void PhysicalLayer::setWirelessChannelManager(
    WirelessChannelManagerPtr wirelessChannelManager)
 {
    m_wirelessChannelManagerPtr = wirelessChannelManager;
 }

 inline void PhysicalLayer::setCurrentTxPower(double txPower)
 {
    assert(txPower > 0.0);
    m_currentTxPower = txPower;
 }

 inline double PhysicalLayer::getCurrentTxPower() const
 {
    return m_currentTxPower;
 }

 inline void PhysicalLayer::setMaxTxPower(double txPower)
 {
    assert(txPower > 0.0);
    m_maxTxPower = txPower;
    m_currentTxPower = min(m_currentTxPower, m_maxTxPower);
 }

 inline double PhysicalLayer::getMaxTxPower() const
 {
    return m_maxTxPower;
 }

 inline void PhysicalLayer::setRxThreshold(double rxThreshold)
 {
    assert(rxThreshold > 0.0);
    m_rxThreshold = rxThreshold;
 }

 inline double PhysicalLayer::getRxThreshold() const
 {
    return m_rxThreshold;
 }

 inline void PhysicalLayer::setCsThreshold(double csThreshold)
 {
    assert(csThreshold > 0.0);
    m_csThreshold = csThreshold;
 }

 inline double PhysicalLayer::getCsThreshold() const
 {
    return m_csThreshold;
 }

 inline void PhysicalLayer::setCaptureThreshold(double captureThreshold)
 {
    assert(captureThreshold > 0.0);
    m_captureThreshold = captureThreshold;
 }

 inline double PhysicalLayer::getCaptureThreshold() const
 {
    return m_captureThreshold;
 }

 inline void PhysicalLayer::setMinimumSignalStrength(
    double minimumSignalStrength)
 {
    assert(minimumSignalStrength > 0.0);
    m_minimumSignalStrength = minimumSignalStrength;
 }

 inline double PhysicalLayer::getMinimumSignalStrength() const
 {
    return m_minimumSignalStrength;
 }

 inline void PhysicalLayer::setDataRate(double dataRate)
 {
    assert(dataRate > 0.0);
    m_dataRate = dataRate;
 }

 inline double PhysicalLayer::getDataRate() const
 {
    return m_dataRate;
 }

 inline void PhysicalLayer::setBandwidth(double bandwidth)
 {
    assert(bandwidth > 0.0);
    m_bandwidth = bandwidth;
 }

 inline double PhysicalLayer::getBandwidth() const
 {
    return m_bandwidth;
 }

 inline double PhysicalLayer::getNoiseFloor() const
 {
    return (m_RADIO_NOISE_FACTOR * m_BOLTZMANNS_CONSTANT *
       m_RADIO_TEMPERATURE * getBandwidth());
 }

 inline double PhysicalLayer::getGain() const
 {
    // This is just a placeholder function for now.
    return 1.0;
 }

 inline void PhysicalLayer::setPendingSignalError(bool hasError)
 {
    m_pendingRecvSignalError = hasError;
 }

 inline bool PhysicalLayer::getPendingSignalError() const
 {
    return m_pendingRecvSignalError;
 }

 inline double PhysicalLayer::getWavelength() const
 {
    return (SPEED_OF_LIGHT / m_bandwidth);
 }

 inline void PhysicalLayer::setSignalSendingDelay(
    SimTime signalSendingDelay)
 {
    m_signalSendingDelay = signalSendingDelay;
 }

 inline SimTime PhysicalLayer::getSignalSendingDelay() const
 {
    return m_signalSendingDelay;
 }

 inline CommunicationLayer::Types PhysicalLayer::getLayerType() const
 {
    return CommunicationLayer::Types_Physical;
 }

 // Overloaded Operators

 // Event Subclasses

 class SignalRecvEvent : public Event {
 public:
    typedef boost::shared_ptr<SignalRecvEvent> SignalRecvEventPtr;

    SignalRecvEvent(WirelessChannelManagerPtr channelManager,
          PhysicalLayerPtr sender, WirelessCommSignalPtr signal)
          : Event(), m_channelManager(channelManager),
          m_sender(sender), m_signal(signal)
    {
       assert(m_channelManager.get() != 0);
    }

    void execute()
    {
       assert(m_channelManager.get() != 0);
       LogStreamManager::instance()->logPktSendItem(
          m_sender->getNodeId(), m_sender->getLayerType(),
          *(m_signal->getPacketPtr()));
       assert(m_sender->m_transmittingTimer.get() != 0);
       assert(!m_sender->m_transmittingTimer->isRunning());
       // Start a timer so we know if the layer is in the process
       // of sending a packet.
       m_sender->m_transmittingTimer->reschedule(m_signal->getDuration());
       m_channelManager->recvSignal(m_sender, m_signal);
    }

 private:
    WirelessChannelManagerPtr m_channelManager;
    PhysicalLayerPtr m_sender;
    WirelessCommSignalPtr m_signal;
 };
 typedef boost::shared_ptr<SignalRecvEvent> SignalRecvEventPtr;

 #endif // PHYSICAL_LAYER_H