Attachment #2671 for bug #2552

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




#include "ns3/log.h"
#include "ns3/double.h"
#include "ns3/boolean.h"
#include "ampdu-tag.h"
#include "wifi-spectrum-signal-parameters.h"
#include "wifi-phy-tag.h"
#include "ns3/antenna-model.h"
#include "wifi-utils.h"

namespace ns3 {


    }
}

bool
SpectrumWifiPhy::DoChannelSwitch (uint16_t nch)
{
  if (IsInitialized () == false)
    {
      //this is not channel switch, this is initialization
      NS_LOG_DEBUG ("start at channel " << nch);
      return true;
    }

  NS_ASSERT (!IsStateSwitching ());
  switch (m_state->GetState ())
    {
    case SpectrumWifiPhy::RX:
      NS_LOG_DEBUG ("drop packet because of channel switching while reception");
      m_endPlcpRxEvent.Cancel ();
      m_endRxEvent.Cancel ();
      goto switchChannel;
      break;
    case SpectrumWifiPhy::TX:
      NS_LOG_DEBUG ("channel switching postponed until end of current transmission");
      Simulator::Schedule (GetDelayUntilIdle (), &WifiPhy::SetChannelNumber, this, nch);
      break;
    case SpectrumWifiPhy::CCA_BUSY:
    case SpectrumWifiPhy::IDLE:
      goto switchChannel;
      break;
    case SpectrumWifiPhy::SLEEP:
      NS_LOG_DEBUG ("channel switching ignored in sleep mode");
      break;
    default:
      NS_ASSERT (false);
      break;
    }

  return false;

switchChannel:

  NS_LOG_DEBUG ("switching channel " << GetChannelNumber () << " -> " << nch);
  m_rxSpectrumModel = WifiSpectrumValueHelper::GetSpectrumModel (GetFrequency (), GetChannelWidth ());
  m_state->SwitchToChannelSwitching (GetChannelSwitchDelay ());
  m_interference.EraseEvents ();
  /*
   * Needed here to be able to correctly sensed the medium for the first
   * time after the switching. The actual switching is not performed until
   * after m_channelSwitchDelay. Packets received during the switching
   * state are added to the event list and are employed later to figure
   * out the state of the medium after the switching.
   */
  return true;
}

bool
SpectrumWifiPhy::DoFrequencySwitch (uint32_t frequency)
{
  if (IsInitialized () == false)
    {
      //this is not channel switch, this is initialization
      NS_LOG_DEBUG ("start at frequency " << frequency);
      return true;
    }

  NS_ASSERT (!IsStateSwitching ());
  switch (m_state->GetState ())
    {
    case SpectrumWifiPhy::RX:
      NS_LOG_DEBUG ("drop packet because of channel/frequency switching while reception");
      m_endPlcpRxEvent.Cancel ();
      m_endRxEvent.Cancel ();
      goto switchFrequency;
      break;
    case SpectrumWifiPhy::TX:
      NS_LOG_DEBUG ("channel/frequency switching postponed until end of current transmission");
      Simulator::Schedule (GetDelayUntilIdle (), &WifiPhy::SetFrequency, this, frequency);
      break;
    case SpectrumWifiPhy::CCA_BUSY:
    case SpectrumWifiPhy::IDLE:
      goto switchFrequency;
      break;
    case SpectrumWifiPhy::SLEEP:
      NS_LOG_DEBUG ("frequency switching ignored in sleep mode");
      break;
    default:
      NS_ASSERT (false);
      break;
    }

  return false;

switchFrequency:

  NS_LOG_DEBUG ("switching frequency " << GetFrequency () << " -> " << frequency);
  m_rxSpectrumModel = WifiSpectrumValueHelper::GetSpectrumModel (GetFrequency (), GetChannelWidth ());
  m_state->SwitchToChannelSwitching (GetChannelSwitchDelay ());
  m_interference.EraseEvents ();
  /*
   * Needed here to be able to correctly sensed the medium for the first
   * time after the switching. The actual switching is not performed until
   * after m_channelSwitchDelay. Packets received during the switching
   * state are added to the event list and are employed later to figure
   * out the state of the medium after the switching.
   */
  return true;
}

Ptr<const SpectrumModel>
SpectrumWifiPhy::GetRxSpectrumModel () const
{

}

void
SpectrumWifiPhy::SetPacketReceivedCallback (RxCallback callback)
{
  m_rxCallback = callback;
}

void
SpectrumWifiPhy::AddOperationalChannel (uint16_t channelNumber)
{
  m_operationalChannelList.push_back (channelNumber);

}

void
SpectrumWifiPhy::SetSleepMode (void)
{
  NS_LOG_FUNCTION (this);
  switch (m_state->GetState ())
    {
    case SpectrumWifiPhy::TX:
      NS_LOG_DEBUG ("setting sleep mode postponed until end of current transmission");
      Simulator::Schedule (GetDelayUntilIdle (), &SpectrumWifiPhy::SetSleepMode, this);
      break;
    case SpectrumWifiPhy::RX:
      NS_LOG_DEBUG ("setting sleep mode postponed until end of current reception");
      Simulator::Schedule (GetDelayUntilIdle (), &SpectrumWifiPhy::SetSleepMode, this);
      break;
    case SpectrumWifiPhy::SWITCHING:
      NS_LOG_DEBUG ("setting sleep mode postponed until end of channel switching");
      Simulator::Schedule (GetDelayUntilIdle (), &SpectrumWifiPhy::SetSleepMode, this);
      break;
    case SpectrumWifiPhy::CCA_BUSY:
    case SpectrumWifiPhy::IDLE:
      NS_LOG_DEBUG ("setting sleep mode");
      m_state->SwitchToSleep ();
      break;
    case SpectrumWifiPhy::SLEEP:
      NS_LOG_DEBUG ("already in sleep mode");
      break;
    default:
      NS_ASSERT (false);
      break;
    }
}

void
SpectrumWifiPhy::ResumeFromSleep (void)
{
  NS_LOG_FUNCTION (this);
  switch (m_state->GetState ())
    {
    case SpectrumWifiPhy::TX:
    case SpectrumWifiPhy::RX:
    case SpectrumWifiPhy::IDLE:
    case SpectrumWifiPhy::CCA_BUSY:
    case SpectrumWifiPhy::SWITCHING:
      {
        NS_LOG_DEBUG ("not in sleep mode, there is nothing to resume");
        break;
      }
    case SpectrumWifiPhy::SLEEP:
      {
        NS_LOG_DEBUG ("resuming from sleep mode");
        Time delayUntilCcaEnd = m_interference.GetEnergyDuration (DbmToW (GetCcaMode1Threshold ()));
        m_state->SwitchFromSleep (delayUntilCcaEnd);
        break;
      }
    default:
      {
        NS_ASSERT (false);
        break;
      }
    }
}

void
SpectrumWifiPhy::SetReceiveOkCallback (RxOkCallback callback)
{
  m_state->SetReceiveOkCallback (callback);
}

void
SpectrumWifiPhy::SetReceiveErrorCallback (RxErrorCallback callback)
{
  m_state->SetReceiveErrorCallback (callback);
}

void
SpectrumWifiPhy::StartRx (Ptr<SpectrumSignalParameters> rxParams)
{
  NS_LOG_FUNCTION (this << rxParams);


  NS_LOG_INFO ("Received Wi-Fi signal");
  Ptr<Packet> packet = wifiRxParams->packet->Copy ();
  StartReceivePreambleAndHeader (packet, rxPowerW, rxDuration);
  bool found = packet->PeekPacketTag (tag);
  if (!found)
    {
      NS_FATAL_ERROR ("Received Wi-Fi Spectrum Signal with no WifiPhyTag");
      return;
    }
    
  WifiTxVector txVector = tag.GetWifiTxVector ();

  if (txVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_HT
      && (txVector.GetNss () != (1 + (txVector.GetMode ().GetMcsValue () / 8))))
    {
      NS_FATAL_ERROR ("MCS value does not match NSS value: MCS = " << (uint16_t)txVector.GetMode ().GetMcsValue () << ", NSS = " << (uint16_t)txVector.GetNss ());
    }

  if (txVector.GetNss () > GetMaxSupportedRxSpatialStreams ())
    {
      NS_FATAL_ERROR ("Reception ends in failure because of an unsupported number of spatial streams");
    }

  WifiPreamble preamble = txVector.GetPreambleType ();
  MpduType mpdutype = tag.GetMpduType ();

  // At this point forward, processing parallels that of
  // YansWifiPhy::StartReceivePreambleAndHeader ()

  AmpduTag ampduTag;
  Time endRx = Simulator::Now () + rxDuration;
  Time preambleAndHeaderDuration = CalculatePlcpPreambleAndHeaderDuration (txVector);

  Ptr<InterferenceHelper::Event> event;
  event = m_interference.Add (packet->GetSize (),
                              txVector,
                              rxDuration,
                              rxPowerW);

  switch (m_state->GetState ())
    {
    case SpectrumWifiPhy::SWITCHING:
      NS_LOG_DEBUG ("drop packet because of channel switching");
      NotifyRxDrop (packet);
      m_plcpSuccess = false;
      /*
       * Packets received on the upcoming channel are added to the event list
       * during the switching state. This way the medium can be correctly sensed
       * when the device listens to the channel for the first time after the
       * switching e.g. after channel switching, the channel may be sensed as
       * busy due to other devices' tramissions started before the end of
       * the switching.
       */
      if (endRx > Simulator::Now () + m_state->GetDelayUntilIdle ())
        {
          //that packet will be noise _after_ the completion of the
          //channel switching.
          SwitchMaybeToCcaBusy ();
          return;
        }
      break;
    case SpectrumWifiPhy::RX:
      NS_LOG_DEBUG ("drop packet because already in Rx (power=" <<
                    rxPowerW << "W)");
      NotifyRxDrop (packet);
      if (endRx > Simulator::Now () + m_state->GetDelayUntilIdle ())
        {
          //that packet will be noise _after_ the reception of the
          //currently-received packet.
          SwitchMaybeToCcaBusy ();
          return;
        }
      break;
    case SpectrumWifiPhy::TX:
      NS_LOG_DEBUG ("drop packet because already in Tx (power=" <<
                    rxPowerW << "W)");
      NotifyRxDrop (packet);
      if (endRx > Simulator::Now () + m_state->GetDelayUntilIdle ())
        {
          //that packet will be noise _after_ the transmission of the
          //currently-transmitted packet.
          SwitchMaybeToCcaBusy ();
          return;
        }
      break;
    case SpectrumWifiPhy::CCA_BUSY:
    case SpectrumWifiPhy::IDLE:
      if (rxPowerW > GetEdThresholdW ()) //checked here, no need to check in the payload reception (current implementation assumes constant rx power over the packet duration)
        {
          if (preamble == WIFI_PREAMBLE_NONE && m_mpdusNum == 0)
            {
              NS_LOG_DEBUG ("drop packet because no preamble has been received");
              NotifyRxDrop (packet);
              SwitchMaybeToCcaBusy ();
              return;
            }
          else if (preamble == WIFI_PREAMBLE_NONE && m_plcpSuccess == false) //A-MPDU reception fails
            {
              NS_LOG_DEBUG ("Drop MPDU because no plcp has been received");
              NotifyRxDrop (packet);
              SwitchMaybeToCcaBusy ();
              return;
            }
          else if (preamble != WIFI_PREAMBLE_NONE && packet->PeekPacketTag (ampduTag) && m_mpdusNum == 0)
            {
              //received the first MPDU in an MPDU
              m_mpdusNum = ampduTag.GetRemainingNbOfMpdus () - 1;
              m_rxMpduReferenceNumber++;
            }
          else if (preamble == WIFI_PREAMBLE_NONE && packet->PeekPacketTag (ampduTag) && m_mpdusNum > 0)
            {
              //received the other MPDUs that are part of the A-MPDU
              if (ampduTag.GetRemainingNbOfMpdus () < m_mpdusNum)
                {
                  NS_LOG_DEBUG ("Missing MPDU from the A-MPDU " << m_mpdusNum - ampduTag.GetRemainingNbOfMpdus ());
                  m_mpdusNum = ampduTag.GetRemainingNbOfMpdus ();
                }
              else
                {
                  m_mpdusNum--;
                }
            }
          else if (preamble != WIFI_PREAMBLE_NONE && m_mpdusNum > 0 )
            {
              NS_LOG_DEBUG ("Didn't receive the last MPDUs from an A-MPDU " << m_mpdusNum);
              m_mpdusNum = 0;
            }

          NS_LOG_DEBUG ("sync to signal (power=" << rxPowerW << "W)");
          //sync to signal
          m_state->SwitchToRx (rxDuration);
          NS_ASSERT (m_endPlcpRxEvent.IsExpired ());
          NotifyRxBegin (packet);
          m_interference.NotifyRxStart ();

          if (preamble != WIFI_PREAMBLE_NONE)
            {
              NS_ASSERT (m_endPlcpRxEvent.IsExpired ());
              m_endPlcpRxEvent = Simulator::Schedule (preambleAndHeaderDuration, &SpectrumWifiPhy::StartReceivePacket, this,
                                                      packet, txVector, mpdutype, event);
            }

          NS_ASSERT (m_endRxEvent.IsExpired ());
          m_endRxEvent = Simulator::Schedule (rxDuration, &SpectrumWifiPhy::EndReceive, this,
                                              packet, preamble, mpdutype, event);
        }
      else
        {
          NS_LOG_DEBUG ("drop packet because signal power too Small (" <<
                        rxPowerW << "<" << GetEdThresholdW () << ")");
          NotifyRxDrop (packet);
          m_plcpSuccess = false;
          SwitchMaybeToCcaBusy ();
          return;
        }
      break;
    case SpectrumWifiPhy::SLEEP:
      NS_LOG_DEBUG ("drop packet because in sleep mode");
      NotifyRxDrop (packet);
      m_plcpSuccess = false;
      break;
    }

  return;
}

