Attachment #1966 for bug #1774

View | Details | Raw Unified | Return to bug 1774
Collapse All | Expand All




    cls.add_method('CreateTxPowerSpectralDensity', 
                   'ns3::Ptr< ns3::SpectrumValue >', 
                   [param('double', 'txPower'), param('uint32_t', 'channel')])
    ## lr-wpan-spectrum-value-helper.h (module 'lr-wpan'): static double ns3::LrWpanSpectrumValueHelper::TotalAvgPower(ns3::Ptr<ns3::SpectrumValue const> psd, uint32_t channel) [member function]
    cls.add_method('TotalAvgPower', 
                   'double', 
                   [param('ns3::Ptr< ns3::SpectrumValue const >', 'psd'), param('uint32_t', 'channel')], 
                   is_static=True)
    return


def register_Ns3LrWpanHelper_methods(root_module, cls):
    ## lr-wpan-helper.h (module 'lr-wpan'): ns3::LrWpanHelper::LrWpanHelper() [constructor]
    cls.add_constructor([])
    ## lr-wpan-helper.h (module 'lr-wpan'): ns3::LrWpanHelper::LrWpanHelper(bool useMultiModelSpectrumChannel) [constructor]
    cls.add_constructor([param('bool', 'useMultiModelSpectrumChannel')])
    ## lr-wpan-helper.h (module 'lr-wpan'): ns3::Ptr<ns3::SpectrumChannel> ns3::LrWpanHelper::GetChannel() [member function]
    cls.add_method('GetChannel', 
                   'ns3::Ptr< ns3::SpectrumChannel >', 
                   [])
    ## lr-wpan-helper.h (module 'lr-wpan'): void ns3::LrWpanHelper::AddMobility(ns3::Ptr<ns3::LrWpanPhy> phy, ns3::Ptr<ns3::MobilityModel> m) [member function]
    cls.add_method('AddMobility', 
                   'void', 




    cls.add_method('CreateTxPowerSpectralDensity', 
                   'ns3::Ptr< ns3::SpectrumValue >', 
                   [param('double', 'txPower'), param('uint32_t', 'channel')])
    ## lr-wpan-spectrum-value-helper.h (module 'lr-wpan'): static double ns3::LrWpanSpectrumValueHelper::TotalAvgPower(ns3::Ptr<ns3::SpectrumValue const> psd, uint32_t channel) [member function]
    cls.add_method('TotalAvgPower', 
                   'double', 
                   [param('ns3::Ptr< ns3::SpectrumValue const >', 'psd'), param('uint32_t', 'channel')], 
                   is_static=True)
    return


def register_Ns3LrWpanHelper_methods(root_module, cls):
    ## lr-wpan-helper.h (module 'lr-wpan'): ns3::LrWpanHelper::LrWpanHelper() [constructor]
    cls.add_constructor([])
    ## lr-wpan-helper.h (module 'lr-wpan'): ns3::LrWpanHelper::LrWpanHelper(bool useMultiModelSpectrumChannel) [constructor]
    cls.add_constructor([param('bool', 'useMultiModelSpectrumChannel')])
    ## lr-wpan-helper.h (module 'lr-wpan'): ns3::Ptr<ns3::SpectrumChannel> ns3::LrWpanHelper::GetChannel() [member function]
    cls.add_method('GetChannel', 
                   'ns3::Ptr< ns3::SpectrumChannel >', 
                   [])
    ## lr-wpan-helper.h (module 'lr-wpan'): void ns3::LrWpanHelper::AddMobility(ns3::Ptr<ns3::LrWpanPhy> phy, ns3::Ptr<ns3::MobilityModel> m) [member function]
    cls.add_method('AddMobility', 
                   'void', 

(-)a/src/lr-wpan/examples/lr-wpan-error-distance-plot.cc (-1 / +2 lines)

Lines 37-42	Link Here

#include <ns3/node.h>

#include <ns3/node.h>

#include <ns3/net-device.h>

#include <ns3/net-device.h>

#include <ns3/single-model-spectrum-channel.h>

#include <ns3/single-model-spectrum-channel.h>

#include <ns3/multi-model-spectrum-channel.h>

#include <ns3/mac16-address.h>

#include <ns3/mac16-address.h>

#include <ns3/constant-position-mobility-model.h>

#include <ns3/constant-position-mobility-model.h>

#include <ns3/uinteger.h>

#include <ns3/uinteger.h>

Lines 95-101	Link Here

  Ptr<LrWpanNetDevice> dev1 = CreateObject<LrWpanNetDevice> ();

  Ptr<LrWpanNetDevice> dev1 = CreateObject<LrWpanNetDevice> ();

  dev0->SetAddress (Mac16Address ("00:01"));

  dev0->SetAddress (Mac16Address ("00:01"));

  dev1->SetAddress (Mac16Address ("00:02"));

  dev1->SetAddress (Mac16Address ("00:02"));

  Ptr<SingleModelSpectrumChannel> channel = CreateObject<SingleModelSpectrumChannel> ();

  Ptr<MultiModelSpectrumChannel> channel = CreateObject<MultiModelSpectrumChannel> ();

  Ptr<LogDistancePropagationLossModel> model = CreateObject<LogDistancePropagationLossModel> ();

100

  Ptr<LogDistancePropagationLossModel> model = CreateObject<LogDistancePropagationLossModel> ();

100

  channel->AddPropagationLossModel (model);

101

  channel->AddPropagationLossModel (model);

101

  dev0->SetChannel (channel);

102

  dev0->SetChannel (channel);




#include <ns3/lr-wpan-net-device.h>
#include <ns3/mobility-model.h>
#include <ns3/single-model-spectrum-channel.h>
#include <ns3/multi-model-spectrum-channel.h>
#include <ns3/propagation-loss-model.h>
#include <ns3/propagation-delay-model.h>
#include <ns3/log.h>
#include "ns3/names.h"

namespace ns3 {


LrWpanHelper::LrWpanHelper (void)
{
  m_channel = CreateObject<SingleModelSpectrumChannel> ();

  Ptr<LogDistancePropagationLossModel> lossModel = CreateObject<LogDistancePropagationLossModel> ();
  m_channel->AddPropagationLossModel (lossModel);

  Ptr<ConstantSpeedPropagationDelayModel> delayModel = CreateObject<ConstantSpeedPropagationDelayModel> ();
  m_channel->SetPropagationDelayModel (delayModel);
}

LrWpanHelper::LrWpanHelper (bool useMultiModelSpectrumChannel)
{
  if (useMultiModelSpectrumChannel)
    {
      m_channel = CreateObject<MultiModelSpectrumChannel> ();
    }
  else
    {
      m_channel = CreateObject<SingleModelSpectrumChannel> ();
    }
  Ptr<LogDistancePropagationLossModel> lossModel = CreateObject<LogDistancePropagationLossModel> ();
  m_channel->AddPropagationLossModel (lossModel);

  Ptr<ConstantSpeedPropagationDelayModel> delayModel = CreateObject<ConstantSpeedPropagationDelayModel> ();
  m_channel->SetPropagationDelayModel (delayModel);
}

LrWpanHelper::~LrWpanHelper (void)

  return devices;
}


Ptr<SpectrumChannel>
LrWpanHelper::GetChannel (void)
{
  return m_channel;
}

void
LrWpanHelper::SetChannel (Ptr<SpectrumChannel> channel)
{
  m_channel = channel;
}

void
LrWpanHelper::SetChannel (std::string channelName)
{
  Ptr<SpectrumChannel> channel = Names::Find<SpectrumChannel> (channelName);
  m_channel = channel;
}


int64_t
LrWpanHelper::AssignStreams (NetDeviceContainer c, int64_t stream)
{





namespace ns3 {

class SpectrumChannel;
class MobilityModel;

/**

   * \brief Create a LrWpan helper in an empty state.
   */
  LrWpanHelper (void);

  /**
   * \brief Create a LrWpan helper in an empty state with either a
   * SingleModelSpectrumChannel or a MultiModelSpectrumChannel.
   * \param useMultiModelSpectrumChannel use a MultiModelSpectrumChannel if true, a SingleModelSpectrumChannel otherwise
   */
  LrWpanHelper (bool useMultiModelSpectrumChannel);

  virtual ~LrWpanHelper (void);

  /**
   * \brief Get the channel associated to this helper
   * \returns the channel
   */
  Ptr<SpectrumChannel> GetChannel (void);

  /**
   * \brief Set the channel associated to this helper
   * \param channel the channel
   */
  void SetChannel (Ptr<SpectrumChannel> channel);

  /**
   * \brief Set the channel associated to this helper
   * \param channelName the channel name
   */
  void SetChannel (std::string channelName);

  /**
   * \brief Add mobility model to a physical device
   * \param phy the physical device
   * \param m the mobility model
   */
  void AddMobility (Ptr<LrWpanPhy> phy, Ptr<MobilityModel> m);

  /**

                                    bool explicitFilename);

private:
  Ptr<SpectrumChannel> m_channel; //!< channel to be used for the devices

};





  NS_LOG_FUNCTION (this << spectrumRxParams);
  LrWpanSpectrumValueHelper psdHelper;


  Ptr<LrWpanSpectrumSignalParameters> lrWpanRxParams = DynamicCast<LrWpanSpectrumSignalParameters> (spectrumRxParams);
  NS_ASSERT (lrWpanRxParams != 0);
  Ptr<Packet> p = (lrWpanRxParams->packetBurst->GetPackets ()).front ();
  NS_ASSERT (p != 0);

  if (!m_edRequest.IsExpired ())
    {
      // Update the average receive power during ED.
      Time now = Simulator::Now ();
      m_edPower.averagePower += LrWpanSpectrumValueHelper::TotalAvgPower (m_signal->GetSignalPsd (), m_phyPIBAttributes.phyCurrentChannel) * (now - m_edPower.lastUpdate).GetTimeStep () / m_edPower.measurementLength.GetTimeStep ();
      m_edPower.lastUpdate = now;
    }

  Ptr<LrWpanSpectrumSignalParameters> lrWpanRxParams = DynamicCast<LrWpanSpectrumSignalParameters> (spectrumRxParams);

  if ( lrWpanRxParams == 0)
    {
      CheckInterference ();
      m_signal->AddSignal (spectrumRxParams->psd);

      // Update peak power if CCA is in progress.
      if (!m_ccaRequest.IsExpired ())
        {
          double power = LrWpanSpectrumValueHelper::TotalAvgPower (m_signal->GetSignalPsd (), m_phyPIBAttributes.phyCurrentChannel);
          if (m_ccaPeakPower < power)
            {
              m_ccaPeakPower = power;
            }
        }

      Simulator::Schedule (spectrumRxParams->duration, &LrWpanPhy::EndRx, this, spectrumRxParams);
      return;
    }

  Ptr<Packet> p = (lrWpanRxParams->packetBurst->GetPackets ()).front ();
  NS_ASSERT (p != 0);

  // Prevent PHY from receiving another packet while switching the transceiver state.
  if (m_trxState == IEEE_802_15_4_PHY_RX_ON && !m_setTRXState.IsRunning ())
    {


      // Add any incoming packet to the current interference before checking the
      // SINR.
      NS_LOG_DEBUG (this << " receiving packet with power: " << 10 * log10(LrWpanSpectrumValueHelper::TotalAvgPower (lrWpanRxParams->psd, m_phyPIBAttributes.phyCurrentChannel)) + 30 << "dBm");
      m_signal->AddSignal (lrWpanRxParams->psd);
      Ptr<SpectrumValue> interferenceAndNoise = m_signal->GetSignalPsd ();
      *interferenceAndNoise -= *lrWpanRxParams->psd;
      *interferenceAndNoise += *m_noise;
      double sinr = LrWpanSpectrumValueHelper::TotalAvgPower (lrWpanRxParams->psd, m_phyPIBAttributes.phyCurrentChannel) / LrWpanSpectrumValueHelper::TotalAvgPower (interferenceAndNoise, m_phyPIBAttributes.phyCurrentChannel);

      // Std. 802.15.4-2006, appendix E, Figure E.2
      // At SNR < -5 the BER is less than 10e-1.

  // Update peak power if CCA is in progress.
  if (!m_ccaRequest.IsExpired ())
    {
      double power = LrWpanSpectrumValueHelper::TotalAvgPower (m_signal->GetSignalPsd (), m_phyPIBAttributes.phyCurrentChannel);
      if (m_ccaPeakPower < power)
        {
          m_ccaPeakPower = power;


  // Always call EndRx to update the interference.
  // \todo: Do we need to keep track of these events to unschedule them when disposing off the PHY?

  Simulator::Schedule (spectrumRxParams->duration, &LrWpanPhy::EndRx, this, spectrumRxParams);
}

void

          Ptr<SpectrumValue> interferenceAndNoise = m_signal->GetSignalPsd ();
          *interferenceAndNoise -= *currentRxParams->psd;
          *interferenceAndNoise += *m_noise;
          double sinr = LrWpanSpectrumValueHelper::TotalAvgPower (currentRxParams->psd, m_phyPIBAttributes.phyCurrentChannel) / LrWpanSpectrumValueHelper::TotalAvgPower (interferenceAndNoise, m_phyPIBAttributes.phyCurrentChannel);
          double per = 1.0 - m_errorModel->GetChunkSuccessRate (sinr, chunkSize);

          // The LQI is the total packet success rate scaled to 0-255.

}

void
LrWpanPhy::EndRx (Ptr<SpectrumSignalParameters> par)
{
  NS_LOG_FUNCTION (this);
  //NS_ASSERT (params != 0);

  Ptr<LrWpanSpectrumSignalParameters> params = DynamicCast<LrWpanSpectrumSignalParameters> (par);

  if (!m_edRequest.IsExpired ())
    {
      // Update the average receive power during ED.
      Time now = Simulator::Now ();
      m_edPower.averagePower += LrWpanSpectrumValueHelper::TotalAvgPower (m_signal->GetSignalPsd (), m_phyPIBAttributes.phyCurrentChannel) * (now - m_edPower.lastUpdate).GetTimeStep () / m_edPower.measurementLength.GetTimeStep ();
      m_edPower.lastUpdate = now;
    }

  CheckInterference ();

  // Update the interference.
  m_signal->RemoveSignal (par->psd);

  if (params == 0)
    {
      NS_LOG_LOGIC ("Node: " << m_device->GetAddress() << " Removing interferent: " << *(par->psd));
      return;
    }

  // If this is the end of the currently received packet, check if reception was successful.
  Ptr<LrWpanSpectrumSignalParameters> currentRxParams = m_currentRxPacket.first;
  if (currentRxParams == params)
    {

{
  NS_LOG_FUNCTION (this);

  m_edPower.averagePower += LrWpanSpectrumValueHelper::TotalAvgPower (m_signal->GetSignalPsd (), m_phyPIBAttributes.phyCurrentChannel) * (Simulator::Now () - m_edPower.lastUpdate).GetTimeStep () / m_edPower.measurementLength.GetTimeStep ();

  uint8_t energyLevel;


  LrWpanPhyEnumeration sensedChannelState = IEEE_802_15_4_PHY_UNSPECIFIED;

  // Update peak power.
  double power = LrWpanSpectrumValueHelper::TotalAvgPower (m_signal->GetSignalPsd (), m_phyPIBAttributes.phyCurrentChannel);
  if (m_ccaPeakPower < power)
    {
      m_ccaPeakPower = power;

(-)a/src/lr-wpan/model/lr-wpan-phy.h (-1 / +1 lines)

Lines 499-505	Link Here

499

500

   * \param params signal parameters of the packet

500

   * \param params signal parameters of the packet

501

*/

501

*/

502

  void EndRx (Ptr<LrWpanSpectrumSignalParameters> params);

502

  void EndRx (Ptr<SpectrumSignalParameters> params);

503

504

/**

504

/**

505

   * Cancel an ongoing ED procedure. This is called when the transceiver is

505

   * Cancel an ongoing ED procedure. This is called when the transceiver is




    g_LrWpanSpectrumModel = Create<SpectrumModel> (bands);
  }

} g_LrWpanSpectrumModelInitializerInstance; //!< Global object used to initialize the LrWpan Spectrum Model

LrWpanSpectrumValueHelper::LrWpanSpectrumValueHelper (void)
{

}

double
LrWpanSpectrumValueHelper::TotalAvgPower (Ptr<const SpectrumValue> psd, uint32_t channel)
{
  NS_LOG_FUNCTION (psd);
  double totalAvgPower = 0.0;

  NS_ASSERT (psd->GetSpectrumModel () == g_LrWpanSpectrumModel);
  // 1 MHz resolution from 2400 to 2483 MHz (center freq)

  // numerically integrate to get area under psd using 1 MHz resolution

  totalAvgPower += (*psd)[2405 + 5 * (channel - 11) - 2400 - 2];
  totalAvgPower += (*psd)[2405 + 5 * (channel - 11) - 2400 - 1];
  totalAvgPower += (*psd)[2405 + 5 * (channel - 11) - 2400];
  totalAvgPower += (*psd)[2405 + 5 * (channel - 11) - 2400 + 1];
  totalAvgPower += (*psd)[2405 + 5 * (channel - 11) - 2400 + 2];
  totalAvgPower *= 1.0e6;

  return totalAvgPower;
}





  Ptr<SpectrumValue> CreateNoisePowerSpectralDensity (uint32_t channel);

  /**
   * \brief total average power of the signal is the integral of the PSD using
   * the limits of the given channel
   * \param psd spectral density
   * \param channel the channel number per IEEE802.15.4
   * \return total power (using composite trap. rule to numerally integrate)
   */
  static double TotalAvgPower (Ptr<const SpectrumValue> psd, uint32_t channel);

private:
  /**

(-)a/src/lr-wpan/test/lr-wpan-spectrum-value-helper-test.cc (-1 / +1 lines)

Lines 59-65	Link Here

          value = helper.CreateTxPowerSpectralDensity (pwrdBm, chan);

          value = helper.CreateTxPowerSpectralDensity (pwrdBm, chan);

          pwrWatts = pow (10.0, pwrdBm / 10.0) / 1000;

          pwrWatts = pow (10.0, pwrdBm / 10.0) / 1000;

          // Test that average power calculation is within +/- 25% of expected

          // Test that average power calculation is within +/- 25% of expected

          NS_TEST_ASSERT_MSG_EQ_TOL (helper.TotalAvgPower (value), pwrWatts, pwrWatts / 4.0, "Not equal for channel " << chan << " pwrdBm " << pwrdBm);

          NS_TEST_ASSERT_MSG_EQ_TOL (helper.TotalAvgPower (value, chan), pwrWatts, pwrWatts / 4.0, "Not equal for channel " << chan << " pwrdBm " << pwrdBm);

Return to bug 1774