/* -*-  Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */

/*

 * Copyright (c) 2011 The Boeing Company

 *

 * 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:

 *  Gary Pei <guangyu.pei@boeing.com>

 *  Sascha Alexander Jopen <jopen@cs.uni-bonn.de>

 */

#include "lr-wpan-phy.h"

#include "lr-wpan-lqi-tag.h"

#include "lr-wpan-spectrum-signal-parameters.h"

#include "lr-wpan-spectrum-value-helper.h"

#include "lr-wpan-error-model.h"

#include "lr-wpan-net-device.h"

#include <ns3/log.h>

#include <ns3/abort.h>

#include <ns3/simulator.h>

#include <ns3/spectrum-value.h>

#include <ns3/antenna-model.h>

#include <ns3/mobility-model.h>

#include <ns3/spectrum-channel.h>

#include <ns3/packet.h>

#include <ns3/packet-burst.h>

#include <ns3/net-device.h>

#include <ns3/random-variable-stream.h>

#include <ns3/double.h>

namespace ns3 {

NS_LOG_COMPONENT_DEFINE ("LrWpanPhy");

NS_OBJECT_ENSURE_REGISTERED (LrWpanPhy);

// Table 22 in section 6.4.1 of ieee802.15.4

const uint32_t LrWpanPhy::aMaxPhyPacketSize = 127; // max PSDU in octets

const uint32_t LrWpanPhy::aTurnaroundTime = 12;  // RX-to-TX or TX-to-RX in symbol periods

// IEEE802.15.4-2006 Table 2 in section 6.1.2 (kb/s and ksymbol/s)

// The index follows LrWpanPhyOption

const LrWpanPhyDataAndSymbolRates

LrWpanPhy::dataSymbolRates[7] = { { 20.0, 20.0},

                                  { 40.0, 40.0},

                                  { 250.0, 12.5},

                                  { 250.0, 50.0},

                                  { 100.0, 25.0},

                                  { 250.0, 62.5},

                                  { 250.0, 62.5}};

// IEEE802.15.4-2006 Table 19 and Table 20 in section 6.3.

// The PHR is 1 octet and it follows phySymbolsPerOctet in Table 23

// The index follows LrWpanPhyOption

const LrWpanPhyPpduHeaderSymbolNumber

LrWpanPhy::ppduHeaderSymbolNumbers[7] = { { 32.0, 8.0, 8.0},

                                          { 32.0, 8.0, 8.0},

                                          { 2.0, 1.0, 0.4},

                                          { 6.0, 1.0, 1.6},

                                          { 8.0, 2.0, 2.0},

                                          { 8.0, 2.0, 2.0},

                                          { 8.0, 2.0, 2.0}};

TypeId

LrWpanPhy::GetTypeId (void)

{

  static TypeId tid = TypeId ("ns3::LrWpanPhy")

    .SetParent<Object> ()

    .AddConstructor<LrWpanPhy> ()

    .AddTraceSource ("TrxState",

                     "The state of the transceiver",

                     MakeTraceSourceAccessor (&LrWpanPhy::m_trxStateLogger),

                     "ns3::LrWpanPhy::StateTracedCallback")

    .AddTraceSource ("PhyTxBegin",

                     "Trace source indicating a packet has "

                     "begun transmitting over the channel medium",

                     MakeTraceSourceAccessor (&LrWpanPhy::m_phyTxBeginTrace),

                     "ns3::Packet::TracedCallback")

    .AddTraceSource ("PhyTxEnd",

                     "Trace source indicating a packet has been "

                     "completely transmitted over the channel.",

                     MakeTraceSourceAccessor (&LrWpanPhy::m_phyTxEndTrace),

                     "ns3::Packet::TracedCallback")

    .AddTraceSource ("PhyTxDrop",

                     "Trace source indicating a packet has been "

                     "dropped by the device during transmission",

                     MakeTraceSourceAccessor (&LrWpanPhy::m_phyTxDropTrace),

                     "ns3::Packet::TracedCallback")

    .AddTraceSource ("PhyRxBegin",

                     "Trace source indicating a packet has begun "

                     "being received from the channel medium by the device",

                     MakeTraceSourceAccessor (&LrWpanPhy::m_phyRxBeginTrace),

                     "ns3::Packet::TracedCallback")

    .AddTraceSource ("PhyRxEnd",

                     "Trace source indicating a packet has been "

                     "completely received from the channel medium "

                     "by the device",

                     MakeTraceSourceAccessor (&LrWpanPhy::m_phyRxEndTrace),

                     "ns3::LrWpanPhy::RxEndTracedCallback")

    .AddTraceSource ("PhyRxDrop",

                     "Trace source indicating a packet has been "

                     "dropped by the device during reception",

                     MakeTraceSourceAccessor (&LrWpanPhy::m_phyRxDropTrace),

                     "ns3::Packet::TracedCallback")

  ;

  return tid;

}

LrWpanPhy::LrWpanPhy (void)

  : m_edRequest (),