void
SpectrumWifiPhy::StartReceivePacket (Ptr<Packet> packet,
                                     WifiTxVector txVector,
                                     MpduType mpdutype,
                                     Ptr<InterferenceHelper::Event> event)
{
  NS_LOG_FUNCTION (this << packet << txVector.GetMode () << txVector.GetPreambleType () << (uint32_t)mpdutype);
  NS_ASSERT (IsStateRx ());
  NS_ASSERT (m_endPlcpRxEvent.IsExpired ());
  AmpduTag ampduTag;
  WifiMode txMode = txVector.GetMode ();

  InterferenceHelper::SnrPer snrPer;
  snrPer = m_interference.CalculatePlcpHeaderSnrPer (event);

  NS_LOG_DEBUG ("snr(dB)=" << RatioToDb (snrPer.snr) << ", per=" << snrPer.per);

  if (m_random->GetValue () > snrPer.per) //plcp reception succeeded
    {
      if (IsModeSupported (txMode) || IsMcsSupported (txMode))
        {
          NS_LOG_DEBUG ("receiving plcp payload"); //endReceive is already scheduled
          m_plcpSuccess = true;
        }
      else //mode is not allowed
        {
          NS_LOG_DEBUG ("drop packet because it was sent using an unsupported mode (" << txMode << ")");
          NotifyRxDrop (packet);
          m_plcpSuccess = false;
        }
    }
  else //plcp reception failed
    {
      NS_LOG_DEBUG ("drop packet because plcp preamble/header reception failed");
      NotifyRxDrop (packet);
      m_plcpSuccess = false;
    }
}

Ptr<WifiSpectrumPhyInterface>

}

void
SpectrumWifiPhy::StartTx (Ptr<Packet> packet, WifiTxVector txVector, Time txDuration)
{
  NS_LOG_DEBUG ("Start transmission: signal power before antenna gain=" << GetPowerDbm (txVector.GetTxPowerLevel ()) << "dBm");
                        << txVector.GetMode ().GetDataRate (txVector)
                        << txVector.GetPreambleType ()
                        << (uint32_t)txVector.GetTxPowerLevel ()
                        << (uint32_t)mpdutype);
  /* Transmission can happen if:
   *  - we are syncing on a packet. It is the responsability of the
   *    MAC layer to avoid doing this but the PHY does nothing to
   *    prevent it.
   *  - we are idle
   */
  NS_ASSERT (!m_state->IsStateTx () && !m_state->IsStateSwitching ());
  
  if (txVector.GetNss () > GetMaxSupportedTxSpatialStreams ())
    {
      NS_FATAL_ERROR ("Unsupported number of spatial streams!");
    }

  if (m_state->IsStateSleep ())
    {
      NS_LOG_DEBUG ("Dropping packet because in sleep mode");
      NotifyTxDrop (packet);
      return;
    }

  Time txDuration = CalculateTxDuration (packet->GetSize (), txVector, GetFrequency (), mpdutype, 1);
  NS_ASSERT (txDuration > NanoSeconds (0));

  if (m_state->IsStateRx ())
    {
      m_endPlcpRxEvent.Cancel ();
      m_endRxEvent.Cancel ();
      m_interference.NotifyRxEnd ();
    }
  NotifyTxBegin (packet);
  if ((mpdutype == MPDU_IN_AGGREGATE) && (txVector.GetPreambleType () != WIFI_PREAMBLE_NONE))
    {
      //send the first MPDU in an MPDU
      m_txMpduReferenceNumber++;
    }
  MpduInfo aMpdu;
  aMpdu.type = mpdutype;
  aMpdu.mpduRefNumber = m_txMpduReferenceNumber;
  NotifyMonitorSniffTx (packet, (uint16_t) GetFrequency (), GetChannelNumber (), txVector, aMpdu);
  m_state->SwitchToTx (txDuration, packet, GetPowerDbm (txVector.GetTxPowerLevel ()), txVector);
  //
  // Spectrum elements added here
  //
  Ptr<Packet> newPacket = packet->Copy (); // obtain non-const Packet
  WifiPhyTag oldtag;
  newPacket->RemovePacketTag (oldtag);
  WifiPhyTag tag (txVector, mpdutype);
  newPacket->AddPacketTag (tag);

  NS_LOG_DEBUG ("Transmission signal power before antenna gain: " << GetPowerDbm (txVector.GetTxPowerLevel ()) << " dBm");
  double txPowerWatts = DbmToW (GetPowerDbm (txVector.GetTxPowerLevel ()) + GetTxGain ());

  Ptr<SpectrumValue> txPowerSpectrum = GetTxPowerSpectralDensity (GetFrequency (), GetChannelWidth (), txPowerWatts);
  Ptr<WifiSpectrumSignalParameters> txParams = Create<WifiSpectrumSignalParameters> ();
  txParams->duration = txDuration;

  NS_ASSERT_MSG (m_wifiSpectrumPhyInterface, "SpectrumPhy() is not set; maybe forgot to call CreateWifiSpectrumPhyInterface?");
  txParams->txPhy = m_wifiSpectrumPhyInterface->GetObject<SpectrumPhy> ();
  txParams->txAntenna = m_antenna;
  txParams->packet = packet;
  NS_LOG_DEBUG ("Starting transmission with power " << WToDbm (txPowerWatts) << " dBm on channel " << GetChannelNumber ());
  NS_LOG_DEBUG ("Starting transmission with integrated spectrum power " << WToDbm (Integral (*txPowerSpectrum)) << " dBm; spectrum model Uid: " << txPowerSpectrum->GetSpectrumModel ()->GetUid ());
  m_channel->StartTx (txParams);
}

void
SpectrumWifiPhy::RegisterListener (WifiPhyListener *listener)
{
  m_state->RegisterListener (listener);
}

void
SpectrumWifiPhy::UnregisterListener (WifiPhyListener *listener)
{
  m_state->UnregisterListener (listener);
}

