physical_layer.hpp

#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

---