    m_setTRXState ()

{

  m_trxState = IEEE_802_15_4_PHY_TRX_OFF;

  m_trxStatePending = IEEE_802_15_4_PHY_IDLE;

  // default PHY PIB attributes

  m_phyPIBAttributes.phyCurrentChannel = 11;

  m_phyPIBAttributes.phyTransmitPower = 0;

  m_phyPIBAttributes.phyCurrentPage = 0;

  for (uint32_t i = 0; i < 32; i++)

    {

      m_phyPIBAttributes.phyChannelsSupported[i] = 0x07ffffff;

    }

  m_phyPIBAttributes.phyCCAMode = 1;

  SetMyPhyOption ();

  m_edPower.averagePower = 0.0;

  m_edPower.lastUpdate = Seconds (0.0);

  m_edPower.measurementLength = Seconds (0.0);

  // default -110 dBm in W for 2.4 GHz

  m_rxSensitivity = pow (10.0, -106.58 / 10.0) / 1000.0;

  LrWpanSpectrumValueHelper psdHelper;

  m_txPsd = psdHelper.CreateTxPowerSpectralDensity (m_phyPIBAttributes.phyTransmitPower,

                                                    m_phyPIBAttributes.phyCurrentChannel);

  m_noise = psdHelper.CreateNoisePowerSpectralDensity (m_phyPIBAttributes.phyCurrentChannel);

  m_signal = Create<LrWpanInterferenceHelper> (m_noise->GetSpectrumModel ());

  m_rxLastUpdate = Seconds (0);

  Ptr<Packet> none_packet = 0;

  Ptr<LrWpanSpectrumSignalParameters> none_params = 0;

  m_currentRxPacket = std::make_pair (none_params, true);

  m_currentTxPacket = std::make_pair (none_packet, true);

  m_errorModel = 0;

  m_random = CreateObject<UniformRandomVariable> ();

  m_random->SetAttribute ("Min", DoubleValue (0.0));

  m_random->SetAttribute ("Max", DoubleValue (1.0));

  ChangeTrxState (IEEE_802_15_4_PHY_TRX_OFF);

}

LrWpanPhy::~LrWpanPhy (void)

{

}

void

LrWpanPhy::DoDispose (void)

{

  NS_LOG_FUNCTION (this);

  // Cancel pending transceiver state change, if one is in progress.

  m_setTRXState.Cancel ();

  m_trxState = IEEE_802_15_4_PHY_TRX_OFF;

  m_trxStatePending = IEEE_802_15_4_PHY_IDLE;

  m_mobility = 0;

  m_device = 0;

  m_channel = 0;

  m_txPsd = 0;

  m_noise = 0;

  m_signal = 0;

  m_errorModel = 0;

  m_pdDataIndicationCallback = MakeNullCallback< void, uint32_t, Ptr<Packet>, uint8_t > ();

  m_pdDataConfirmCallback = MakeNullCallback< void, LrWpanPhyEnumeration > ();

  m_plmeCcaConfirmCallback = MakeNullCallback< void, LrWpanPhyEnumeration > ();

  m_plmeEdConfirmCallback = MakeNullCallback< void, LrWpanPhyEnumeration,uint8_t > ();

  m_plmeGetAttributeConfirmCallback = MakeNullCallback< void, LrWpanPhyEnumeration, LrWpanPibAttributeIdentifier, LrWpanPhyPibAttributes* > ();

  m_plmeSetTRXStateConfirmCallback = MakeNullCallback< void, LrWpanPhyEnumeration > ();

  m_plmeSetAttributeConfirmCallback = MakeNullCallback< void, LrWpanPhyEnumeration, LrWpanPibAttributeIdentifier > ();

  SpectrumPhy::DoDispose ();

}

Ptr<NetDevice>

LrWpanPhy::GetDevice (void)

{

  NS_LOG_FUNCTION (this);

  return m_device;

}

Ptr<MobilityModel>

LrWpanPhy::GetMobility (void)

{

  NS_LOG_FUNCTION (this);

  return m_mobility;

}

void

LrWpanPhy::SetDevice (Ptr<NetDevice> d)

{

  NS_LOG_FUNCTION (this << d);

  m_device = d;

}

void

LrWpanPhy::SetMobility (Ptr<MobilityModel> m)

{

  NS_LOG_FUNCTION (this << m);

  m_mobility = m;

}

void

LrWpanPhy::SetChannel (Ptr<SpectrumChannel> c)

{

  NS_LOG_FUNCTION (this << c);

  m_channel = c;

}

Ptr<SpectrumChannel>

LrWpanPhy::GetChannel (void)

{

  NS_LOG_FUNCTION (this);

  return m_channel;

}

Ptr<const SpectrumModel>

LrWpanPhy::GetRxSpectrumModel (void) const

{

  NS_LOG_FUNCTION (this);

  if (m_txPsd)

    {

      return m_txPsd->GetSpectrumModel ();

    }

  else

    {

      return 0;

    }

}

Ptr<AntennaModel>

LrWpanPhy::GetRxAntenna (void)

{

  NS_LOG_FUNCTION (this);

  return m_antenna;

}

void

LrWpanPhy::SetAntenna (Ptr<AntennaModel> a)

{

  NS_LOG_FUNCTION (this << a);

  m_antenna = a;

}

void

LrWpanPhy::StartRx (Ptr<SpectrumSignalParameters> spectrumRxParams)

{

  NS_LOG_FUNCTION (this << spectrumRxParams);

  LrWpanSpectrumValueHelper psdHelper;

  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 ())