void
SpectrumWifiPhy::EndReceive (Ptr<Packet> packet, WifiPreamble preamble, MpduType mpdutype, Ptr<InterferenceHelper::Event> event)
{
  NS_LOG_FUNCTION (this << packet << event);
  NS_ASSERT (IsStateRx ());
  NS_ASSERT (event->GetEndTime () == Simulator::Now ());

  InterferenceHelper::SnrPer snrPer;
  snrPer = m_interference.CalculatePlcpPayloadSnrPer (event);
  m_interference.NotifyRxEnd ();
  bool rxSucceeded;

  if (m_plcpSuccess == true)
    {
      NS_LOG_DEBUG ("mode=" << (event->GetPayloadMode ().GetDataRate (event->GetTxVector ())) <<
                    ", snr(dB)=" << RatioToDb (snrPer.snr) << ", per=" << snrPer.per << ", size=" << packet->GetSize ());

      if (m_random->GetValue () > snrPer.per)
        {
          NotifyRxEnd (packet);
          SignalNoiseDbm signalNoise;
          signalNoise.signal = RatioToDb (event->GetRxPowerW ()) + 30;
          signalNoise.noise = RatioToDb (event->GetRxPowerW () / snrPer.snr) - GetRxNoiseFigure () + 30;
          MpduInfo aMpdu;
          aMpdu.type = mpdutype;
          aMpdu.mpduRefNumber = m_rxMpduReferenceNumber;
          NotifyMonitorSniffRx (packet, (uint16_t) GetFrequency (), GetChannelNumber (), event->GetTxVector (), aMpdu, signalNoise);
          m_state->SwitchFromRxEndOk (packet, snrPer.snr, event->GetTxVector ());
          rxSucceeded = true;
        }
      else
        {
          /* failure. */
          NotifyRxDrop (packet);
          m_state->SwitchFromRxEndError (packet, snrPer.snr);
          rxSucceeded = false;
        }
      if (!m_rxCallback.IsNull ())
        {
          m_rxCallback (rxSucceeded);
        }
    }
  else
    {
      m_state->SwitchFromRxEndError (packet, snrPer.snr);
      if (!m_rxCallback.IsNull ())
        {
          m_rxCallback (false);
        }
    }

  if (preamble == WIFI_PREAMBLE_NONE && mpdutype == LAST_MPDU_IN_AGGREGATE)
    {
      m_plcpSuccess = false;
    }

}

} //namespace ns3




  void ClearOperationalChannelList (void);

  /**
   * Starting receiving the payload of a packet (i.e. the first bit of the packet has arrived).
   *
   * \param packet the arriving packet
   * \param txVector the TXVECTOR of the arriving packet
   * \param mpdutype the type of the MPDU as defined in WifiPhy::MpduType.
   * \param event the corresponding event of the first time the packet arrives
   */
  void StartReceivePacket (Ptr<Packet> packet,
                           WifiTxVector txVector,
                           MpduType mpdutype,
                           Ptr<InterferenceHelper::Event> event);

  /**
   * Input method for delivering a signal from the spectrum channel
   * and low-level Phy interface to this SpectrumWifiPhy instance.
   *
   * \param rxParams Input signal parameters
   */
  void StartRx (Ptr<SpectrumSignalParameters> rxParams);
  
  /**
   * \param packet the packet to send
   * \param txVector the TXVECTOR that has tx parameters such as mode, the transmission mode to use to send
   *        this packet, and txPowerLevel, a power level to use to send this packet. The real transmission
   *        power is calculated as txPowerMin + txPowerLevel * (txPowerMax - txPowerMin) / nTxLevels
   * \param txDuration duration of the transmission.
   */
  void StartTx (Ptr<Packet> packet, WifiTxVector txVector, Time txDuration);
  
  /**
   * Method to encapsulate the creation of the WifiSpectrumPhyInterface
   * object (used to bind the WifiSpectrumPhy to a SpectrumChannel) and

   * returned, it means that any model will be accepted.
   */
  Ptr<const SpectrumModel> GetRxSpectrumModel () const;
  /**
   * Callback invoked at the end of a frame reception, to notify whether
   * the frame was received successfully (true) or not (false)
   */
  typedef Callback<void,bool> RxCallback;
  /**
   * Set the packet received callback (invoked at the end of a frame
   * reception), to notify whether the frame was received successfully
   * or not.
   *
   * \param callback the function to hook to the callback
   */
  void SetPacketReceivedCallback (RxCallback callback);

  /**
   * Callback invoked when the Phy model starts to process a signal

   */
  typedef void (* SignalArrivalCallback) (bool signalType, uint32_t senderNodeId, double rxPower, Time duration);

  virtual void SetReceiveOkCallback (WifiPhy::RxOkCallback callback);
  virtual void SetReceiveErrorCallback (WifiPhy::RxErrorCallback callback);
  virtual void SendPacket (Ptr<const Packet> packet, WifiTxVector txVector, MpduType mpdutype = NORMAL_MPDU);
  virtual void RegisterListener (WifiPhyListener *listener);
  virtual void UnregisterListener (WifiPhyListener *listener);
  virtual void SetSleepMode (void);
  virtual void ResumeFromSleep (void);
  virtual Ptr<WifiChannel> GetChannel (void) const;


protected:
  // Inherited
  virtual void DoDispose (void);
  virtual void DoInitialize (void);

  virtual bool DoFrequencySwitch (uint32_t frequency);

private:
  /**
   * The last bit of the packet has arrived.
   *
   * \param packet the packet that the last bit has arrived
   * \param preamble the preamble of the arriving packet
   * \param mpdutype the type of the MPDU as defined in WifiPhy::MpduType.
   * \param event the corresponding event of the first time the packet arrives
   */
  void EndReceive (Ptr<Packet> packet, WifiPreamble preamble, MpduType mpdutype, Ptr<InterferenceHelper::Event> event);

  /**
   * \param centerFrequency center frequency (MHz)
   * \param channelWidth channel width (MHz) of the channel
   * \param txPowerW power in W to spread across the bands

  Ptr<WifiSpectrumPhyInterface> m_wifiSpectrumPhyInterface;
  Ptr<AntennaModel> m_antenna;
  mutable Ptr<const SpectrumModel> m_rxSpectrumModel;
  RxCallback m_rxCallback;
  bool m_disableWifiReception;          //!< forces this Phy to fail to sync on any signal
  TracedCallback<bool, uint32_t, double, Time> m_signalCb;


(-)a/src/wifi/model/wifi-phy.cc (-27 / +498 lines)

Lines 34-40	Link Here

#include "ns3/pointer.h"

#include "ns3/pointer.h"

#include "ns3/trace-source-accessor.h"

#include "ns3/trace-source-accessor.h"

#include "ns3/fatal-error.h"

#include "ns3/fatal-error.h"

#include <cmath>

#include "wifi-phy-tag.h"

#include "ampdu-tag.h"

#include "wifi-utils.h"

namespace ns3 {

namespace ns3 {

Lines 416-421	Link Here

416

418

417

419

418

void

420

void

421

WifiPhy::SetReceiveOkCallback (RxOkCallback callback)

422

423

  m_state->SetReceiveOkCallback (callback);

424

425

426

void

427

WifiPhy::SetReceiveErrorCallback (RxErrorCallback callback)

428

429

  m_state->SetReceiveErrorCallback (callback);

430

431

432

void

433

WifiPhy::RegisterListener (WifiPhyListener *listener)

434

435

  m_state->RegisterListener (listener);

436

437

438

void

439

WifiPhy::UnregisterListener (WifiPhyListener *listener)

440

441

  m_state->UnregisterListener (listener);

442

443

444

void

419

WifiPhy::InitializeFrequencyChannelNumber (void)

445

WifiPhy::InitializeFrequencyChannelNumber (void)

420

446

421

  NS_LOG_FUNCTION (this);

447

  NS_LOG_FUNCTION (this);

Lines 1364-1378	Link Here

1364

bool

1390

bool

1365

WifiPhy::DoChannelSwitch (uint16_t nch)

1391

WifiPhy::DoChannelSwitch (uint16_t nch)

1366

1392

1393

  if (!IsInitialized ())

1394

1395

      //this is not channel switch, this is initialization

1396

      NS_LOG_DEBUG ("initialize to channel " << nch);

1397

      return true;

1398

1399

1400

  NS_ASSERT (!IsStateSwitching ());

1401

  switch (m_state->GetState ())

1402

1403

    case WifiPhy::RX:

1404

      NS_LOG_DEBUG ("drop packet because of channel switching while reception");

1405

      m_endPlcpRxEvent.Cancel ();

1406

      m_endRxEvent.Cancel ();

1407

      goto switchChannel;

1408

      break;

1409

    case WifiPhy::TX:

1410

      NS_LOG_DEBUG ("channel switching postponed until end of current transmission");

1411

      Simulator::Schedule (GetDelayUntilIdle (), &WifiPhy::SetChannelNumber, this, nch);

1412

      break;

1413

    case WifiPhy::CCA_BUSY:

1414

    case WifiPhy::IDLE:

1415

      goto switchChannel;

1416

      break;

1417

    case WifiPhy::SLEEP:

1418

      NS_LOG_DEBUG ("channel switching ignored in sleep mode");

1419

      break;

1420

    default:

1421

      NS_ASSERT (false);

1422

      break;

1423

1424

1425

  return false;

1426

1427

switchChannel:

1428

1429

  NS_LOG_DEBUG ("switching channel " << GetChannelNumber () << " -> " << nch);

1430

  m_state->SwitchToChannelSwitching (GetChannelSwitchDelay ());

1431

  m_interference.EraseEvents ();

1432

/*

1433

   * Needed here to be able to correctly sensed the medium for the first

1434

   * time after the switching. The actual switching is not performed until

1435

   * after m_channelSwitchDelay. Packets received during the switching

1436

   * state are added to the event list and are employed later to figure

1437

   * out the state of the medium after the switching.

1438

*/

1367

  return true;

1439

  return true;

1368

1440

1369

1441

1370

bool

1442

bool

1371

WifiPhy::DoFrequencySwitch (uint32_t frequency)

1443

WifiPhy::DoFrequencySwitch (uint32_t frequency)

1372

1444

1445

  if (!IsInitialized ())

1446

1447

      //this is not channel switch, this is initialization

1448

      NS_LOG_DEBUG ("start at frequency " << frequency);

1449

      return true;

1450

1451

1452

  NS_ASSERT (!IsStateSwitching ());

1453

  switch (m_state->GetState ())

1454

1455

    case WifiPhy::RX:

1456

      NS_LOG_DEBUG ("drop packet because of channel/frequency switching while reception");

1457

      m_endPlcpRxEvent.Cancel ();

1458

      m_endRxEvent.Cancel ();

1459

      goto switchFrequency;

1460

      break;

1461

    case WifiPhy::TX:

1462

      NS_LOG_DEBUG ("channel/frequency switching postponed until end of current transmission");

1463

      Simulator::Schedule (GetDelayUntilIdle (), &WifiPhy::SetFrequency, this, frequency);

1464

      break;

1465

    case WifiPhy::CCA_BUSY:

1466

    case WifiPhy::IDLE:

1467

      goto switchFrequency;

1468

      break;

1469

    case WifiPhy::SLEEP:

1470

      NS_LOG_DEBUG ("frequency switching ignored in sleep mode");

1471

      break;

1472

    default:

1473

      NS_ASSERT (false);

1474

      break;

1475

1476

1477

  return false;

1478

1479

switchFrequency:

1480

1481

  NS_LOG_DEBUG ("switching frequency " << GetFrequency () << " -> " << frequency);

1482

  m_state->SwitchToChannelSwitching (GetChannelSwitchDelay ());

1483

  m_interference.EraseEvents ();

1484

/*

1485

   * Needed here to be able to correctly sensed the medium for the first

1486

   * time after the switching. The actual switching is not performed until

1487

   * after m_channelSwitchDelay. Packets received during the switching

1488

   * state are added to the event list and are employed later to figure

1489

   * out the state of the medium after the switching.

1490

*/

