nr-ue-rrc.h

// Copyright (c) 2011 Centre Tecnologic de Telecomunicacions de Catalunya (CTTC)
// Copyright (c) 2018 Fraunhofer ESK : RLF extensions
//
// SPDX-License-Identifier: GPL-2.0-only
//
// 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)
//          Vignesh Babu <ns3-dev@esk.fraunhofer.de> (RLF extensions)
 
#ifndef NR_UE_RRC_H
#define NR_UE_RRC_H
 
#include "nr-as-sap.h"
#include "nr-pdcp-sap.h"
#include "nr-rrc-sap.h"
#include "nr-ue-ccm-rrc-sap.h"
#include "nr-ue-cmac-sap.h"
#include "nr-ue-cphy-sap.h"
 
#include "ns3/object.h"
#include "ns3/packet.h"
#include "ns3/traced-callback.h"
 
#include <map>
#include <set>
#include <vector>
 
namespace ns3
{
 
extern const Time NR_UE_MEASUREMENT_REPORT_DELAY;
 
class NrRlc;
class NrMacSapProvider;
class NrUeCmacSapUser;
class NrUeCmacSapProvider;
class NrDataRadioBearerInfo;
class NrSignalingRadioBearerInfo;
 
class NrUeRrc : public Object
{
    friend class UeMemberNrUeCmacSapUser;
    friend class UeRrcMemberNrGnbCmacSapUser;
    friend class NrPdcpSpecificNrPdcpSapUser<NrUeRrc>;
    friend class MemberNrAsSapProvider<NrUeRrc>;
    friend class MemberNrUeCphySapUser<NrUeRrc>;
    friend class MemberNrUeRrcSapProvider<NrUeRrc>;
    friend class MemberNrUeCcmRrcSapUser<NrUeRrc>;
 
  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
    };
 
    NrUeRrc();
 
    ~NrUeRrc() override;
 
    // inherited from Object
  private:
    void DoDispose() override;
 
  public:
    static TypeId GetTypeId();
 
    void InitializeSap();
 
    void InitializeSrb0();
 
    void SetNrUeCphySapProvider(NrUeCphySapProvider* s);
    void SetNrUeCphySapProvider(NrUeCphySapProvider* s, uint8_t index);
 
    NrUeCphySapUser* GetNrUeCphySapUser();
    NrUeCphySapUser* GetNrUeCphySapUser(uint8_t index);
 
    void SetNrUeCmacSapProvider(NrUeCmacSapProvider* s);
    void SetNrUeCmacSapProvider(NrUeCmacSapProvider* s, uint8_t index);
 
    NrUeCmacSapUser* GetNrUeCmacSapUser();
    NrUeCmacSapUser* GetNrUeCmacSapUser(uint8_t index);
 
    void SetNrUeRrcSapUser(NrUeRrcSapUser* s);
 
    NrUeRrcSapProvider* GetNrUeRrcSapProvider();
 
    void SetNrMacSapProvider(NrMacSapProvider* s);
 
    void SetAsSapUser(NrAsSapUser* s);
 
    NrAsSapProvider* GetAsSapProvider();
 
    void SetNrCcmRrcSapProvider(NrUeCcmRrcSapProvider* s);
 
    NrUeCcmRrcSapUser* GetNrCcmRrcSapUser();
 
    void SetImsi(uint64_t imsi);
 
    void StorePreviousCellId(uint16_t cellId);
 
    uint64_t GetImsi() const;
 
    uint16_t GetRnti() const;
 
    uint16_t GetCellId() const;
 
    bool IsServingCell(uint16_t cellId) const;
 
    uint8_t GetUlBandwidth() const;
 
    uint8_t GetDlBandwidth() const;
 
    uint32_t GetDlEarfcn() const;
 
    uint32_t GetUlEarfcn() const;
 
    State GetState() const;
 
    uint16_t GetPreviousCellId() const;
 
    void SetUseRlcSm(bool val);
 
    void SetPrimaryUlIndex(uint16_t primaryIndex);
 
    uint16_t GetPrimaryUlIndex() const;
 
    void SetPrimaryDlIndex(uint16_t primaryIndex);
 
    uint16_t GetPrimaryDlIndex() const;
 