    {

      // The specification doesn't seem to refer to BUSY_RX, but vendor

      // data sheets suggest that this is a substate of the RX_ON state

      // that is entered after preamble detection when the digital receiver

      // is enabled.  Here, for now, we use BUSY_RX to mark the period between

      // StartRx() and EndRx() states.

      // We are going to BUSY_RX state when receiving the first bit of an SHR,

      // as opposed to real receivers, which should go to this state only after

      // successfully receiving the SHR.

      // If synchronizing to the packet is possible, change to BUSY_RX state,

      // otherwise drop the packet and stay in RX state. The actual synchronization

      // is not modeled.

      // 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.

      // It's useless to even *try* to decode the packet.

      if (10 * log10 (sinr) > -5)

        {

          ChangeTrxState (IEEE_802_15_4_PHY_BUSY_RX);

          m_currentRxPacket = std::make_pair (lrWpanRxParams, false);

          m_phyRxBeginTrace (p);

          m_rxLastUpdate = Simulator::Now ();

        }

      else

        {

          m_phyRxDropTrace (p);

        }

    }

  else if (m_trxState == IEEE_802_15_4_PHY_BUSY_RX)

    {

      // Drop the new packet.

      NS_LOG_DEBUG (this << " packet collision");

      m_phyRxDropTrace (p);

      // Check if we correctly received the old packet up to now.

      CheckInterference ();

      // Add the incoming packet to the current interference after we have

      // checked for successfull reception of the current packet for the time

      // before the additional interference.

      m_signal->AddSignal (lrWpanRxParams->psd);

    }

  else

    {

      // Simply drop the packet.

      NS_LOG_DEBUG (this << " transceiver not in RX state");

      m_phyRxDropTrace (p);

      // Add the signal power to the interference, anyway.

      m_signal->AddSignal (lrWpanRxParams->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;

        }

    }

  // 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

LrWpanPhy::CheckInterference (void)

{

  // Calculate whether packet was lost.

  LrWpanSpectrumValueHelper psdHelper;

  Ptr<LrWpanSpectrumSignalParameters> currentRxParams = m_currentRxPacket.first;

  // We are currently receiving a packet.

  if (m_trxState == IEEE_802_15_4_PHY_BUSY_RX)

    {

      // NS_ASSERT (currentRxParams && !m_currentRxPacket.second);

      Ptr<Packet> currentPacket = currentRxParams->packetBurst->GetPackets ().front ();

      if (m_errorModel != 0)

        {

          // How many bits did we receive since the last calculation?

          double t = (Simulator::Now () - m_rxLastUpdate).ToDouble (Time::MS);

          uint32_t chunkSize = ceil (t * (GetDataOrSymbolRate (true) / 1000));

          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.

          // If not already set, initialize to 255.

          LrWpanLqiTag tag (std::numeric_limits<uint8_t>::max ());

          currentPacket->PeekPacketTag (tag);

          uint8_t lqi = tag.Get ();

          tag.Set (lqi - (per * lqi));

          currentPacket->ReplacePacketTag (tag);

          if (m_random->GetValue () < per)

            {

              // The packet was destroyed, drop the packet after reception.

              m_currentRxPacket.second = true;

            }

        }

      else

        {

          NS_LOG_WARN ("Missing ErrorModel");

        }

    }

  m_rxLastUpdate = Simulator::Now ();

}

void

LrWpanPhy::EndRx (Ptr<SpectrumSignalParameters> par)

{

  NS_LOG_FUNCTION (this);

  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)

    {

      Ptr<Packet> currentPacket = currentRxParams->packetBurst->GetPackets ().front ();

      NS_ASSERT (currentPacket != 0);

      // If there is no error model attached to the PHY, we always report the maximum LQI value.

      LrWpanLqiTag tag (std::numeric_limits<uint8_t>::max ());

      currentPacket->PeekPacketTag (tag);

      m_phyRxEndTrace (currentPacket, tag.Get ());

      if (!m_currentRxPacket.second)

        {

          // The packet was successfully received, push it up the stack.

          if (!m_pdDataIndicationCallback.IsNull ())

            {

              m_pdDataIndicationCallback (currentPacket->GetSize (), currentPacket, tag.Get ());

            }

        }

      else

        {

          // The packet was destroyed, drop it.

          m_phyRxDropTrace (currentPacket);

        }

      Ptr<LrWpanSpectrumSignalParameters> none = 0;

      m_currentRxPacket = std::make_pair (none, true);

      // We may be waiting to apply a pending state change.

      if (m_trxStatePending != IEEE_802_15_4_PHY_IDLE)

        {

          // Only change the state immediately, if the transceiver is not already

          // switching the state.