1373

  return true;

1491

  return true;

1374

1492

1375

1493

1494

void

1495

WifiPhy::SetSleepMode (void)

1496

1497

  NS_LOG_FUNCTION (this);

1498

  switch (m_state->GetState ())

1499

1500

    case WifiPhy::TX:

1501

      NS_LOG_DEBUG ("setting sleep mode postponed until end of current transmission");

1502

      Simulator::Schedule (GetDelayUntilIdle (), &WifiPhy::SetSleepMode, this);

1503

      break;

1504

    case WifiPhy::RX:

1505

      NS_LOG_DEBUG ("setting sleep mode postponed until end of current reception");

1506

      Simulator::Schedule (GetDelayUntilIdle (), &WifiPhy::SetSleepMode, this);

1507

      break;

1508

    case WifiPhy::SWITCHING:

1509

      NS_LOG_DEBUG ("setting sleep mode postponed until end of channel switching");

1510

      Simulator::Schedule (GetDelayUntilIdle (), &WifiPhy::SetSleepMode, this);

1511

      break;

1512

    case WifiPhy::CCA_BUSY:

1513

    case WifiPhy::IDLE:

1514

      NS_LOG_DEBUG ("setting sleep mode");

1515

      m_state->SwitchToSleep ();

1516

      break;

1517

    case WifiPhy::SLEEP:

1518

      NS_LOG_DEBUG ("already in sleep mode");

1519

      break;

1520

    default:

1521

      NS_ASSERT (false);

1522

      break;

1523

1524

1525

1526

void

1527

WifiPhy::ResumeFromSleep (void)

1528

1529

  NS_LOG_FUNCTION (this);

1530

  switch (m_state->GetState ())

1531

1532

    case WifiPhy::TX:

1533

    case WifiPhy::RX:

1534

    case WifiPhy::IDLE:

1535

    case WifiPhy::CCA_BUSY:

1536

    case WifiPhy::SWITCHING:

1537

1538

        NS_LOG_DEBUG ("not in sleep mode, there is nothing to resume");

1539

        break;

1540

1541

    case WifiPhy::SLEEP:

1542

1543

        NS_LOG_DEBUG ("resuming from sleep mode");

1544

        Time delayUntilCcaEnd = m_interference.GetEnergyDuration (DbmToW (GetCcaMode1Threshold ()));

1545

        m_state->SwitchFromSleep (delayUntilCcaEnd);

1546

        break;

1547

1548

    default:

1549

1550

        NS_ASSERT (false);

1551

        break;

1552

1553

1554

1555

1376

WifiMode

1556

WifiMode

1377

WifiPhy::GetHtPlcpHeaderMode (WifiMode payloadMode)

1557

WifiPhy::GetHtPlcpHeaderMode (WifiMode payloadMode)

1378

1558

Lines 2026-2031	Link Here

2026

  m_phyMonitorSniffTxTrace (packet, channelFreqMhz, channelNumber, txVector, aMpdu);

2206

  m_phyMonitorSniffTxTrace (packet, channelFreqMhz, channelNumber, txVector, aMpdu);

2027

2207

2028

2208

2209

void

2210

WifiPhy::SendPacket (Ptr<const Packet> packet, WifiTxVector txVector, MpduType mpdutype)

2211

2212

  NS_LOG_FUNCTION (this << packet << txVector.GetMode ()

2213

                        << txVector.GetMode ().GetDataRate (txVector)

2214

                        << txVector.GetPreambleType ()

2215

                        << (uint32_t)txVector.GetTxPowerLevel ()

2216

                        << (uint32_t)mpdutype);

2217

  /* Transmission can happen if:

2218

   *  - we are syncing on a packet. It is the responsability of the

2219

   *    MAC layer to avoid doing this but the PHY does nothing to

2220

   *    prevent it.

2221

   *  - we are idle

2222

*/

2223

  NS_ASSERT (!m_state->IsStateTx () && !m_state->IsStateSwitching ());

2224

2225

  if (txVector.GetNss () > GetMaxSupportedTxSpatialStreams ())

2226

2227

      NS_FATAL_ERROR ("Unsupported number of spatial streams!");

2228

2229

2230

  if (m_state->IsStateSleep ())

2231

2232

      NS_LOG_DEBUG ("Dropping packet because in sleep mode");

2233

      NotifyTxDrop (packet);

2234

      return;

2235

2236

2237

  Time txDuration = CalculateTxDuration (packet->GetSize (), txVector, GetFrequency (), mpdutype, 1);

2238

  NS_ASSERT (txDuration > NanoSeconds (0));

2239

2240

  if (m_state->IsStateRx ())

2241

2242

      m_endPlcpRxEvent.Cancel ();

2243

      m_endRxEvent.Cancel ();

2244

      m_interference.NotifyRxEnd ();

2245

2246

  NotifyTxBegin (packet);

2247

  if ((mpdutype == MPDU_IN_AGGREGATE) && (txVector.GetPreambleType () != WIFI_PREAMBLE_NONE))

2248

2249

      //send the first MPDU in an MPDU

2250

      m_txMpduReferenceNumber++;

2251

2252

  MpduInfo aMpdu;

2253

  aMpdu.type = mpdutype;

2254

  aMpdu.mpduRefNumber = m_txMpduReferenceNumber;

2255

  NotifyMonitorSniffTx (packet, (uint16_t) GetFrequency (), GetChannelNumber (), txVector, aMpdu);

2256

  m_state->SwitchToTx (txDuration, packet, GetPowerDbm (txVector.GetTxPowerLevel ()), txVector);

2257

2258

  Ptr<Packet> newPacket = packet->Copy (); // obtain non-const Packet

2259

  WifiPhyTag oldtag;

2260

  newPacket->RemovePacketTag (oldtag);

2261

  WifiPhyTag tag (txVector, mpdutype);

2262

  newPacket->AddPacketTag (tag);

2263

2264

  StartTx (newPacket, txVector, txDuration);

2265

2266

2267

void

2268

WifiPhy::StartReceivePreambleAndHeader (Ptr<Packet> packet, double rxPowerW, Time rxDuration)

2269

2270

  //This function should be later split to check separately whether plcp preamble and plcp header can be successfully received.

2271

  //Note: plcp preamble reception is not yet modeled.

2272

  NS_LOG_FUNCTION (this << packet << WToDbm (rxPowerW) << rxDuration);

2273

  AmpduTag ampduTag;

2274

  Time endRx = Simulator::Now () + rxDuration;

2275

2276

  WifiPhyTag tag;

2277

  bool found = packet->RemovePacketTag (tag);

2278

  if (!found)

2279

2280

      NS_FATAL_ERROR ("Received Wi-Fi Signal with no WifiPhyTag");

2281

      return;

2282

2283

2284

  WifiTxVector txVector = tag.GetWifiTxVector ();

2285

2286

  if (txVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_HT

2287

      && (txVector.GetNss () != (1 + (txVector.GetMode ().GetMcsValue () / 8))))

2288

2289

      NS_FATAL_ERROR ("MCS value does not match NSS value: MCS = " << (uint16_t)txVector.GetMode ().GetMcsValue () << ", NSS = " << (uint16_t)txVector.GetNss ());

2290

2291

2292

  if (txVector.GetNss () > GetMaxSupportedRxSpatialStreams ())

2293

2294

      NS_FATAL_ERROR ("Reception ends in failure because of an unsupported number of spatial streams");

2295

2296

2297

  WifiPreamble preamble = txVector.GetPreambleType ();

2298

  MpduType mpdutype = tag.GetMpduType ();

2299

  Time preambleAndHeaderDuration = CalculatePlcpPreambleAndHeaderDuration (txVector);

2300

2301

  Ptr<InterferenceHelper::Event> event;

2302

  event = m_interference.Add (packet->GetSize (),

2303

                              txVector,

2304

                              rxDuration,

2305

                              rxPowerW);

2306

2307

  switch (m_state->GetState ())

2308

2309

    case WifiPhy::SWITCHING:

2310

      NS_LOG_DEBUG ("drop packet because of channel switching");

2311

      NotifyRxDrop (packet);

2312

      m_plcpSuccess = false;

2313

/*

2314

       * Packets received on the upcoming channel are added to the event list

2315

       * during the switching state. This way the medium can be correctly sensed

2316

       * when the device listens to the channel for the first time after the

2317

       * switching e.g. after channel switching, the channel may be sensed as

2318

       * busy due to other devices' tramissions started before the end of

2319

       * the switching.

2320

*/

2321

      if (endRx > Simulator::Now () + m_state->GetDelayUntilIdle ())

2322

2323

          //that packet will be noise _after_ the completion of the

2324

          //channel switching.

2325

          goto maybeCcaBusy;

2326

2327

      break;

2328

    case WifiPhy::RX:

2329

      NS_LOG_DEBUG ("drop packet because already in Rx (power=" <<

2330

                    rxPowerW << "W)");

2331

      NotifyRxDrop (packet);

2332

      if (endRx > Simulator::Now () + m_state->GetDelayUntilIdle ())

2333

2334

          //that packet will be noise _after_ the reception of the

2335

          //currently-received packet.

2336

          goto maybeCcaBusy;

2337

2338

      break;

2339

    case WifiPhy::TX:

2340

      NS_LOG_DEBUG ("drop packet because already in Tx (power=" <<

2341

                    rxPowerW << "W)");

2342

      NotifyRxDrop (packet);

2343

      if (endRx > Simulator::Now () + m_state->GetDelayUntilIdle ())

2344

2345

          //that packet will be noise _after_ the transmission of the

2346

          //currently-transmitted packet.

2347

          goto maybeCcaBusy;

2348

2349

      break;

2350

    case WifiPhy::CCA_BUSY:

2351

    case WifiPhy::IDLE:

2352

      if (rxPowerW > GetEdThresholdW ()) //checked here, no need to check in the payload reception (current implementation assumes constant rx power over the packet duration)

2353

2354

          if (preamble == WIFI_PREAMBLE_NONE && (m_mpdusNum == 0 || m_plcpSuccess == false))

2355

2356

              m_plcpSuccess = false;

2357

              m_mpdusNum = 0;

2358

              NS_LOG_DEBUG ("drop packet because no PLCP preamble/header has been received");

2359

              NotifyRxDrop (packet);

2360

              goto maybeCcaBusy;

2361

2362

          else if (preamble != WIFI_PREAMBLE_NONE && packet->PeekPacketTag (ampduTag) && m_mpdusNum == 0)

2363

2364

              //received the first MPDU in an MPDU

