lte-ue-rrc.h

Go to the documentation of this file.

/* -*-  Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2011 Centre Tecnologic de Telecomunicacions de Catalunya (CTTC)
 *
 * 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: Nicola Baldo <nbaldo@cttc.es>
 *         Budiarto Herman <budiarto.herman@magister.fi>
 * Modified by:
 *          Danilo Abrignani <danilo.abrignani@unibo.it> (Carrier Aggregation - GSoC 2015)
 *          Biljana Bojovic <biljana.bojovic@cttc.es> (Carrier Aggregation)
 */

#ifndef LTE_UE_RRC_H
#define LTE_UE_RRC_H

#include <ns3/object.h>
#include <ns3/packet.h>
#include <ns3/lte-ue-cmac-sap.h>
#include <ns3/lte-pdcp-sap.h>
#include <ns3/lte-as-sap.h>
#include <ns3/lte-ue-cphy-sap.h>
#include <ns3/lte-rrc-sap.h>
#include <ns3/traced-callback.h>
#include "ns3/component-carrier-ue.h"
#include <ns3/lte-ue-ccm-rrc-sap.h>
#include <vector>

#include <map>
#include <set>

#define MIN_NO_CC 1
#define MAX_NO_CC 5 // this is the maximum number of carrier components allowed by 3GPP up to R13

namespace ns3 {


static const Time UE_MEASUREMENT_REPORT_DELAY = MicroSeconds (1);


class LteRlc;
class LteMacSapProvider;
class LteUeCmacSapUser;
class LteUeCmacSapProvider;
class LteDataRadioBearerInfo;
class LteSignalingRadioBearerInfo;

class LteUeRrc : public Object
{

  friend class UeMemberLteUeCmacSapUser;
  friend class UeRrcMemberLteEnbCmacSapUser;
  friend class LtePdcpSpecificLtePdcpSapUser<LteUeRrc>;
  friend class MemberLteAsSapProvider<LteUeRrc>;
  friend class MemberLteUeCphySapUser<LteUeRrc>;
  friend class MemberLteUeRrcSapProvider<LteUeRrc>;
  friend class MemberLteUeCcmRrcSapUser<LteUeRrc>;

public:

  enum State
  {
    IDLE_START = 0,
    IDLE_CELL_SEARCH,
    IDLE_WAIT_MIB_SIB1,
    IDLE_WAIT_MIB,
    IDLE_WAIT_SIB1,
    IDLE_CAMPED_NORMALLY,
    IDLE_WAIT_SIB2,
    IDLE_RANDOM_ACCESS,
    IDLE_CONNECTING,
    CONNECTED_NORMALLY,
    CONNECTED_HANDOVER,
    CONNECTED_PHY_PROBLEM,
    CONNECTED_REESTABLISHING,
    NUM_STATES
  };


  LteUeRrc ();


  virtual ~LteUeRrc ();


  // inherited from Object
private:
  virtual void DoInitialize (void);
  virtual void DoDispose (void);
public:
  static TypeId GetTypeId (void);

  void InitializeSap (void);

  void SetLteUeCphySapProvider (LteUeCphySapProvider * s);
  void SetLteUeCphySapProvider (LteUeCphySapProvider * s, uint8_t index);

  LteUeCphySapUser* GetLteUeCphySapUser ();
  LteUeCphySapUser* GetLteUeCphySapUser (uint8_t index);

  void SetLteUeCmacSapProvider (LteUeCmacSapProvider * s);
  void SetLteUeCmacSapProvider (LteUeCmacSapProvider * s, uint8_t index);

  LteUeCmacSapUser* GetLteUeCmacSapUser ();
  LteUeCmacSapUser* GetLteUeCmacSapUser (uint8_t index);


  void SetLteUeRrcSapUser (LteUeRrcSapUser * s);

  LteUeRrcSapProvider* GetLteUeRrcSapProvider ();

  void SetLteMacSapProvider (LteMacSapProvider* s);

  void SetAsSapUser (LteAsSapUser* s);

  LteAsSapProvider* GetAsSapProvider ();

  void SetLteCcmRrcSapProvider (LteUeCcmRrcSapProvider * s);

  LteUeCcmRrcSapUser* GetLteCcmRrcSapUser ();

  void SetImsi (uint64_t imsi);

  uint64_t GetImsi (void) const;

  uint16_t GetRnti () const;

  uint16_t GetCellId () const;

  uint8_t GetUlBandwidth () const;

  uint8_t GetDlBandwidth () const;

  uint32_t GetDlEarfcn () const;

  uint32_t GetUlEarfcn () const;

  State GetState () const;

  void SetUseRlcSm (bool val);

  typedef void (* CellSelectionTracedCallback)
    (uint64_t imsi, uint16_t cellId);

  typedef void (* ImsiCidRntiTracedCallback)
    (uint64_t imsi, uint16_t cellId, uint16_t rnti);

