/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2010 TELEMATICS LAB, DEE - Politecnico di Bari
*
* 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: Giuseppe Piro <g.piro@poliba.it>
* Marco Miozzo <marco.miozzo@cttc.es>
* Nicola Baldo <nbaldo@cttc.es>
*/
#include <ns3/object-factory.h>
#include <ns3/log.h>
#include <cfloat>
#include <cmath>
#include <ns3/simulator.h>
#include <ns3/double.h>
#include "lte-ue-phy.h"
#include "lte-enb-phy.h"
#include "lte-net-device.h"
#include "lte-ue-net-device.h"
#include "lte-enb-net-device.h"
#include "lte-spectrum-value-helper.h"
#include "lte-amc.h"
#include "lte-ue-mac.h"
#include "ff-mac-common.h"
#include "lte-sinr-chunk-processor.h"
#include <ns3/lte-common.h>
#include <ns3/pointer.h>
NS_LOG_COMPONENT_DEFINE ("LteUePhy");
namespace ns3 {
// duration of data portion of UL subframe
// = TTI - 1 symbol for SRS - 1ns as margin to avoid overlapping simulator events
// (symbol duration in nanoseconds = TTI / 14 (rounded))
// in other words, duration of data portion of UL subframe = TTI*(13/14) -1ns
static const Time UL_DATA_DURATION = NanoSeconds (1e6 - 71429 - 1);
// delay from subframe start to transmission of SRS
// = TTI - 1 symbol for SRS
static const Time UL_SRS_DELAY_FROM_SUBFRAME_START = NanoSeconds (1e6 - 71429);
////////////////////////////////////////
// member SAP forwarders
////////////////////////////////////////
class UeMemberLteUePhySapProvider : public LteUePhySapProvider
{
public:
UeMemberLteUePhySapProvider (LteUePhy* phy);
// inherited from LtePhySapProvider
virtual void SendMacPdu (Ptr<Packet> p);
virtual void SendLteControlMessage (Ptr<LteControlMessage> msg);
virtual void SendRachPreamble (uint32_t prachId, uint32_t raRnti);
private:
LteUePhy* m_phy;
};
UeMemberLteUePhySapProvider::UeMemberLteUePhySapProvider (LteUePhy* phy) : m_phy (phy)
{
}
void
UeMemberLteUePhySapProvider::SendMacPdu (Ptr<Packet> p)
{
m_phy->DoSendMacPdu (p);
}
void
UeMemberLteUePhySapProvider::SendLteControlMessage (Ptr<LteControlMessage> msg)
{
m_phy->DoSendLteControlMessage (msg);
}
void
UeMemberLteUePhySapProvider::SendRachPreamble (uint32_t prachId, uint32_t raRnti)
{
m_phy->DoSendRachPreamble (prachId, raRnti);
}
////////////////////////////////////////
// LteUePhy methods
////////////////////////////////////////
const char* g_uePhyStateName[LteUePhy::NUM_STATES] =
{
"CELL_SEARCH",
"SYNCHRONIZED"
};
std::string ToString (LteUePhy::State s)
{
return std::string (g_uePhyStateName[s]);
}
NS_OBJECT_ENSURE_REGISTERED (LteUePhy);
LteUePhy::LteUePhy ()
{
NS_LOG_FUNCTION (this);
NS_FATAL_ERROR ("This constructor should not be called");
}
LteUePhy::LteUePhy (Ptr<LteSpectrumPhy> dlPhy, Ptr<LteSpectrumPhy> ulPhy)
: LtePhy (dlPhy, ulPhy),
m_p10CqiPeriocity (MilliSeconds (1)), // ideal behavior
m_a30CqiPeriocity (MilliSeconds (1)), // ideal behavior
m_uePhySapUser (0),
m_ueCphySapUser (0),
m_state (CELL_SEARCH),
m_subframeNo (0),
m_rsReceivedPowerUpdated (false),
m_rsInterferencePowerUpdated (false),
m_pssReceived (false),
m_ueMeasurementsFilterPeriod (MilliSeconds (200)),
m_ueMeasurementsFilterLast (MilliSeconds (0)),
m_rsrpSinrSampleCounter (0)
{
m_amc = CreateObject <LteAmc> ();
m_uePhySapProvider = new UeMemberLteUePhySapProvider (this);
m_ueCphySapProvider = new MemberLteUeCphySapProvider<LteUePhy> (this);
m_macChTtiDelay = UL_PUSCH_TTIS_DELAY;
NS_ASSERT_MSG (Simulator::Now ().GetNanoSeconds () == 0,
"Cannot create UE devices after simulation started");
Simulator::ScheduleNow (&LteUePhy::SubframeIndication, this, 1, 1);
Simulator::Schedule (m_ueMeasurementsFilterPeriod, &LteUePhy::ReportUeMeasurements, this);
DoReset ();
}
LteUePhy::~LteUePhy ()
{
m_txModeGain.clear ();
}
void
LteUePhy::DoDispose ()
{
NS_LOG_FUNCTION (this);
delete m_uePhySapProvider;
delete m_ueCphySapProvider;
LtePhy::DoDispose ();
}
TypeId
LteUePhy::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::LteUePhy")
.SetParent<LtePhy> ()
.AddConstructor<LteUePhy> ()
.AddAttribute ("TxPower",
"Transmission power in dBm",
DoubleValue (10.0),
MakeDoubleAccessor (&LteUePhy::SetTxPower,
&LteUePhy::GetTxPower),
MakeDoubleChecker<double> ())
.AddAttribute ("NoiseFigure",
"Loss (dB) in the Signal-to-Noise-Ratio due to non-idealities in the receiver."
" According to Wikipedia (http://en.wikipedia.org/wiki/Noise_figure), this is "
"\"the difference in decibels (dB) between"
" the noise output of the actual receiver to the noise output of an "
" ideal receiver with the same overall gain and bandwidth when the receivers "
" are connected to sources at the standard noise temperature T0.\" "
"In this model, we consider T0 = 290K.",
DoubleValue (9.0),
MakeDoubleAccessor (&LteUePhy::SetNoiseFigure,
&LteUePhy::GetNoiseFigure),
MakeDoubleChecker<double> ())
.AddAttribute ("TxMode1Gain",
"Transmission mode 1 gain in dB",
DoubleValue (0.0),
MakeDoubleAccessor (&LteUePhy::SetTxMode1Gain),
MakeDoubleChecker<double> ())
.AddAttribute ("TxMode2Gain",
"Transmission mode 2 gain in dB",
DoubleValue (4.2),
MakeDoubleAccessor (&LteUePhy::SetTxMode2Gain),
MakeDoubleChecker<double> ())
.AddAttribute ("TxMode3Gain",
"Transmission mode 3 gain in dB",
DoubleValue (-2.8),
MakeDoubleAccessor (&LteUePhy::SetTxMode3Gain),
MakeDoubleChecker<double> ())
.AddAttribute ("TxMode4Gain",
"Transmission mode 4 gain in dB",
DoubleValue (0.0),
MakeDoubleAccessor (&LteUePhy::SetTxMode4Gain),
MakeDoubleChecker<double> ())
.AddAttribute ("TxMode5Gain",
"Transmission mode 5 gain in dB",
DoubleValue (0.0),
MakeDoubleAccessor (&LteUePhy::SetTxMode5Gain),
MakeDoubleChecker<double> ())
.AddAttribute ("TxMode6Gain",
"Transmission mode 6 gain in dB",
DoubleValue (0.0),
MakeDoubleAccessor (&LteUePhy::SetTxMode6Gain),
MakeDoubleChecker<double> ())
.AddAttribute ("TxMode7Gain",
"Transmission mode 7 gain in dB",
DoubleValue (0.0),
MakeDoubleAccessor (&LteUePhy::SetTxMode7Gain),
MakeDoubleChecker<double> ())
.AddTraceSource ("ReportCurrentCellRsrpSinr",
"RSRP and SINR statistics.",
MakeTraceSourceAccessor (&LteUePhy::m_reportCurrentCellRsrpSinrTrace))
.AddAttribute ("RsrpSinrSamplePeriod",
"The sampling period for reporting RSRP-SINR stats (default value 1)",
UintegerValue (1),
MakeUintegerAccessor (&LteUePhy::m_rsrpSinrSamplePeriod),
MakeUintegerChecker<uint16_t> ())
.AddTraceSource ("UlPhyTransmission",
"DL transmission PHY layer statistics.",
MakeTraceSourceAccessor (&LteUePhy::m_ulPhyTransmission))
.AddAttribute ("DlSpectrumPhy",
"The downlink LteSpectrumPhy associated to this LtePhy",
TypeId::ATTR_GET,
PointerValue (),
MakePointerAccessor (&LteUePhy::GetDlSpectrumPhy),
MakePointerChecker <LteSpectrumPhy> ())
.AddAttribute ("UlSpectrumPhy",
"The uplink LteSpectrumPhy associated to this LtePhy",
TypeId::ATTR_GET,
PointerValue (),
MakePointerAccessor (&LteUePhy::GetUlSpectrumPhy),
MakePointerChecker <LteSpectrumPhy> ())
.AddAttribute ("RsrqUeMeasThreshold",
"Receive threshold for PSS on RSRQ [dB]",
DoubleValue (-1000.0),
MakeDoubleAccessor (&LteUePhy::m_pssReceptionThreshold),
MakeDoubleChecker<double> ())
.AddAttribute ("UeMeasurementsFilterPeriod",
"Time period for reporting UE measurements (default 200 ms.) ",
TimeValue (MilliSeconds (200)),
MakeTimeAccessor (&LteUePhy::m_ueMeasurementsFilterPeriod),
MakeTimeChecker ())
.AddTraceSource ("ReportUeMeasurements",
"Report UE measurements RSRP (dBm) and RSRQ (dB).",
MakeTraceSourceAccessor (&LteUePhy::m_reportUeMeasurements))
.AddTraceSource ("StateTransition",
"Trace fired upon every UE PHY state transition",
MakeTraceSourceAccessor (&LteUePhy::m_stateTransitionTrace))
;
return tid;
}
void
LteUePhy::DoInitialize ()
{
NS_LOG_FUNCTION (this);
LtePhy::DoInitialize ();
}
void
LteUePhy::SetLteUePhySapUser (LteUePhySapUser* s)
{
NS_LOG_FUNCTION (this);
m_uePhySapUser = s;
}
LteUePhySapProvider*
LteUePhy::GetLteUePhySapProvider ()
{
NS_LOG_FUNCTION (this);
return (m_uePhySapProvider);
}
void
LteUePhy::SetLteUeCphySapUser (LteUeCphySapUser* s)
{
NS_LOG_FUNCTION (this);
m_ueCphySapUser = s;
}
LteUeCphySapProvider*
LteUePhy::GetLteUeCphySapProvider ()
{
NS_LOG_FUNCTION (this);
return (m_ueCphySapProvider);
}
void
LteUePhy::SetNoiseFigure (double nf)
{
NS_LOG_FUNCTION (this << nf);
m_noiseFigure = nf;
}
double
LteUePhy::GetNoiseFigure () const
{
NS_LOG_FUNCTION (this);
return m_noiseFigure;
}
void
LteUePhy::SetTxPower (double pow)
{
NS_LOG_FUNCTION (this << pow);
m_txPower = pow;
}
double
LteUePhy::GetTxPower () const
{
NS_LOG_FUNCTION (this);
return m_txPower;
}
uint8_t
LteUePhy::GetMacChDelay (void) const
{
return (m_macChTtiDelay);
}
Ptr<LteSpectrumPhy>
LteUePhy::GetDlSpectrumPhy () const
{
return m_downlinkSpectrumPhy;
}
Ptr<LteSpectrumPhy>
LteUePhy::GetUlSpectrumPhy () const
{
return m_uplinkSpectrumPhy;
}
void
LteUePhy::DoSendMacPdu (Ptr<Packet> p)
{
NS_LOG_FUNCTION (this);
SetMacPdu (p);
}
void
LteUePhy::PhyPduReceived (Ptr<Packet> p)
{
m_uePhySapUser->ReceivePhyPdu (p);
}
void
LteUePhy::SetSubChannelsForTransmission (std::vector <int> mask)
{
NS_LOG_FUNCTION (this);
m_subChannelsForTransmission = mask;
Ptr<SpectrumValue> txPsd = CreateTxPowerSpectralDensity ();
m_uplinkSpectrumPhy->SetTxPowerSpectralDensity (txPsd);
}
void
LteUePhy::SetSubChannelsForReception (std::vector <int> mask)
{
NS_LOG_FUNCTION (this);
m_subChannelsForReception = mask;
}
std::vector <int>
LteUePhy::GetSubChannelsForTransmission ()
{
NS_LOG_FUNCTION (this);
return m_subChannelsForTransmission;
}
std::vector <int>
LteUePhy::GetSubChannelsForReception ()
{
NS_LOG_FUNCTION (this);
return m_subChannelsForReception;
}
Ptr<SpectrumValue>
LteUePhy::CreateTxPowerSpectralDensity ()
{
NS_LOG_FUNCTION (this);
LteSpectrumValueHelper psdHelper;
Ptr<SpectrumValue> psd = psdHelper.CreateTxPowerSpectralDensity (m_ulEarfcn, m_ulBandwidth, m_txPower, GetSubChannelsForTransmission ());
return psd;
}
void
LteUePhy::GenerateCtrlCqiReport (const SpectrumValue& sinr)
{
NS_LOG_FUNCTION (this);
NS_ASSERT (m_state != CELL_SEARCH);
NS_ASSERT (m_cellId > 0);
if (m_dlConfigured && m_ulConfigured && (m_rnti > 0))
{
// check periodic wideband CQI
if (Simulator::Now () > m_p10CqiLast + m_p10CqiPeriocity)
{
Ptr<LteUeNetDevice> thisDevice = GetDevice ()->GetObject<LteUeNetDevice> ();
Ptr<DlCqiLteControlMessage> msg = CreateDlCqiFeedbackMessage (sinr);
if (msg)
{
DoSendLteControlMessage (msg);
}
m_p10CqiLast = Simulator::Now ();
}
// check aperiodic high-layer configured subband CQI
if (Simulator::Now () > m_a30CqiLast + m_a30CqiPeriocity)
{
Ptr<LteUeNetDevice> thisDevice = GetDevice ()->GetObject<LteUeNetDevice> ();
Ptr<DlCqiLteControlMessage> msg = CreateDlCqiFeedbackMessage (sinr);
if (msg)
{
DoSendLteControlMessage (msg);
}
m_a30CqiLast = Simulator::Now ();
}
}
// Generate PHY trace
m_rsrpSinrSampleCounter++;
if (m_rsrpSinrSampleCounter==m_rsrpSinrSamplePeriod)
{
NS_ASSERT_MSG (m_rsReceivedPowerUpdated, " RS received power info obsolete");
// RSRP evaluated as averaged received power among RBs
double sum = 0.0;
uint8_t rbNum = 0;
Values::const_iterator it;
for (it = m_rsReceivedPower.ConstValuesBegin (); it != m_rsReceivedPower.ConstValuesEnd (); it++)
{
// convert PSD [W/Hz] to linear power [W] for the single RE
// we consider only one RE for the RS since the channel is
// flat within the same RB
double powerTxW = ((*it) * 180000.0) / 12.0;
sum += powerTxW;
rbNum++;
}
double rsrp = (rbNum > 0) ? (sum / rbNum) : DBL_MAX;
// averaged SINR among RBs
sum = 0.0;
rbNum = 0;
for (it = sinr.ConstValuesBegin (); it != sinr.ConstValuesEnd (); it++)
{
sum += (*it);
rbNum++;
}
double avSinr = (rbNum > 0) ? (sum / rbNum) : DBL_MAX;
NS_LOG_INFO (this << " cellId " << m_cellId << " rnti " << m_rnti << " RSRP " << rsrp << " SINR " << avSinr);
m_reportCurrentCellRsrpSinrTrace (m_cellId, m_rnti, rsrp, avSinr);
m_rsrpSinrSampleCounter = 0;
}
if (m_pssReceived)
{
// measure instantaneous RSRQ now
NS_ASSERT_MSG (m_rsInterferencePowerUpdated, " RS interference power info obsolete");
std::list <PssElement>::iterator itPss = m_pssList.begin ();
while (itPss != m_pssList.end ())
{
uint16_t rbNum = 0;
double rsrqSum = 0.0;
Values::const_iterator itIntN = m_rsInterferencePower.ConstValuesBegin ();
Values::const_iterator itPj = m_rsReceivedPower.ConstValuesBegin ();
for (itPj = m_rsReceivedPower.ConstValuesBegin ();
itPj != m_rsReceivedPower.ConstValuesEnd ();
itIntN++, itPj++)
{
rbNum++;
// convert PSD [W/Hz] to linear power [W] for the single RE
double noisePowerTxW = ((*itIntN) * 180000.0) / 12.0;
double intPowerTxW = ((*itPj) * 180000.0) / 12.0;
rsrqSum += (2 * (noisePowerTxW + intPowerTxW));
}
NS_ASSERT (rbNum == (*itPss).nRB);
double rsrq_dB = 10 * log10 ((*itPss).pssPsdSum / rsrqSum);
if (rsrq_dB > m_pssReceptionThreshold)
{
NS_LOG_INFO (this << " PSS RNTI " << m_rnti << " cellId " << m_cellId
<< " has RSRQ " << rsrq_dB << " and RBnum " << rbNum);
// store measurements
std::map <uint16_t, UeMeasurementsElement>::iterator itMeasMap;
itMeasMap = m_ueMeasurementsMap.find ((*itPss).cellId);
NS_ASSERT (itMeasMap != m_ueMeasurementsMap.end ());
(*itMeasMap).second.rsrqSum += rsrq_dB;
(*itMeasMap).second.rsrqNum++;
}
itPss++;
} // end of while (itPss != m_pssList.end ())
m_pssList.clear ();
} // end of if (m_pssReceived)
} // end of void LteUePhy::GenerateCtrlCqiReport (const SpectrumValue& sinr)
void
LteUePhy::GenerateDataCqiReport (const SpectrumValue& sinr)
{
// Not used by UE, CQI are based only on RS
}
void
LteUePhy::ReportInterference (const SpectrumValue& interf)
{
NS_LOG_FUNCTION (this << interf);
m_rsInterferencePowerUpdated = true;
m_rsInterferencePower = interf;
}
void
LteUePhy::ReportRsReceivedPower (const SpectrumValue& power)
{
NS_LOG_FUNCTION (this << power);
m_rsReceivedPowerUpdated = true;
m_rsReceivedPower = power;
}
Ptr<DlCqiLteControlMessage>
LteUePhy::CreateDlCqiFeedbackMessage (const SpectrumValue& sinr)
{
NS_LOG_FUNCTION (this);
// apply transmission mode gain
NS_ASSERT (m_transmissionMode < m_txModeGain.size ());
SpectrumValue newSinr = sinr;
newSinr *= m_txModeGain.at (m_transmissionMode);
// CREATE DlCqiLteControlMessage
Ptr<DlCqiLteControlMessage> msg = Create<DlCqiLteControlMessage> ();
CqiListElement_s dlcqi;
std::vector<int> cqi;
if (Simulator::Now () > m_p10CqiLast + m_p10CqiPeriocity)
{
cqi = m_amc->CreateCqiFeedbacks (newSinr, m_dlBandwidth);
int nLayer = TransmissionModesLayers::TxMode2LayerNum (m_transmissionMode);
int nbSubChannels = cqi.size ();
double cqiSum = 0.0;
int activeSubChannels = 0;
// average the CQIs of the different RBs
for (int i = 0; i < nbSubChannels; i++)
{
if (cqi.at (i) != -1)
{
cqiSum += cqi.at (i);
activeSubChannels++;
}
NS_LOG_DEBUG (this << " subch " << i << " cqi " << cqi.at (i));
}
dlcqi.m_rnti = m_rnti;
dlcqi.m_ri = 1; // not yet used
dlcqi.m_cqiType = CqiListElement_s::P10; // Peridic CQI using PUCCH wideband
NS_ASSERT_MSG (nLayer > 0, " nLayer negative");
NS_ASSERT_MSG (nLayer < 3, " nLayer limit is 2s");
for (int i = 0; i < nLayer; i++)
{
if (activeSubChannels > 0)
{
dlcqi.m_wbCqi.push_back ((uint16_t) cqiSum / activeSubChannels);
}
else
{
// approximate with the worst case -> CQI = 1
dlcqi.m_wbCqi.push_back (1);
}
}
//NS_LOG_DEBUG (this << " Generate P10 CQI feedback " << (uint16_t) cqiSum / activeSubChannels);
dlcqi.m_wbPmi = 0; // not yet used
// dl.cqi.m_sbMeasResult others CQI report modes: not yet implemented
}
else if (Simulator::Now () > m_a30CqiLast + m_a30CqiPeriocity)
{
cqi = m_amc->CreateCqiFeedbacks (newSinr, GetRbgSize ());
int nLayer = TransmissionModesLayers::TxMode2LayerNum (m_transmissionMode);
int nbSubChannels = cqi.size ();
int rbgSize = GetRbgSize ();
double cqiSum = 0.0;
int cqiNum = 0;
SbMeasResult_s rbgMeas;
//NS_LOG_DEBUG (this << " Create A30 CQI feedback, RBG " << rbgSize << " cqiNum " << nbSubChannels << " band " << (uint16_t)m_dlBandwidth);
for (int i = 0; i < nbSubChannels; i++)
{
if (cqi.at (i) != -1)
{
cqiSum += cqi.at (i);
}
// else "nothing" no CQI is treated as CQI = 0 (worst case scenario)
cqiNum++;
if (cqiNum == rbgSize)
{
// average the CQIs of the different RBGs
//NS_LOG_DEBUG (this << " RBG CQI " << (uint16_t) cqiSum / rbgSize);
HigherLayerSelected_s hlCqi;
hlCqi.m_sbPmi = 0; // not yet used
for (int i = 0; i < nLayer; i++)
{
hlCqi.m_sbCqi.push_back ((uint16_t) cqiSum / rbgSize);
}
rbgMeas.m_higherLayerSelected.push_back (hlCqi);
cqiSum = 0.0;
cqiNum = 0;
}
}
dlcqi.m_rnti = m_rnti;
dlcqi.m_ri = 1; // not yet used
dlcqi.m_cqiType = CqiListElement_s::A30; // Aperidic CQI using PUSCH
//dlcqi.m_wbCqi.push_back ((uint16_t) cqiSum / nbSubChannels);
dlcqi.m_wbPmi = 0; // not yet used
dlcqi.m_sbMeasResult = rbgMeas;
}
msg->SetDlCqi (dlcqi);
return msg;
}
void
LteUePhy::ReportUeMeasurements ()
{
NS_LOG_FUNCTION (this << Simulator::Now ());
NS_LOG_DEBUG (this << " Report UE Measurements ");
LteUeCphySapUser::UeMeasurementsParameters ret;
std::map <uint16_t, UeMeasurementsElement>::iterator it;
for (it = m_ueMeasurementsMap.begin (); it != m_ueMeasurementsMap.end (); it++)
{
double avg_rsrp = (*it).second.rsrpSum / (double)(*it).second.rsrpNum;
double avg_rsrq = (*it).second.rsrqSum / (double)(*it).second.rsrqNum;
/*
* In CELL_SEARCH state, this may result in avg_rsrq = 0/0 = -nan.
* UE RRC must take this into account when receiving measurement reports.
* TODO remove this shortcoming by calculating RSRQ during CELL_SEARCH
*/
NS_LOG_DEBUG (this << " CellId " << (*it).first
<< " RSRP " << avg_rsrp
<< " (nSamples " << (uint16_t)(*it).second.rsrpNum << ")"
<< " RSRQ " << avg_rsrq
<< " (nSamples " << (uint16_t)(*it).second.rsrqNum << ")");
LteUeCphySapUser::UeMeasurementsElement newEl;
newEl.m_cellId = (*it).first;
newEl.m_rsrp = avg_rsrp;
newEl.m_rsrq = avg_rsrq;
ret.m_ueMeasurementsList.push_back (newEl);
// report to UE measurements trace
m_reportUeMeasurements (m_rnti, (*it).first, avg_rsrp, avg_rsrq, ((*it).first == m_cellId ? 1 : 0));
}
// report to RRC
m_ueCphySapUser->ReportUeMeasurements (ret);
m_ueMeasurementsMap.clear ();
Simulator::Schedule (m_ueMeasurementsFilterPeriod, &LteUePhy::ReportUeMeasurements, this);
}
void
LteUePhy::DoSendLteControlMessage (Ptr<LteControlMessage> msg)
{
NS_LOG_FUNCTION (this << msg);
SetControlMessages (msg);
}
void
LteUePhy::DoSendRachPreamble (uint32_t raPreambleId, uint32_t raRnti)
{
NS_LOG_FUNCTION (this << raPreambleId);
// unlike other control messages, RACH preamble is sent ASAP
Ptr<RachPreambleLteControlMessage> msg = Create<RachPreambleLteControlMessage> ();
msg->SetRapId (raPreambleId);
m_raPreambleId = raPreambleId;
m_raRnti = raRnti;
m_controlMessagesQueue.at (0).push_back (msg);
}
void
LteUePhy::ReceiveLteControlMessageList (std::list<Ptr<LteControlMessage> > msgList)
{
NS_LOG_FUNCTION (this);
std::list<Ptr<LteControlMessage> >::iterator it;
for (it = msgList.begin (); it != msgList.end(); it++)
{
Ptr<LteControlMessage> msg = (*it);
if (msg->GetMessageType () == LteControlMessage::DL_DCI)
{
Ptr<DlDciLteControlMessage> msg2 = DynamicCast<DlDciLteControlMessage> (msg);
DlDciListElement_s dci = msg2->GetDci ();
if (dci.m_rnti != m_rnti)
{
// DCI not for me
continue;
}
if (dci.m_resAlloc != 0)
{
NS_FATAL_ERROR ("Resource Allocation type not implemented");
}
std::vector <int> dlRb;
// translate the DCI to Spectrum framework
uint32_t mask = 0x1;
for (int i = 0; i < 32; i++)
{
if (((dci.m_rbBitmap & mask) >> i) == 1)
{
for (int k = 0; k < GetRbgSize (); k++)
{
dlRb.push_back ((i * GetRbgSize ()) + k);
// NS_LOG_DEBUG(this << " RNTI " << m_rnti << " RBG " << i << " DL-DCI allocated PRB " << (i*GetRbgSize()) + k);
}
}
mask = (mask << 1);
}
// send TB info to LteSpectrumPhy
NS_LOG_DEBUG (this << " UE " << m_rnti << " DL-DCI " << dci.m_rnti << " bitmap " << dci.m_rbBitmap);
for (uint8_t i = 0; i < dci.m_tbsSize.size (); i++)
{
m_downlinkSpectrumPhy->AddExpectedTb (dci.m_rnti, dci.m_ndi.at (i), dci.m_tbsSize.at (i), dci.m_mcs.at (i), dlRb, i, dci.m_harqProcess, dci.m_rv.at (i), true /* DL */);
}
SetSubChannelsForReception (dlRb);
}
else if (msg->GetMessageType () == LteControlMessage::UL_DCI)
{
// set the uplink bandwidth according to the UL-CQI
Ptr<UlDciLteControlMessage> msg2 = DynamicCast<UlDciLteControlMessage> (msg);
UlDciListElement_s dci = msg2->GetDci ();
if (dci.m_rnti != m_rnti)
{
// DCI not for me
continue;
}
NS_LOG_INFO (this << " UL DCI");
std::vector <int> ulRb;
for (int i = 0; i < dci.m_rbLen; i++)
{
ulRb.push_back (i + dci.m_rbStart);
//NS_LOG_DEBUG (this << " UE RB " << i + dci.m_rbStart);
}
QueueSubChannelsForTransmission (ulRb);
// fire trace of UL Tx PHY stats
HarqProcessInfoList_t harqInfoList = m_harqPhyModule->GetHarqProcessInfoUl (m_rnti, 0);
PhyTransmissionStatParameters params;
params.m_cellId = m_cellId;
params.m_imsi = 0; // it will be set by DlPhyTransmissionCallback in LteHelper
params.m_timestamp = Simulator::Now ().GetMilliSeconds () + UL_PUSCH_TTIS_DELAY;
params.m_rnti = m_rnti;
params.m_txMode = 0; // always SISO for UE
params.m_layer = 0;
params.m_mcs = dci.m_mcs;
params.m_size = dci.m_tbSize;
params.m_rv = harqInfoList.size ();
params.m_ndi = dci.m_ndi;
m_ulPhyTransmission (params);
// pass the info to the MAC
m_uePhySapUser->ReceiveLteControlMessage (msg);
}
else if (msg->GetMessageType () == LteControlMessage::RAR)
{
Ptr<RarLteControlMessage> rarMsg = DynamicCast<RarLteControlMessage> (msg);
if (rarMsg->GetRaRnti () == m_raRnti)
{
for (std::list<RarLteControlMessage::Rar>::const_iterator it = rarMsg->RarListBegin (); it != rarMsg->RarListEnd (); ++it)
{
if (it->rapId != m_raPreambleId)
{
// UL grant not for me
continue;
}
else
{
NS_LOG_INFO ("received RAR RNTI " << m_raRnti);
// set the uplink bandwidht according to the UL grant
std::vector <int> ulRb;
for (int i = 0; i < it->rarPayload.m_grant.m_rbLen; i++)
{
ulRb.push_back (i + it->rarPayload.m_grant.m_rbStart);
}
QueueSubChannelsForTransmission (ulRb);
// pass the info to the MAC
m_uePhySapUser->ReceiveLteControlMessage (msg);
// reset RACH variables with out of range values
m_raPreambleId = 255;
m_raRnti = 11;
}
}
}
}
else if (msg->GetMessageType () == LteControlMessage::MIB)
{
NS_LOG_INFO ("received MIB");
NS_ASSERT (m_cellId > 0);
Ptr<MibLteControlMessage> msg2 = DynamicCast<MibLteControlMessage> (msg);
m_ueCphySapUser->RecvMasterInformationBlock (m_cellId, msg2->GetMib ());
}
else if (msg->GetMessageType () == LteControlMessage::SIB1)
{
NS_LOG_INFO ("received SIB1");
NS_ASSERT (m_cellId > 0);
Ptr<Sib1LteControlMessage> msg2 = DynamicCast<Sib1LteControlMessage> (msg);
m_ueCphySapUser->RecvSystemInformationBlockType1 (m_cellId, msg2->GetSib1 ());
}
else
{
// pass the message to UE-MAC
m_uePhySapUser->ReceiveLteControlMessage (msg);
}
}
}
void
LteUePhy::ReceivePss (uint16_t cellId, Ptr<SpectrumValue> p)
{
NS_LOG_FUNCTION (this << cellId << (*p));
double sum = 0.0;
uint16_t nRB = 0;
Values::const_iterator itPi;
for (itPi = p->ConstValuesBegin (); itPi != p->ConstValuesEnd (); itPi++)
{
// convert PSD [W/Hz] to linear power [W] for the single RE
double powerTxW = ((*itPi) * 180000.0) / 12.0;
sum += powerTxW;
nRB++;
}
// measure instantaneous RSRP now
double rsrp_dBm = 10 * log10 (1000 * (sum / (double)nRB));
NS_LOG_INFO (this << " PSS RNTI " << m_rnti << " cellId " << m_cellId
<< " has RSRP " << rsrp_dBm << " and RBnum " << nRB);
// note that m_pssReceptionThreshold does not apply here
// store measurements
std::map <uint16_t, UeMeasurementsElement>::iterator itMeasMap = m_ueMeasurementsMap.find (cellId);
if (itMeasMap == m_ueMeasurementsMap.end ())
{
// insert new entry
UeMeasurementsElement newEl;
newEl.rsrpSum = rsrp_dBm;
newEl.rsrpNum = 1;
newEl.rsrqSum = 0;
newEl.rsrqNum = 0;
m_ueMeasurementsMap.insert (std::pair <uint16_t, UeMeasurementsElement> (cellId, newEl));
}
else
{
(*itMeasMap).second.rsrpSum += rsrp_dBm;
(*itMeasMap).second.rsrpNum++;
}
/*
* Collect the PSS for later processing in GenerateCtrlCqiReport()
* (to be called from ChunkProcessor after RX is finished).
*/
m_pssReceived = true;
PssElement el;
el.cellId = cellId;
el.pssPsdSum = sum;
el.nRB = nRB;
m_pssList.push_back (el);
} // end of void LteUePhy::ReceivePss (uint16_t cellId, Ptr<SpectrumValue> p)
void
LteUePhy::QueueSubChannelsForTransmission (std::vector <int> rbMap)
{
m_subChannelsForTransmissionQueue.at (m_macChTtiDelay - 1) = rbMap;
}
void
LteUePhy::SubframeIndication (uint32_t frameNo, uint32_t subframeNo)
{
NS_LOG_FUNCTION (this << frameNo << subframeNo);
NS_ASSERT_MSG (frameNo > 0, "the SRS index check code assumes that frameNo starts at 1");
// refresh internal variables
m_rsReceivedPowerUpdated = false;
m_rsInterferencePowerUpdated = false;
m_pssReceived = false;
if (m_ulConfigured)
{
// update uplink transmission mask according to previous UL-CQIs
SetSubChannelsForTransmission (m_subChannelsForTransmissionQueue.at (0));
// shift the queue
for (uint8_t i = 1; i < m_macChTtiDelay; i++)
{
m_subChannelsForTransmissionQueue.at (i-1) = m_subChannelsForTransmissionQueue.at (i);
}
m_subChannelsForTransmissionQueue.at (m_macChTtiDelay-1).clear ();
if (m_srsConfigured && (m_srsStartTime <= Simulator::Now ()))
{
NS_ASSERT_MSG (subframeNo > 0 && subframeNo <= 10, "the SRS index check code assumes that subframeNo starts at 1");
if ((((frameNo-1)*10 + (subframeNo-1)) % m_srsPeriodicity) == m_srsSubframeOffset)
{
NS_LOG_INFO ("frame " << frameNo << " subframe " << subframeNo << " sending SRS (offset=" << m_srsSubframeOffset << ", period=" << m_srsPeriodicity << ")");
m_sendSrsEvent = Simulator::Schedule (UL_SRS_DELAY_FROM_SUBFRAME_START,
&LteUePhy::SendSrs,
this);
}
}
std::list<Ptr<LteControlMessage> > ctrlMsg = GetControlMessages ();
// send packets in queue
NS_LOG_LOGIC (this << " UE - start slot for PUSCH + PUCCH - RNTI " << m_rnti << " CELLID " << m_cellId);
// send the current burts of packets
Ptr<PacketBurst> pb = GetPacketBurst ();
if (pb)
{
m_uplinkSpectrumPhy->StartTxDataFrame (pb, ctrlMsg, UL_DATA_DURATION);
}
else
{
// send only PUCCH (ideal: fake null bandwidth signal)
if (ctrlMsg.size ()>0)
{
NS_LOG_LOGIC (this << " UE - start TX PUCCH (NO PUSCH)");
std::vector <int> dlRb;
SetSubChannelsForTransmission (dlRb);
m_uplinkSpectrumPhy->StartTxDataFrame (pb, ctrlMsg, UL_DATA_DURATION);
}
else
{
NS_LOG_LOGIC (this << " UE - UL NOTHING TO SEND");
}
}
} // m_configured
// trigger the MAC
m_uePhySapUser->SubframeIndication (frameNo, subframeNo);
m_subframeNo = subframeNo;
++subframeNo;
if (subframeNo > 10)
{
++frameNo;
subframeNo = 1;
}
// schedule next subframe indication
Simulator::Schedule (Seconds (GetTti ()), &LteUePhy::SubframeIndication, this, frameNo, subframeNo);
}
void
LteUePhy::SendSrs ()
{
NS_LOG_FUNCTION (this << " UE " << m_rnti << " start tx SRS, cell Id " << (uint32_t) m_cellId);
NS_ASSERT (m_cellId > 0);
// set the current tx power spectral density (full bandwidth)
std::vector <int> dlRb;
for (uint8_t i = 0; i < m_ulBandwidth; i++)
{
dlRb.push_back (i);
}
SetSubChannelsForTransmission (dlRb);
m_uplinkSpectrumPhy->StartTxUlSrsFrame ();
}
void
LteUePhy::DoReset ()
{
NS_LOG_FUNCTION (this);
m_rnti = 0;
m_transmissionMode = 0;
m_srsPeriodicity = 0;
m_srsConfigured = false;
m_dlConfigured = false;
m_ulConfigured = false;
m_raPreambleId = 255; // value out of range
m_raRnti = 11; // value out of range
m_rsrpSinrSampleCounter = 0;
m_p10CqiLast = Simulator::Now ();
m_a30CqiLast = Simulator::Now ();
m_packetBurstQueue.clear ();
m_controlMessagesQueue.clear ();
m_subChannelsForTransmissionQueue.clear ();
for (int i = 0; i < m_macChTtiDelay; i++)
{
Ptr<PacketBurst> pb = CreateObject <PacketBurst> ();
m_packetBurstQueue.push_back (pb);
std::list<Ptr<LteControlMessage> > l;
m_controlMessagesQueue.push_back (l);
}
std::vector <int> ulRb;
m_subChannelsForTransmissionQueue.resize (m_macChTtiDelay, ulRb);
m_sendSrsEvent.Cancel ();
m_downlinkSpectrumPhy->Reset ();
m_uplinkSpectrumPhy->Reset ();
} // end of void LteUePhy::DoReset ()
void
LteUePhy::DoStartCellSearch (uint16_t dlEarfcn)
{
NS_LOG_FUNCTION (this << dlEarfcn);
m_dlEarfcn = dlEarfcn;
DoSetDlBandwidth (6); // configure DL for receiving PSS
SwitchToState (CELL_SEARCH);
}
void
LteUePhy::DoSynchronizeWithEnb (uint16_t cellId, uint16_t dlEarfcn)
{
NS_LOG_FUNCTION (this << cellId << dlEarfcn);
m_dlEarfcn = dlEarfcn;
DoSynchronizeWithEnb (cellId);
}
void
LteUePhy::DoSynchronizeWithEnb (uint16_t cellId)
{
NS_LOG_FUNCTION (this << cellId);
if (cellId == 0)
{
NS_FATAL_ERROR ("Cell ID shall not be zero");
}
m_cellId = cellId;
m_downlinkSpectrumPhy->SetCellId (cellId);
m_uplinkSpectrumPhy->SetCellId (cellId);
// configure DL for receiving the BCH with the minimum bandwidth
DoSetDlBandwidth (6);
m_dlConfigured = false;
m_ulConfigured = false;
SwitchToState (SYNCHRONIZED);
}
void
LteUePhy::DoSetDlBandwidth (uint8_t dlBandwidth)
{
NS_LOG_FUNCTION (this << (uint32_t) dlBandwidth);
if (m_dlBandwidth != dlBandwidth or !m_dlConfigured)
{
m_dlBandwidth = dlBandwidth;
int Type0AllocationRbg[4] = {
10, // RGB size 1
26, // RGB size 2
63, // RGB size 3
110 // RGB size 4
}; // see table 7.1.6.1-1 of 36.213
for (int i = 0; i < 4; i++)
{
if (dlBandwidth < Type0AllocationRbg[i])
{
m_rbgSize = i + 1;
break;
}
}
Ptr<SpectrumValue> noisePsd = LteSpectrumValueHelper::CreateNoisePowerSpectralDensity (m_dlEarfcn, m_dlBandwidth, m_noiseFigure);
m_downlinkSpectrumPhy->SetNoisePowerSpectralDensity (noisePsd);
m_downlinkSpectrumPhy->GetChannel ()->AddRx (m_downlinkSpectrumPhy);
}
m_dlConfigured = true;
}
void
LteUePhy::DoConfigureUplink (uint16_t ulEarfcn, uint8_t ulBandwidth)
{
m_ulEarfcn = ulEarfcn;
m_ulBandwidth = ulBandwidth;
m_ulConfigured = true;
}
void
LteUePhy::DoSetRnti (uint16_t rnti)
{
NS_LOG_FUNCTION (this << rnti);
m_rnti = rnti;
}
void
LteUePhy::DoSetTransmissionMode (uint8_t txMode)
{
NS_LOG_FUNCTION (this << (uint16_t)txMode);
m_transmissionMode = txMode;
m_downlinkSpectrumPhy->SetTransmissionMode (txMode);
}
void
LteUePhy::DoSetSrsConfigurationIndex (uint16_t srcCi)
{
NS_LOG_FUNCTION (this << srcCi);
m_srsPeriodicity = GetSrsPeriodicity (srcCi);
m_srsSubframeOffset = GetSrsSubframeOffset (srcCi);
m_srsConfigured = true;
// a guard time is needed for the case where the SRS periodicity is changed dynamically at run time
// if we use a static one, we can have a 0ms guard time
m_srsStartTime = Simulator::Now () + MilliSeconds (0);
NS_LOG_DEBUG (this << " UE SRS P " << m_srsPeriodicity << " RNTI " << m_rnti << " offset " << m_srsSubframeOffset << " cellId " << m_cellId << " CI " << srcCi);
}
void
LteUePhy::SetTxMode1Gain (double gain)
{
SetTxModeGain (1, gain);
}
void
LteUePhy::SetTxMode2Gain (double gain)
{
SetTxModeGain (2, gain);
}
void
LteUePhy::SetTxMode3Gain (double gain)
{
SetTxModeGain (3, gain);
}
void
LteUePhy::SetTxMode4Gain (double gain)
{
SetTxModeGain (4, gain);
}
void
LteUePhy::SetTxMode5Gain (double gain)
{
SetTxModeGain (5, gain);
}
void
LteUePhy::SetTxMode6Gain (double gain)
{
SetTxModeGain (6, gain);
}
void
LteUePhy::SetTxMode7Gain (double gain)
{
SetTxModeGain (7, gain);
}
void
LteUePhy::SetTxModeGain (uint8_t txMode, double gain)
{
NS_LOG_FUNCTION (this << gain);
// convert to linear
double gainLin = std::pow (10.0, (gain / 10.0));
if (m_txModeGain.size () < txMode)
{
m_txModeGain.resize (txMode);
}
std::vector <double> temp;
temp = m_txModeGain;
m_txModeGain.clear ();
for (uint8_t i = 0; i < temp.size (); i++)
{
if (i==txMode-1)
{
m_txModeGain.push_back (gainLin);
}
else
{
m_txModeGain.push_back (temp.at (i));
}
}
// forward the info to DL LteSpectrumPhy
m_downlinkSpectrumPhy->SetTxModeGain (txMode, gain);
}
void
LteUePhy::ReceiveLteDlHarqFeedback (DlInfoListElement_s m)
{
NS_LOG_FUNCTION (this);
// generate feedback to eNB and send it through ideal PUCCH
Ptr<DlHarqFeedbackLteControlMessage> msg = Create<DlHarqFeedbackLteControlMessage> ();
msg->SetDlHarqFeedback (m);
SetControlMessages (msg);
}
void
LteUePhy::SetHarqPhyModule (Ptr<LteHarqPhy> harq)
{
m_harqPhyModule = harq;
}
LteUePhy::State
LteUePhy::GetState () const
{
NS_LOG_FUNCTION (this);
return m_state;
}
void
LteUePhy::SwitchToState (State newState)
{
NS_LOG_FUNCTION (this << newState);
State oldState = m_state;
m_state = newState;
NS_LOG_INFO (this << " cellId=" << m_cellId << " rnti=" << m_rnti
<< " UePhy " << ToString (oldState)
<< " --> " << ToString (newState));
m_stateTransitionTrace (m_cellId, m_rnti, oldState, newState);
}
} // namespace ns3