2365

              m_mpdusNum = ampduTag.GetRemainingNbOfMpdus ();

2366

              m_rxMpduReferenceNumber++;

2367

2368

          else if (preamble == WIFI_PREAMBLE_NONE && packet->PeekPacketTag (ampduTag) && m_mpdusNum > 0)

2369

2370

              //received the other MPDUs that are part of the A-MPDU

2371

              if (ampduTag.GetRemainingNbOfMpdus () < (m_mpdusNum - 1))

2372

2373

                  NS_LOG_DEBUG ("Missing MPDU from the A-MPDU " << m_mpdusNum - ampduTag.GetRemainingNbOfMpdus ());

2374

                  m_mpdusNum = ampduTag.GetRemainingNbOfMpdus ();

2375

2376

              else

2377

2378

                  m_mpdusNum--;

2379

2380

2381

          else if (preamble != WIFI_PREAMBLE_NONE && packet->PeekPacketTag (ampduTag) && m_mpdusNum > 0)

2382

2383

              NS_LOG_DEBUG ("New A-MPDU started while " << m_mpdusNum << " MPDUs from previous are lost");

2384

              m_mpdusNum = ampduTag.GetRemainingNbOfMpdus ();

2385

2386

          else if (preamble != WIFI_PREAMBLE_NONE && m_mpdusNum > 0 )

2387

2388

              NS_LOG_DEBUG ("Didn't receive the last MPDUs from an A-MPDU " << m_mpdusNum);

2389

              m_mpdusNum = 0;

2390

2391

2392

          NS_LOG_DEBUG ("sync to signal (power=" << rxPowerW << "W)");

2393

          //sync to signal

2394

          m_state->SwitchToRx (rxDuration);

2395

          NS_ASSERT (m_endPlcpRxEvent.IsExpired ());

2396

          NotifyRxBegin (packet);

2397

          m_interference.NotifyRxStart ();

2398

2399

          if (preamble != WIFI_PREAMBLE_NONE)

2400

2401

              NS_ASSERT (m_endPlcpRxEvent.IsExpired ());

2402

              m_endPlcpRxEvent = Simulator::Schedule (preambleAndHeaderDuration, &WifiPhy::StartReceivePacket, this,

2403

                                                      packet, txVector, mpdutype, event);

2404

2405

2406

          NS_ASSERT (m_endRxEvent.IsExpired ());

2407

          m_endRxEvent = Simulator::Schedule (rxDuration, &WifiPhy::EndReceive, this,

2408

                                              packet, preamble, mpdutype, event);

2409

2410

      else

2411

2412

          NS_LOG_DEBUG ("drop packet because signal power too Small (" <<

2413

                        rxPowerW << "<" << GetEdThresholdW () << ")");

2414

          NotifyRxDrop (packet);

2415

          m_plcpSuccess = false;

2416

          goto maybeCcaBusy;

2417

2418

      break;

2419

    case WifiPhy::SLEEP:

2420

      NS_LOG_DEBUG ("drop packet because in sleep mode");

2421

      NotifyRxDrop (packet);

2422

      m_plcpSuccess = false;

2423

      break;

2424

2425

2426

  return;

2427

2428

maybeCcaBusy:

2429

  //We are here because we have received the first bit of a packet and we are

2430

  //not going to be able to synchronize on it

2431

  //In this model, CCA becomes busy when the aggregation of all signals as

2432

  //tracked by the InterferenceHelper class is higher than the CcaBusyThreshold

2433

2434

  Time delayUntilCcaEnd = m_interference.GetEnergyDuration (DbmToW (GetCcaMode1Threshold ()));

2435

  if (!delayUntilCcaEnd.IsZero ())

2436

2437

      m_state->SwitchMaybeToCcaBusy (delayUntilCcaEnd);

2438

2439

2440

2441

void

2442

WifiPhy::StartReceivePacket (Ptr<Packet> packet,

2443

                             WifiTxVector txVector,

2444

                             MpduType mpdutype,

2445

                             Ptr<InterferenceHelper::Event> event)

2446

2447

  NS_LOG_FUNCTION (this << packet << txVector.GetMode () << txVector.GetPreambleType () << (uint32_t)mpdutype);

2448

  NS_ASSERT (IsStateRx ());

2449

  NS_ASSERT (m_endPlcpRxEvent.IsExpired ());

2450

  WifiMode txMode = txVector.GetMode ();

2451

2452

  InterferenceHelper::SnrPer snrPer;

2453

  snrPer = m_interference.CalculatePlcpHeaderSnrPer (event);

2454

2455

  NS_LOG_DEBUG ("snr(dB)=" << RatioToDb (snrPer.snr) << ", per=" << snrPer.per);

2456

2457

  if (m_random->GetValue () > snrPer.per) //plcp reception succeeded

2458

2459

      if (IsModeSupported (txMode) || IsMcsSupported (txMode))

2460

2461

          NS_LOG_DEBUG ("receiving plcp payload"); //endReceive is already scheduled

2462

          m_plcpSuccess = true;

2463

2464

      else //mode is not allowed

2465

2466

          NS_LOG_DEBUG ("drop packet because it was sent using an unsupported mode (" << txMode << ")");

2467

          NotifyRxDrop (packet);

2468

          m_plcpSuccess = false;

2469

2470

2471

  else //plcp reception failed

2472

2473

      NS_LOG_DEBUG ("drop packet because plcp preamble/header reception failed");

2474

      NotifyRxDrop (packet);

2475

      m_plcpSuccess = false;

2476

2477

2478

2479

void

2480

WifiPhy::EndReceive (Ptr<Packet> packet, WifiPreamble preamble, MpduType mpdutype, Ptr<InterferenceHelper::Event> event)

2481

2482

  NS_LOG_FUNCTION (this << packet << event);

2483

  NS_ASSERT (IsStateRx ());

2484

  NS_ASSERT (event->GetEndTime () == Simulator::Now ());

2485

2486

  InterferenceHelper::SnrPer snrPer;

2487

  snrPer = m_interference.CalculatePlcpPayloadSnrPer (event);

2488

  m_interference.NotifyRxEnd ();

2489

2490

  if (m_plcpSuccess == true)

2491

2492

      NS_LOG_DEBUG ("mode=" << (event->GetPayloadMode ().GetDataRate (event->GetTxVector ())) <<

2493

                    ", snr(dB)=" << RatioToDb (snrPer.snr) << ", per=" << snrPer.per << ", size=" << packet->GetSize ());

2494

2495

      if (m_random->GetValue () > snrPer.per)

2496

2497

          NotifyRxEnd (packet);

2498

          SignalNoiseDbm signalNoise;

2499

          signalNoise.signal = RatioToDb (event->GetRxPowerW ()) + 30;

2500

          signalNoise.noise = RatioToDb (event->GetRxPowerW () / snrPer.snr) - GetRxNoiseFigure () + 30;

2501

          MpduInfo aMpdu;

2502

          aMpdu.type = mpdutype;

2503

          aMpdu.mpduRefNumber = m_rxMpduReferenceNumber;

2504

          NotifyMonitorSniffRx (packet, (uint16_t) GetFrequency (), GetChannelNumber (), event->GetTxVector (), aMpdu, signalNoise);

2505

          m_state->SwitchFromRxEndOk (packet, snrPer.snr, event->GetTxVector ());

2506

2507

      else

2508

2509

          /* failure. */

2510

          NotifyRxDrop (packet);

2511

          m_state->SwitchFromRxEndError (packet, snrPer.snr);

2512

2513

2514

  else

2515

2516

      m_state->SwitchFromRxEndError (packet, snrPer.snr);

2517

2518

2519

  if (preamble == WIFI_PREAMBLE_NONE && mpdutype == LAST_MPDU_IN_AGGREGATE)

2520

2521

      m_plcpSuccess = false;

2522

2523

2524

2525

2029

2526

2030

// Clause 15 rates (DSSS)

2527

// Clause 15 rates (DSSS)

2031

2528

Lines 2904-2935	Link Here

2904

  return m_deviceMcsSet[mcs];

3401

  return m_deviceMcsSet[mcs];

2905

3402

2906

3403

2907

double

2908

WifiPhy::DbToRatio (double dB) const

2909

2910

  double ratio = std::pow (10.0, dB / 10.0);

2911

  return ratio;

2912

2913

2914

double

2915

WifiPhy::DbmToW (double dBm) const

2916

2917

  double mW = std::pow (10.0, dBm / 10.0);

2918

  return mW / 1000.0;

2919

2920

2921

double

2922

WifiPhy::WToDbm (double w) const

2923

2924

  return 10.0 * std::log10 (w * 1000.0);

2925

2926

2927

double

2928

WifiPhy::RatioToDb (double ratio) const

2929

2930

  return 10.0 * std::log10 (ratio);

2931

2932

2933

bool

3404

bool

2934

WifiPhy::IsStateCcaBusy (void)

3405

WifiPhy::IsStateCcaBusy (void)

2935