  typedef void (* MibSibHandoverTracedCallback)
    (uint64_t imsi, uint16_t cellId, uint16_t rnti, uint16_t otherCid);

  typedef void (* StateTracedCallback)
    (uint64_t imsi, uint16_t cellId, uint16_t rnti,
     State oldState, State newState);

  typedef void (* SCarrierConfiguredTracedCallback)
    (Ptr<LteUeRrc>, std::list<LteRrcSap::SCellToAddMod>);


private:


  // PDCP SAP methods
  void DoReceivePdcpSdu (LtePdcpSapUser::ReceivePdcpSduParameters params);

  // CMAC SAP methods
  void DoSetTemporaryCellRnti (uint16_t rnti);
  void DoNotifyRandomAccessSuccessful ();
  void DoNotifyRandomAccessFailed ();
 
  // LTE AS SAP methods
  void DoSetCsgWhiteList (uint32_t csgId);
  void DoForceCampedOnEnb (uint16_t cellId, uint32_t dlEarfcn);
  void DoStartCellSelection (uint32_t dlEarfcn);
  void DoConnect ();
  void DoSendData (Ptr<Packet> packet, uint8_t bid);
  void DoDisconnect ();

  // CPHY SAP methods
  void DoRecvMasterInformationBlock (uint16_t cellId,
                                     LteRrcSap::MasterInformationBlock msg);
  void DoRecvSystemInformationBlockType1 (uint16_t cellId,
                                          LteRrcSap::SystemInformationBlockType1 msg);
  void DoReportUeMeasurements (LteUeCphySapUser::UeMeasurementsParameters params);

  // RRC SAP methods

  void DoCompleteSetup (LteUeRrcSapProvider::CompleteSetupParameters params);
  void DoRecvSystemInformation (LteRrcSap::SystemInformation msg);
  void DoRecvRrcConnectionSetup (LteRrcSap::RrcConnectionSetup msg);
  void DoRecvRrcConnectionReconfiguration (LteRrcSap::RrcConnectionReconfiguration msg);
  void DoRecvRrcConnectionReestablishment (LteRrcSap::RrcConnectionReestablishment msg);
  void DoRecvRrcConnectionReestablishmentReject (LteRrcSap::RrcConnectionReestablishmentReject msg);
  void DoRecvRrcConnectionRelease (LteRrcSap::RrcConnectionRelease msg);
  void DoRecvRrcConnectionReject (LteRrcSap::RrcConnectionReject msg);

  void DoComponentCarrierEnabling (std::vector<uint8_t> res);

 
  // INTERNAL METHODS

  void SynchronizeToStrongestCell ();

  void EvaluateCellForSelection ();

  void ApplyMeasConfig (LteRrcSap::MeasConfig mc);

  void SaveUeMeasurements (uint16_t cellId, double rsrp, double rsrq,
                           bool useLayer3Filtering);

  void SaveScellUeMeasurements (uint16_t cellId, double rsrp, double rsrq,
                                bool useLayer3Filtering, uint16_t componentCarrierId);
  void MeasurementReportTriggering (uint8_t measId);

  void SendMeasurementReport (uint8_t measId);

  void ApplyRadioResourceConfigDedicated (LteRrcSap::RadioResourceConfigDedicated rrcd);
  void ApplyRadioResourceConfigDedicatedSecondaryCarrier (LteRrcSap::NonCriticalExtensionConfiguration nonCec);
  void StartConnection ();
  void LeaveConnectedMode ();
  void DisposeOldSrb1 ();
  uint8_t Bid2Drbid (uint8_t bid);
  void SwitchToState (State s);

  std::map<uint8_t, uint8_t> m_bid2DrbidMap; 

  std::vector<LteUeCphySapUser*> m_cphySapUser; 
  std::vector<LteUeCphySapProvider*> m_cphySapProvider; 

  std::vector<LteUeCmacSapUser*> m_cmacSapUser; 
  std::vector<LteUeCmacSapProvider*> m_cmacSapProvider; 

  LteUeRrcSapUser* m_rrcSapUser; 
  LteUeRrcSapProvider* m_rrcSapProvider; 

  LteMacSapProvider* m_macSapProvider; 
  LtePdcpSapUser* m_drbPdcpSapUser; 

  LteAsSapProvider* m_asSapProvider; 
  LteAsSapUser* m_asSapUser; 

  // Receive API calls from the LteUeComponentCarrierManager  instance.
  // LteCcmRrcSapUser* m_ccmRrcSapUser;
  LteUeCcmRrcSapProvider* m_ccmRrcSapProvider; 
  LteUeCcmRrcSapUser* m_ccmRrcSapUser; 

  State m_state;

  uint64_t m_imsi;
  uint16_t m_rnti;
  uint16_t m_cellId;

  Ptr<LteSignalingRadioBearerInfo> m_srb0;
  Ptr<LteSignalingRadioBearerInfo> m_srb1;
  Ptr<LteSignalingRadioBearerInfo> m_srb1Old;
  std::map <uint8_t, Ptr<LteDataRadioBearerInfo> > m_drbMap;