    static const std::string ToString(NrUeRrc::State s);
 
    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<NrUeRrc>,
                                                     std::list<NrRrcSap::SCellToAddMod>);
 
    typedef void (*PhySyncDetectionTracedCallback)(uint64_t imsi,
                                                   uint16_t rnti,
                                                   uint16_t cellId,
                                                   std::string type,
                                                   uint16_t count);
 
    typedef void (*ImsiCidRntiCountTracedCallback)(uint64_t imsi,
                                                   uint16_t cellId,
                                                   uint16_t rnti,
                                                   uint8_t count);
 
  private:
    // PDCP SAP methods
    void DoReceivePdcpSdu(NrPdcpSapUser::ReceivePdcpSduParameters params);
 
    // CMAC SAP methods
    void DoSetTemporaryCellRnti(uint16_t rnti);
    void DoNotifyRandomAccessSuccessful();
    void DoNotifyRandomAccessFailed();
 
    // NR AS SAP methods
    void DoSetCsgWhiteList(uint32_t csgId);
    void DoForceCampedOnGnb(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, NrRrcSap::MasterInformationBlock msg);
    void DoRecvSystemInformationBlockType1(uint16_t cellId,
                                           NrRrcSap::SystemInformationBlockType1 msg);
    void DoReportUeMeasurements(NrUeCphySapUser::UeMeasurementsParameters params);
 
    // RRC SAP methods
 
    void DoCompleteSetup(NrUeRrcSapProvider::CompleteSetupParameters params);
    void DoRecvSystemInformation(NrRrcSap::SystemInformation msg);
    void DoRecvRrcConnectionSetup(NrRrcSap::RrcConnectionSetup msg);
    void DoRecvRrcConnectionReconfiguration(NrRrcSap::RrcConnectionReconfiguration msg);
    void DoRecvRrcConnectionReestablishment(NrRrcSap::RrcConnectionReestablishment msg);
    void DoRecvRrcConnectionReestablishmentReject(NrRrcSap::RrcConnectionReestablishmentReject msg);
    void DoRecvRrcConnectionRelease(NrRrcSap::RrcConnectionRelease msg);
    void DoRecvRrcConnectionReject(NrRrcSap::RrcConnectionReject msg);
 
    void DoSetNumberOfComponentCarriers(uint16_t noOfComponentCarriers);
 
    // INTERNAL METHODS
 
    void SynchronizeToStrongestCell();
 
    void EvaluateCellForSelection();
 
    void ApplyMeasConfig(NrRrcSap::MeasConfig mc);
 
    void SaveUeMeasurements(uint16_t cellId,
                            double rsrp,
                            double rsrq,
                            bool useLayer3Filtering,
                            uint8_t componentCarrierId);
 
    void MeasurementReportTriggering(uint8_t measId);
 
    void SendMeasurementReport(uint8_t measId);
 
    void ApplyRadioResourceConfigDedicated(NrRrcSap::RadioResourceConfigDedicated rrcd);
    void ApplyRadioResourceConfigDedicatedSecondaryCarrier(
        NrRrcSap::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<NrUeCphySapUser*> m_cphySapUser;         
    std::vector<NrUeCphySapProvider*> m_cphySapProvider; 
 
    std::vector<NrUeCmacSapUser*> m_cmacSapUser;         
    std::vector<NrUeCmacSapProvider*> m_cmacSapProvider; 
 
    NrUeRrcSapUser* m_rrcSapUser;         
    NrUeRrcSapProvider* m_rrcSapProvider; 
 
    NrMacSapProvider* m_macSapProvider; 
    NrPdcpSapUser* m_drbPdcpSapUser;    
 
    NrAsSapProvider* m_asSapProvider; 
    NrAsSapUser* m_asSapUser;         
 
    // Receive API calls from the NrUeComponentCarrierManager  instance.
    // NrCcmRrcSapUser* m_ccmRrcSapUser;
    NrUeCcmRrcSapProvider* m_ccmRrcSapProvider; 
    NrUeCcmRrcSapUser* m_ccmRrcSapUser;         
 
    State m_state;
 
    uint64_t m_imsi;
    uint16_t m_rnti;
    uint16_t m_cellId;
 
    uint16_t m_primaryUlIndex{0};
 
    uint16_t m_primaryDlIndex{0};
 
    Ptr<NrSignalingRadioBearerInfo> m_srb0;
    Ptr<NrSignalingRadioBearerInfo> m_srb1;
    Ptr<NrSignalingRadioBearerInfo> m_srb1Old;
    std::map<uint8_t, Ptr<NrDataRadioBearerInfo>> m_drbMap;
 
    bool m_useRlcSm;
 
    uint8_t m_lastRrcTransactionIdentifier; 
 
    NrRrcSap::PdschConfigDedicated m_pdschConfigDedicated; 
 
    uint16_t m_dlBandwidth; 
    uint16_t m_ulBandwidth; 
    uint32_t m_dlEarfcn;                                    
    uint32_t m_ulEarfcn;                                    
    std::list<NrRrcSap::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, uint8_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<NrUeRrc>, std::list<NrRrcSap::SCellToAddMod>> m_sCarrierConfiguredTrace;
    TracedCallback<uint64_t, uint16_t, uint16_t> m_srb1CreatedTrace;
    TracedCallback<uint64_t, uint16_t, uint16_t, uint8_t> m_drbCreatedTrace;
    TracedCallback<uint64_t, uint16_t, uint16_t, std::string, uint8_t> m_phySyncDetectionTrace;
    TracedCallback<uint64_t, uint16_t, uint16_t> m_radioLinkFailureTrace;
 
    bool m_connectionPending;
    bool m_hasReceivedMib;
    bool m_hasReceivedSib1;
    bool m_hasReceivedSib2;
 
    NrRrcSap::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, NrRrcSap::MeasIdToAddMod> measIdList;             
        std::map<uint8_t, NrRrcSap::MeasObjectToAddMod> measObjectList;     
        std::map<uint8_t, NrRrcSap::ReportConfigToAddMod> reportConfigList; 
        NrRrcSap::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;          
        uint32_t carrierFreq; 
    };
 
    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();
 
    Time m_t310;
 
    uint8_t m_n310;
 
    uint8_t m_n311;
 
    EventId m_radioLinkFailureDetected;
 
    uint8_t m_noOfSyncIndications; 
 
    bool m_leaveConnectedMode; 
 
    uint16_t m_previousCellId; 
 
    uint8_t m_connEstFailCountLimit; 
 
    uint8_t m_connEstFailCount; 
    void RadioLinkFailureDetected();
 
    void DoNotifyInSync();
 
    void DoNotifyOutOfSync();
 
    void DoResetSyncIndicationCounter();
 
    void ResetRlfParams();
 
  public:
    uint16_t m_numberOfComponentCarriers;
 
}; // end of class NrUeRrc
 
} // namespace ns3
 
#endif // NR_UE_RRC_H