3406




   * \param callback the callback to invoke
   *        upon successful packet reception.
   */
  void SetReceiveOkCallback (RxOkCallback callback);
  /**
   * \param callback the callback to invoke
   *        upon erroneous packet reception.
   */
  void SetReceiveErrorCallback (RxErrorCallback callback);
  
  /**
   * \param listener the new listener
   *
   * Add the input listener to the list of objects to be notified of
   * PHY-level events.
   */
  void RegisterListener (WifiPhyListener *listener);
  /**
   * \param listener the listener to be unregistered
   *
   * Remove the input listener from the list of objects to be notified of
   * PHY-level events.
   */
  void UnregisterListener (WifiPhyListener *listener);
  
  /**
   * Starting receiving the plcp of a packet (i.e. the first bit of the preamble has arrived).
   *
   * \param packet the arriving packet
   * \param rxPowerW the receive power in W
   * \param rxDuration the duration needed for the reception of the packet
   */
  void StartReceivePreambleAndHeader (Ptr<Packet> packet,
                                      double rxPowerW,
                                      Time rxDuration);
  
  /**
   * Starting receiving the payload of a packet (i.e. the first bit of the packet has arrived).
   *
   * \param packet the arriving packet
   * \param txVector the TXVECTOR of the arriving packet
   * \param mpdutype the type of the MPDU as defined in WifiPhy::MpduType.
   * \param event the corresponding event of the first time the packet arrives
   */
  void StartReceivePacket (Ptr<Packet> packet,
                           WifiTxVector txVector,
                           MpduType mpdutype,
                           Ptr<InterferenceHelper::Event> event);
    
  /**
   * The last bit of the packet has arrived.
   *
   * \param packet the packet that the last bit has arrived
   * \param preamble the preamble of the arriving packet
   * \param mpdutype the type of the MPDU as defined in WifiPhy::MpduType.
   * \param event the corresponding event of the first time the packet arrives
   */
  void EndReceive (Ptr<Packet> packet, WifiPreamble preamble, MpduType mpdutype, Ptr<InterferenceHelper::Event> event);
    
  /**
   * \param packet the packet to send
   * \param txVector the TXVECTOR that has tx parameters such as mode, the transmission mode to use to send

   *        power is calculated as txPowerMin + txPowerLevel * (txPowerMax - txPowerMin) / nTxLevels
   * \param mpdutype the type of the MPDU as defined in WifiPhy::MpduType.
   */
  void SendPacket (Ptr<const Packet> packet, WifiTxVector txVector, MpduType mpdutype = NORMAL_MPDU);
  
  /**
   * \param packet the packet to send
   * \param txVector the TXVECTOR that has tx parameters such as mode, the transmission mode to use to send
   *        this packet, and txPowerLevel, a power level to use to send this packet. The real transmission
   *        power is calculated as txPowerMin + txPowerLevel * (txPowerMax - txPowerMin) / nTxLevels
   * \param txDuration duration of the transmission.
   */
  virtual void StartTx (Ptr<Packet> packet, WifiTxVector txVector, Time txDuration) = 0;
  /**
   * \param listener the listener to be unregistered
   *
   * Remove the input listener from the list of objects to be notified of
   * PHY-level events.
   */
  virtual void UnregisterListener (WifiPhyListener *listener) = 0;

  /**
   * Put in sleep mode.
   */
  virtual void SetSleepMode (void);
  /**
   * Resume from sleep mode.
   */
  virtual void ResumeFromSleep (void);

  /**
   * \return true of the current state of the PHY layer is WifiPhy::IDLE, false otherwise.

   * \return a vector containing the supported channel widths, values in MHz
   */
  virtual std::vector<uint32_t> GetSupportedChannelWidthSet (void) const;

   * Convert from dBm to Watts.
   *
   * \param dbm the power in dBm
   *
   * \return the equivalent Watts for the given dBm
   */
  double DbmToW (double dbm) const;
  /**
   * Convert from dB to ratio.
   *
   * \param db
   *
   * \return ratio
   */
  double DbToRatio (double db) const;
  /**
   * Convert from Watts to dBm.
   *
   * \param w the power in Watts
   *
   * \return the equivalent dBm for the given Watts
   */
  double WToDbm (double w) const;
  /**
   * Convert from ratio to dB.
   *
   * \param ratio
   *
   * \return dB
   */
  double RatioToDb (double ratio) const;

protected:
  // Inherited




/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2016
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Author: Sébastien Deronne <sebastien.deronne@gmail.com>
 */

#include "wifi-utils.h"
#include <cmath>

namespace ns3 {

double
DbToRatio (double dB)
{
  double ratio = std::pow (10.0, dB / 10.0);
  return ratio;
}

double
DbmToW (double dBm)
{
  double mW = std::pow (10.0, dBm / 10.0);
  return mW / 1000.0;
}

double
WToDbm (double w)
{
  return 10.0 * std::log10 (w * 1000.0);
}

double
RatioToDb (double ratio)
{
  return 10.0 * std::log10 (ratio);
}

} //namespace ns3




/* -*-  Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2016
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Author: Sébastien Deronne <sebastien.deronne@gmail.com>
 */

#ifndef WIFI_UTILS_H
#define WIFI_UTILS_H

namespace ns3 {

  /**
   * Convert from dBm to Watts.
   *
   * \param dbm the power in dBm
   *
   * \return the equivalent Watts for the given dBm
   */
  double DbmToW (double dbm);
  /**
   * Convert from dB to ratio.
   *
   * \param db
   *
   * \return ratio
   */
  double DbToRatio (double db);
  /**
   * Convert from Watts to dBm.
   *
   * \param w the power in Watts
   *
   * \return the equivalent dBm for the given Watts
   */
  double WToDbm (double w);
  /**
   * Convert from ratio to dB.
   *
   * \param ratio
   *
   * \return dB
   */
  double RatioToDb (double ratio);

} // namespace ns3

#endif /* WIFI_UTILS_H */

(-)a/src/wifi/model/yans-wifi-channel.cc (-1 / +2 lines)

Lines 29-34	Link Here

#include "yans-wifi-channel.h"

#include "yans-wifi-channel.h"

#include "ns3/propagation-loss-model.h"

#include "ns3/propagation-loss-model.h"

#include "ns3/propagation-delay-model.h"

#include "ns3/propagation-delay-model.h"

#include "wifi-utils.h"

namespace ns3 {

namespace ns3 {

Lines 120-126	Link Here

120

void

121

void

121

YansWifiChannel::Receive (uint32_t i, Ptr<Packet> packet, double rxPowerDbm, Time duration) const

122

YansWifiChannel::Receive (uint32_t i, Ptr<Packet> packet, double rxPowerDbm, Time duration) const

122

123

  m_phyList[i]->StartReceivePreambleAndHeader (packet, rxPowerDbm, duration);

124

  m_phyList[i]->StartReceivePreambleAndHeader (packet, DbmToW (rxPowerDbm + m_phyList[i]->GetRxGain ()), duration);

124

125

126

uint32_t

127

uint32_t




#include "ns3/assert.h"
#include "ns3/log.h"
#include "ns3/double.h"
#include "wifi-utils.h"
#include "wifi-phy-tag.h"
#include <cmath>

namespace ns3 {