  bool m_useRlcSm;

  uint8_t m_lastRrcTransactionIdentifier; 

  LteRrcSap::PdschConfigDedicated m_pdschConfigDedicated; 

  uint8_t m_dlBandwidth; 
  uint8_t m_ulBandwidth; 
  uint32_t m_dlEarfcn;  
  uint32_t m_ulEarfcn;  
  std::list<LteRrcSap::SCellToAddMod> m_sCellToAddModList; 
  TracedCallback<uint64_t, uint16_t, uint16_t, uint16_t> m_mibReceivedTrace;
  TracedCallback<uint64_t, uint16_t, uint16_t, uint16_t> m_sib1ReceivedTrace;
  TracedCallback<uint64_t, uint16_t, uint16_t> m_sib2ReceivedTrace;
  TracedCallback<uint64_t, uint16_t, uint16_t, State, State> m_stateTransitionTrace;
  TracedCallback<uint64_t, uint16_t> m_initialCellSelectionEndOkTrace;
  TracedCallback<uint64_t, uint16_t> m_initialCellSelectionEndErrorTrace;
  TracedCallback<uint64_t, uint16_t, uint16_t> m_randomAccessSuccessfulTrace;
  TracedCallback<uint64_t, uint16_t, uint16_t> m_randomAccessErrorTrace;
  TracedCallback<uint64_t, uint16_t, uint16_t> m_connectionEstablishedTrace;
  TracedCallback<uint64_t, uint16_t, uint16_t> m_connectionTimeoutTrace;
  TracedCallback<uint64_t, uint16_t, uint16_t> m_connectionReconfigurationTrace;
  TracedCallback<uint64_t, uint16_t, uint16_t, uint16_t> m_handoverStartTrace;
  TracedCallback<uint64_t, uint16_t, uint16_t> m_handoverEndOkTrace;
  TracedCallback<uint64_t, uint16_t, uint16_t> m_handoverEndErrorTrace;
  TracedCallback<Ptr<LteUeRrc>, std::list<LteRrcSap::SCellToAddMod> > m_sCarrierConfiguredTrace;

  bool m_connectionPending;
  bool m_hasReceivedMib;
  bool m_hasReceivedSib1;
  bool m_hasReceivedSib2;

  LteRrcSap::SystemInformationBlockType1 m_lastSib1;

  std::set<uint16_t> m_acceptableCell;

  uint32_t m_csgWhiteList;


  // INTERNAL DATA STRUCTURE RELATED TO UE MEASUREMENTS

  struct VarMeasConfig
  {
    std::map<uint8_t, LteRrcSap::MeasIdToAddMod> measIdList; 
    std::map<uint8_t, LteRrcSap::MeasObjectToAddMod> measObjectList; 
    std::map<uint8_t, LteRrcSap::ReportConfigToAddMod> reportConfigList; 
    LteRrcSap::QuantityConfig quantityConfig; 
    double aRsrp; 
    double aRsrq; 
  };

  VarMeasConfig m_varMeasConfig;

  struct VarMeasReport
  {
    uint8_t measId; 
    std::set<uint16_t> cellsTriggeredList; 
    uint32_t numberOfReportsSent; 
    EventId periodicReportTimer; 
  };

  std::map<uint8_t, VarMeasReport> m_varMeasReportList;

  typedef std::list<uint16_t> ConcernedCells_t;

  void VarMeasReportListAdd (uint8_t measId, ConcernedCells_t enteringCells);

  void VarMeasReportListErase (uint8_t measId, ConcernedCells_t leavingCells,
                               bool reportOnLeave);

  void VarMeasReportListClear (uint8_t measId);

  struct MeasValues
  {
    double rsrp; 
    double rsrq; 
    Time timestamp; 
  };

  std::map<uint16_t, MeasValues> m_storedMeasValues;

  std::map<uint16_t, std::map <uint8_t, MeasValues> > m_storedMeasValuesPerCarrier;

  std::map<uint16_t, MeasValues> m_storedScellMeasValues;

  struct PendingTrigger_t
  {
    uint8_t measId; 
    ConcernedCells_t concernedCells; 
    EventId timer; 
  };

  std::map<uint8_t, std::list<PendingTrigger_t> > m_enteringTriggerQueue;

  std::map<uint8_t, std::list<PendingTrigger_t> > m_leavingTriggerQueue;

  void CancelEnteringTrigger (uint8_t measId);

  void CancelEnteringTrigger (uint8_t measId, uint16_t cellId);

  void CancelLeavingTrigger (uint8_t measId);

  void CancelLeavingTrigger (uint8_t measId, uint16_t cellId);

  Time m_t300;

  EventId m_connectionTimeout;

  void ConnectionTimeout ();

public:
  uint16_t m_numberOfComponentCarriers;

}; // end of class LteUeRrc


} // namespace ns3

#endif // LTE_UE_RRC_H