  m_channel = 0;
}

bool
YansWifiPhy::DoChannelSwitch (uint16_t nch)
{
  if (!IsInitialized ())
    {
      //this is not channel switch, this is initialization
      NS_LOG_DEBUG ("initialize to channel " << nch);
      return true;
    }

  NS_ASSERT (!IsStateSwitching ());
  switch (m_state->GetState ())
    {
    case YansWifiPhy::RX:
      NS_LOG_DEBUG ("drop packet because of channel switching while reception");
      m_endPlcpRxEvent.Cancel ();
      m_endRxEvent.Cancel ();
      goto switchChannel;
      break;
    case YansWifiPhy::TX:
      NS_LOG_DEBUG ("channel switching postponed until end of current transmission");
      Simulator::Schedule (GetDelayUntilIdle (), &WifiPhy::SetChannelNumber, this, nch);
      break;
    case YansWifiPhy::CCA_BUSY:
    case YansWifiPhy::IDLE:
      goto switchChannel;
      break;
    case YansWifiPhy::SLEEP:
      NS_LOG_DEBUG ("channel switching ignored in sleep mode");
      break;
    default:
      NS_ASSERT (false);
      break;
    }

  return false;

switchChannel:

  NS_LOG_DEBUG ("switching channel " << GetChannelNumber () << " -> " << nch);
  m_state->SwitchToChannelSwitching (GetChannelSwitchDelay ());
  m_interference.EraseEvents ();
  /*
   * Needed here to be able to correctly sensed the medium for the first
   * time after the switching. The actual switching is not performed until
   * after m_channelSwitchDelay. Packets received during the switching
   * state are added to the event list and are employed later to figure
   * out the state of the medium after the switching.
   */
  return true;
}

bool
YansWifiPhy::DoFrequencySwitch (uint32_t frequency)
{
  if (!IsInitialized ())
    {
      //this is not channel switch, this is initialization
      NS_LOG_DEBUG ("start at frequency " << frequency);
      return true;
    }

  NS_ASSERT (!IsStateSwitching ());
  switch (m_state->GetState ())
    {
    case YansWifiPhy::RX:
      NS_LOG_DEBUG ("drop packet because of channel/frequency switching while reception");
      m_endPlcpRxEvent.Cancel ();
      m_endRxEvent.Cancel ();
      goto switchFrequency;
      break;
    case YansWifiPhy::TX:
      NS_LOG_DEBUG ("channel/frequency switching postponed until end of current transmission");
      Simulator::Schedule (GetDelayUntilIdle (), &WifiPhy::SetFrequency, this, frequency);
      break;
    case YansWifiPhy::CCA_BUSY:
    case YansWifiPhy::IDLE:
      goto switchFrequency;
      break;
    case YansWifiPhy::SLEEP:
      NS_LOG_DEBUG ("frequency switching ignored in sleep mode");
      break;
    default:
      NS_ASSERT (false);
      break;
    }

  return false;

switchFrequency:

  NS_LOG_DEBUG ("switching frequency " << GetFrequency () << " -> " << frequency);
  m_state->SwitchToChannelSwitching (GetChannelSwitchDelay ());
  m_interference.EraseEvents ();
  /*
   * Needed here to be able to correctly sensed the medium for the first
   * time after the switching. The actual switching is not performed until
   * after m_channelSwitchDelay. Packets received during the switching
   * state are added to the event list and are employed later to figure
   * out the state of the medium after the switching.
   */
  return true;
}

Ptr<WifiChannel>
YansWifiPhy::GetChannel (void) const
{

}

void
YansWifiPhy::StartTx (Ptr<Packet> packet, WifiTxVector txVector, Time txDuration)
{
  NS_LOG_FUNCTION (this);
  switch (m_state->GetState ())
    {
    case YansWifiPhy::TX:
      NS_LOG_DEBUG ("setting sleep mode postponed until end of current transmission");
      Simulator::Schedule (GetDelayUntilIdle (), &YansWifiPhy::SetSleepMode, this);
      break;
    case YansWifiPhy::RX:
      NS_LOG_DEBUG ("setting sleep mode postponed until end of current reception");
      Simulator::Schedule (GetDelayUntilIdle (), &YansWifiPhy::SetSleepMode, this);
      break;
    case YansWifiPhy::SWITCHING:
      NS_LOG_DEBUG ("setting sleep mode postponed until end of channel switching");
      Simulator::Schedule (GetDelayUntilIdle (), &YansWifiPhy::SetSleepMode, this);
      break;
    case YansWifiPhy::CCA_BUSY:
    case YansWifiPhy::IDLE:
      NS_LOG_DEBUG ("setting sleep mode");
      m_state->SwitchToSleep ();
      break;
    case YansWifiPhy::SLEEP:
      NS_LOG_DEBUG ("already in sleep mode");
      break;
    default:
      NS_ASSERT (false);
      break;
    }
}

void
YansWifiPhy::ResumeFromSleep (void)
{
  NS_LOG_FUNCTION (this);
  switch (m_state->GetState ())
    {
    case YansWifiPhy::TX:
    case YansWifiPhy::RX:
    case YansWifiPhy::IDLE:
    case YansWifiPhy::CCA_BUSY:
    case YansWifiPhy::SWITCHING:
      {
        NS_LOG_DEBUG ("not in sleep mode, there is nothing to resume");
        break;
      }
    case YansWifiPhy::SLEEP:
      {
        NS_LOG_DEBUG ("resuming from sleep mode");
        Time delayUntilCcaEnd = m_interference.GetEnergyDuration (DbmToW (GetCcaMode1Threshold ()));
        m_state->SwitchFromSleep (delayUntilCcaEnd);
        break;
      }
    default:
      {
        NS_ASSERT (false);
        break;
      }
    }
}

void
YansWifiPhy::SetReceiveOkCallback (RxOkCallback callback)
{
  m_state->SetReceiveOkCallback (callback);
}

void
YansWifiPhy::SetReceiveErrorCallback (RxErrorCallback callback)
{
  m_state->SetReceiveErrorCallback (callback);
}

void
YansWifiPhy::StartReceivePreambleAndHeader (Ptr<Packet> packet, double rxPowerDbm, Time rxDuration)
{
  NS_LOG_DEBUG ("Start transmission: signal power before antenna gain=" << GetPowerDbm (txVector.GetTxPowerLevel ()) << "dBm");
  m_channel->Send (this, packet, GetPowerDbm (txVector.GetTxPowerLevel ()) + GetTxGain (), txDuration);
  NS_LOG_FUNCTION (this << packet << rxPowerDbm << rxDuration);
  AmpduTag ampduTag;
  rxPowerDbm += GetRxGain ();
  double rxPowerW = DbmToW (rxPowerDbm);
  Time endRx = Simulator::Now () + rxDuration;
  
  WifiPhyTag tag;
  packet->RemovePacketTag (tag);
  WifiTxVector txVector = tag.GetWifiTxVector ();
  
  if (txVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_HT
      && (txVector.GetNss () != (1 + (txVector.GetMode ().GetMcsValue () / 8))))
    {
      NS_FATAL_ERROR ("MCS value does not match NSS value: MCS = " << (uint16_t)txVector.GetMode ().GetMcsValue () << ", NSS = " << (uint16_t)txVector.GetNss ());
    }
  
  if (txVector.GetNss () > GetMaxSupportedRxSpatialStreams ())
    {
      NS_FATAL_ERROR ("Reception ends in failure because of an unsupported number of spatial streams");
    }

  WifiPreamble preamble = txVector.GetPreambleType ();
  MpduType mpdutype = tag.GetMpduType ();
  Time preambleAndHeaderDuration = CalculatePlcpPreambleAndHeaderDuration (txVector);

  Ptr<InterferenceHelper::Event> event;
  event = m_interference.Add (packet->GetSize (),
                              txVector,
                              rxDuration,
                              rxPowerW);

  switch (m_state->GetState ())
    {
    case YansWifiPhy::SWITCHING:
      NS_LOG_DEBUG ("drop packet because of channel switching");
      NotifyRxDrop (packet);
      m_plcpSuccess = false;
      /*
       * Packets received on the upcoming channel are added to the event list
       * during the switching state. This way the medium can be correctly sensed
       * when the device listens to the channel for the first time after the
       * switching e.g. after channel switching, the channel may be sensed as
       * busy due to other devices' tramissions started before the end of
       * the switching.
       */
      if (endRx > Simulator::Now () + m_state->GetDelayUntilIdle ())
        {
          //that packet will be noise _after_ the completion of the
          //channel switching.
          goto maybeCcaBusy;
        }
      break;
    case YansWifiPhy::RX:
      NS_LOG_DEBUG ("drop packet because already in Rx (power=" <<
                    rxPowerW << "W)");
      NotifyRxDrop (packet);
      if (endRx > Simulator::Now () + m_state->GetDelayUntilIdle ())
        {
          //that packet will be noise _after_ the reception of the
          //currently-received packet.
          goto maybeCcaBusy;
        }
      break;
    case YansWifiPhy::TX:
      NS_LOG_DEBUG ("drop packet because already in Tx (power=" <<
                    rxPowerW << "W)");
      NotifyRxDrop (packet);
      if (endRx > Simulator::Now () + m_state->GetDelayUntilIdle ())
        {
          //that packet will be noise _after_ the transmission of the
          //currently-transmitted packet.
          goto maybeCcaBusy;
        }
      break;
    case YansWifiPhy::CCA_BUSY:
    case YansWifiPhy::IDLE:
      if (rxPowerW > GetEdThresholdW ()) //checked here, no need to check in the payload reception (current implementation assumes constant rx power over the packet duration)
        {
          if (preamble == WIFI_PREAMBLE_NONE && (m_mpdusNum == 0 || m_plcpSuccess == false))
            {
              m_plcpSuccess = false;
              m_mpdusNum = 0;
              NS_LOG_DEBUG ("drop packet because no PLCP preamble/header has been received");
              NotifyRxDrop (packet);
              goto maybeCcaBusy;
            }
          else if (preamble != WIFI_PREAMBLE_NONE && packet->PeekPacketTag (ampduTag) && m_mpdusNum == 0)
            {
              //received the first MPDU in an MPDU
              m_mpdusNum = ampduTag.GetRemainingNbOfMpdus ();
              m_rxMpduReferenceNumber++;
            }
          else if (preamble == WIFI_PREAMBLE_NONE && packet->PeekPacketTag (ampduTag) && m_mpdusNum > 0)
            {
              //received the other MPDUs that are part of the A-MPDU
              if (ampduTag.GetRemainingNbOfMpdus () < (m_mpdusNum - 1))
                {
                  NS_LOG_DEBUG ("Missing MPDU from the A-MPDU " << m_mpdusNum - ampduTag.GetRemainingNbOfMpdus ());
                  m_mpdusNum = ampduTag.GetRemainingNbOfMpdus ();
                }
              else
                {
                  m_mpdusNum--;
                }
            }
          else if (preamble != WIFI_PREAMBLE_NONE && packet->PeekPacketTag (ampduTag) && m_mpdusNum > 0)
            {
              NS_LOG_DEBUG ("New A-MPDU started while " << m_mpdusNum << " MPDUs from previous are lost");
              m_mpdusNum = ampduTag.GetRemainingNbOfMpdus ();
            }
          else if (preamble != WIFI_PREAMBLE_NONE && m_mpdusNum > 0 )
            {
              NS_LOG_DEBUG ("Didn't receive the last MPDUs from an A-MPDU " << m_mpdusNum);
              m_mpdusNum = 0;
            }

          NS_LOG_DEBUG ("sync to signal (power=" << rxPowerW << "W)");
          //sync to signal
          m_state->SwitchToRx (rxDuration);
          NS_ASSERT (m_endPlcpRxEvent.IsExpired ());
          NotifyRxBegin (packet);
          m_interference.NotifyRxStart ();

          if (preamble != WIFI_PREAMBLE_NONE)
            {
              NS_ASSERT (m_endPlcpRxEvent.IsExpired ());
              m_endPlcpRxEvent = Simulator::Schedule (preambleAndHeaderDuration, &YansWifiPhy::StartReceivePacket, this,
                                                      packet, txVector, mpdutype, event);
            }

          NS_ASSERT (m_endRxEvent.IsExpired ());
          m_endRxEvent = Simulator::Schedule (rxDuration, &YansWifiPhy::EndReceive, this,
                                              packet, preamble, mpdutype, event);
        }
      else
        {
          NS_LOG_DEBUG ("drop packet because signal power too Small (" <<
                        rxPowerW << "<" << GetEdThresholdW () << ")");
          NotifyRxDrop (packet);
          m_plcpSuccess = false;
          goto maybeCcaBusy;
        }
      break;
    case YansWifiPhy::SLEEP:
      NS_LOG_DEBUG ("drop packet because in sleep mode");
      NotifyRxDrop (packet);
      m_plcpSuccess = false;
      break;
    }

  return;

maybeCcaBusy:
  //We are here because we have received the first bit of a packet and we are
  //not going to be able to synchronize on it
  //In this model, CCA becomes busy when the aggregation of all signals as
  //tracked by the InterferenceHelper class is higher than the CcaBusyThreshold

  Time delayUntilCcaEnd = m_interference.GetEnergyDuration (DbmToW (GetCcaMode1Threshold ()));
  if (!delayUntilCcaEnd.IsZero ())
    {
      m_state->SwitchMaybeToCcaBusy (delayUntilCcaEnd);
    }
}

void
YansWifiPhy::StartReceivePacket (Ptr<Packet> packet,
                                 WifiTxVector txVector,
                                 MpduType mpdutype,
                                 Ptr<InterferenceHelper::Event> event)
{
  NS_LOG_FUNCTION (this << packet << txVector.GetMode () << txVector.GetPreambleType () << (uint32_t)mpdutype);
  NS_ASSERT (IsStateRx ());
  NS_ASSERT (m_endPlcpRxEvent.IsExpired ());
  WifiMode txMode = txVector.GetMode ();

  InterferenceHelper::SnrPer snrPer;
  snrPer = m_interference.CalculatePlcpHeaderSnrPer (event);

  NS_LOG_DEBUG ("snr(dB)=" << RatioToDb (snrPer.snr) << ", per=" << snrPer.per);

  if (m_random->GetValue () > snrPer.per) //plcp reception succeeded
    {
      if (IsModeSupported (txMode) || IsMcsSupported (txMode))
        {
          NS_LOG_DEBUG ("receiving plcp payload"); //endReceive is already scheduled
          m_plcpSuccess = true;
        }
      else //mode is not allowed
        {
          NS_LOG_DEBUG ("drop packet because it was sent using an unsupported mode (" << txMode << ")");
          NotifyRxDrop (packet);
          m_plcpSuccess = false;
        }
    }
  else //plcp reception failed
    {
      NS_LOG_DEBUG ("drop packet because plcp preamble/header reception failed");
      NotifyRxDrop (packet);
      m_plcpSuccess = false;
    }
}

void
YansWifiPhy::SendPacket (Ptr<const Packet> packet, WifiTxVector txVector, MpduType mpdutype)
{
  NS_LOG_FUNCTION (this << packet << txVector.GetMode () 
    << txVector.GetMode ().GetDataRate (txVector) << txVector.GetPreambleType ()
    << (uint32_t)txVector.GetTxPowerLevel () << (uint32_t)mpdutype);
  /* Transmission can happen if:
   *  - we are syncing on a packet. It is the responsability of the
   *    MAC layer to avoid doing this but the PHY does nothing to
   *    prevent it.
   *  - we are idle
   */
  NS_ASSERT (!m_state->IsStateTx () && !m_state->IsStateSwitching ());
  
  if (txVector.GetNss () > GetMaxSupportedTxSpatialStreams ())
    {
      NS_FATAL_ERROR ("Unsupported number of spatial streams!");
    }

  if (m_state->IsStateSleep ())
    {
      NS_LOG_DEBUG ("Dropping packet because in sleep mode");
      NotifyTxDrop (packet);
      return;
    }

  Time txDuration = CalculateTxDuration (packet->GetSize (), txVector, GetFrequency (), mpdutype, 1);
  NS_ASSERT (txDuration > NanoSeconds (0));

  if (m_state->IsStateRx ())
    {
      m_endPlcpRxEvent.Cancel ();
      m_endRxEvent.Cancel ();
      m_interference.NotifyRxEnd ();
    }
  NotifyTxBegin (packet);
  if ((mpdutype == MPDU_IN_AGGREGATE) && (txVector.GetPreambleType () != WIFI_PREAMBLE_NONE))
    {
      //send the first MPDU in an MPDU
      m_txMpduReferenceNumber++;
    }
  MpduInfo aMpdu;
  aMpdu.type = mpdutype;
  aMpdu.mpduRefNumber = m_txMpduReferenceNumber;
  NotifyMonitorSniffTx (packet, (uint16_t)GetFrequency (), GetChannelNumber (), txVector, aMpdu);
  m_state->SwitchToTx (txDuration, packet, GetPowerDbm (txVector.GetTxPowerLevel ()), txVector);
  
  Ptr<Packet> newPacket = packet->Copy (); // obtain non-const Packet
  WifiPhyTag oldtag;
  newPacket->RemovePacketTag (oldtag);
  WifiPhyTag tag (txVector, mpdutype);
  newPacket->AddPacketTag (tag);
  m_channel->Send (this, newPacket, GetPowerDbm (txVector.GetTxPowerLevel ()) + GetTxGain (), txDuration);
}

void
YansWifiPhy::RegisterListener (WifiPhyListener *listener)
{
  m_state->RegisterListener (listener);
}

void
YansWifiPhy::UnregisterListener (WifiPhyListener *listener)
{
  m_state->UnregisterListener (listener);
}

void
YansWifiPhy::EndReceive (Ptr<Packet> packet, WifiPreamble preamble, MpduType mpdutype, Ptr<InterferenceHelper::Event> event)
{
  NS_LOG_FUNCTION (this << packet << event);
  NS_ASSERT (IsStateRx ());
  NS_ASSERT (event->GetEndTime () == Simulator::Now ());

  InterferenceHelper::SnrPer snrPer;
  snrPer = m_interference.CalculatePlcpPayloadSnrPer (event);
  m_interference.NotifyRxEnd ();

  if (m_plcpSuccess == true)
    {
      NS_LOG_DEBUG ("mode=" << (event->GetPayloadMode ().GetDataRate (event->GetTxVector ())) <<
                    ", snr(dB)=" << RatioToDb (snrPer.snr) << ", per=" << snrPer.per << ", size=" << packet->GetSize ());

      if (m_random->GetValue () > snrPer.per)
        {
          NotifyRxEnd (packet);
          SignalNoiseDbm signalNoise;
          signalNoise.signal = RatioToDb (event->GetRxPowerW ()) + 30;
          signalNoise.noise = RatioToDb (event->GetRxPowerW () / snrPer.snr) - GetRxNoiseFigure () + 30;
          MpduInfo aMpdu;
          aMpdu.type = mpdutype;
          aMpdu.mpduRefNumber = m_rxMpduReferenceNumber;
          NotifyMonitorSniffRx (packet, (uint16_t)GetFrequency (), GetChannelNumber (), event->GetTxVector (), aMpdu, signalNoise);
          m_state->SwitchFromRxEndOk (packet, snrPer.snr, event->GetTxVector ());
        }
      else
        {
          /* failure. */
          NotifyRxDrop (packet);
          m_state->SwitchFromRxEndError (packet, snrPer.snr);
        }
    }
  else
    {
      m_state->SwitchFromRxEndError (packet, snrPer.snr);
    }

  if (preamble == WIFI_PREAMBLE_NONE && mpdutype == LAST_MPDU_IN_AGGREGATE)
    {
      m_plcpSuccess = false;
    }
}

} //namespace ns3




  void SetChannel (Ptr<YansWifiChannel> channel);

  /**
   * \param packet the packet to send
   * \param txVector the TXVECTOR that has tx parameters such as mode, the transmission mode to use to send
   *        this packet, and txPowerLevel, a power level to use to send this packet. The real transmission
   *        power is calculated as txPowerMin + txPowerLevel * (txPowerMax - txPowerMin) / nTxLevels
   * \param txDuration duration of the transmission.
   */
  void StartTx (Ptr<Packet> packet, WifiTxVector txVector, Time txDuration);
                                      double rxPowerDbm,
                                      Time rxDuration);
  /**
   * Starting receiving the payload of a packet (i.e. the first bit of the packet has arrived).
   *
   * \param packet the arriving packet
   * \param txVector the TXVECTOR of the arriving packet
   * \param mpdutype the type of the MPDU as defined in WifiPhy::MpduType.
   * \param event the corresponding event of the first time the packet arrives
   */
  void StartReceivePacket (Ptr<Packet> packet,
                           WifiTxVector txVector,
                           MpduType mpdutype,
                           Ptr<InterferenceHelper::Event> event);

  virtual void SetReceiveOkCallback (WifiPhy::RxOkCallback callback);
  virtual void SetReceiveErrorCallback (WifiPhy::RxErrorCallback callback);
  virtual void SendPacket (Ptr<const Packet> packet, WifiTxVector txVector, MpduType mpdutype = NORMAL_MPDU);
  virtual void RegisterListener (WifiPhyListener *listener);
  virtual void UnregisterListener (WifiPhyListener *listener);
  virtual void SetSleepMode (void);
  virtual void ResumeFromSleep (void);
  virtual Ptr<WifiChannel> GetChannel (void) const;


protected:
  // Inherited
  virtual void DoDispose (void);

  virtual bool DoFrequencySwitch (uint32_t frequency);

private:
  /**
   * The last bit of the packet has arrived.
   *
   * \param packet the packet that the last bit has arrived
   * \param preamble the preamble of the arriving packet
   * \param mpdutype the type of the MPDU as defined in WifiPhy::MpduType.
   * \param event the corresponding event of the first time the packet arrives
   */
  void EndReceive (Ptr<Packet> packet, WifiPreamble preamble, MpduType mpdutype, Ptr<InterferenceHelper::Event> event);

  Ptr<YansWifiChannel> m_channel; //!< YansWifiChannel that this YansWifiPhy is connected to
};


(-)a/src/wifi/test/spectrum-wifi-phy-test.cc (-3 / +11 lines)

Lines 48-54	Link Here

  Ptr<SpectrumWifiPhy> m_phy;

  Ptr<SpectrumWifiPhy> m_phy;

  Ptr<SpectrumSignalParameters> MakeSignal (double txPowerWatts);

  Ptr<SpectrumSignalParameters> MakeSignal (double txPowerWatts);

  void SendSignal (double txPowerWatts);

  void SendSignal (double txPowerWatts);

  void SpectrumWifiPhyReceiver (bool rxSucceeded);

  void SpectrumWifiPhyRxSuccess (Ptr<Packet> p, double snr, WifiTxVector txVector);

  void SpectrumWifiPhyRxFailure (Ptr<Packet> p, double snr);

  uint32_t m_count;

  uint32_t m_count;

private:

private:

  virtual void DoRun (void);

  virtual void DoRun (void);

Lines 104-110	Link Here

104

105

106

void

107

void

107

SpectrumWifiPhyBasicTest::SpectrumWifiPhyReceiver (bool rxSucceeded)

108

SpectrumWifiPhyBasicTest::SpectrumWifiPhyRxSuccess (Ptr<Packet> p, double snr, WifiTxVector txVector)

109

110

  m_count++;

111

112

113

void

114

SpectrumWifiPhyBasicTest::SpectrumWifiPhyRxFailure (Ptr<Packet> p, double snr)

108

115

109

  m_count++;

116

  m_count++;

110

117

Lines 124-130	Link Here

124

  m_phy->SetErrorRateModel (error);

131

  m_phy->SetErrorRateModel (error);

125

  m_phy->SetChannelNumber (CHANNEL_NUMBER);

132

  m_phy->SetChannelNumber (CHANNEL_NUMBER);

126

  m_phy->SetFrequency (FREQUENCY);

133

  m_phy->SetFrequency (FREQUENCY);

127

  m_phy->SetPacketReceivedCallback (MakeCallback (&SpectrumWifiPhyBasicTest::SpectrumWifiPhyReceiver, this));

134

  m_phy->SetReceiveOkCallback (MakeCallback (&SpectrumWifiPhyBasicTest::SpectrumWifiPhyRxSuccess, this));

135

  m_phy->SetReceiveErrorCallback (MakeCallback (&SpectrumWifiPhyBasicTest::SpectrumWifiPhyRxFailure, this));

128

  //Bug 2460: CcaMode1Threshold default should be set to -62 dBm when using Spectrum

136

  //Bug 2460: CcaMode1Threshold default should be set to -62 dBm when using Spectrum

129

  m_phy->SetCcaMode1Threshold (-62.0);

137

  m_phy->SetCcaMode1Threshold (-62.0);

130

138

(-)a/src/wifi/wscript (+2 lines)

Lines 3-8	Link Here

def build(bld):

def build(bld):

    obj = bld.create_ns3_module('wifi', ['network', 'propagation', 'energy', 'spectrum', 'antenna', 'mobility'])

    obj = bld.create_ns3_module('wifi', ['network', 'propagation', 'energy', 'spectrum', 'antenna', 'mobility'])

    obj.source = [

    obj.source = [

        'model/wifi-utils.cc',

        'model/wifi-information-element.cc',

        'model/wifi-information-element.cc',

        'model/wifi-information-element-vector.cc',

        'model/wifi-information-element-vector.cc',

        'model/wifi-channel.cc',

        'model/wifi-channel.cc',

Lines 107-112	Link Here

107

    headers = bld(features='ns3header')

108

    headers = bld(features='ns3header')

108

    headers.module = 'wifi'

109

    headers.module = 'wifi'

109

    headers.source = [

110

    headers.source = [

111

        'model/wifi-utils.h',

110

        'model/wifi-information-element.h',

112

        'model/wifi-information-element.h',

111

        'model/wifi-information-element-vector.h',

113

        'model/wifi-information-element-vector.h',

112

        'model/wifi-net-device.h',

114

        'model/wifi-net-device.h',

Return to bug 2552