From d75875fd28b7f256a5d90117269a8b8ddedadcfb Mon Sep 17 00:00:00 2001 From: Nicola Baldo Date: Fri, 8 Feb 2013 15:42:30 +0100 Subject: [PATCH 01/10] fixed valgrind errors in LteEnbRrc --- src/lte/model/lte-enb-rrc.cc | 12 ++++++++++++ src/lte/model/lte-rrc-protocol-real.cc | 27 ++++++++++++++++---------- 2 files changed, 29 insertions(+), 10 deletions(-) diff --git a/src/lte/model/lte-enb-rrc.cc b/src/lte/model/lte-enb-rrc.cc index 2ccb444b6..453329e85 100644 --- a/src/lte/model/lte-enb-rrc.cc +++ b/src/lte/model/lte-enb-rrc.cc @@ -527,6 +527,12 @@ UeManager::PrepareHandover (uint16_t cellId) hpi.asConfig.sourceSystemInformationBlockType1.cellAccessRelatedInfo.cellIdentity = m_rrc->m_cellId; hpi.asConfig.sourceSystemInformationBlockType1.cellAccessRelatedInfo.csgIndication = 0; hpi.asConfig.sourceSystemInformationBlockType1.cellAccessRelatedInfo.csgIdentity = 0; + LteEnbCmacSapProvider::RachConfig rc = m_rrc->m_cmacSapProvider->GetRachConfig (); + hpi.asConfig.sourceSystemInformationBlockType2.radioResourceConfigCommon.rachConfigCommon.preambleInfo.numberOfRaPreambles = rc.numberOfRaPreambles; + hpi.asConfig.sourceSystemInformationBlockType2.radioResourceConfigCommon.rachConfigCommon.raSupervisionInfo.preambleTransMax = rc.preambleTransMax; + hpi.asConfig.sourceSystemInformationBlockType2.radioResourceConfigCommon.rachConfigCommon.raSupervisionInfo.raResponseWindowSize = rc.raResponseWindowSize; + hpi.asConfig.sourceSystemInformationBlockType2.freqInfo.ulCarrierFreq = m_rrc->m_ulEarfcn; + hpi.asConfig.sourceSystemInformationBlockType2.freqInfo.ulBandwidth = m_rrc->m_ulBandwidth; params.rrcContext = m_rrc->m_rrcSapUser->EncodeHandoverPreparationInformation (hpi); NS_LOG_LOGIC ("oldEnbUeX2apId = " << params.oldEnbUeX2apId); @@ -1543,6 +1549,12 @@ LteEnbRrc::DoRecvHandoverRequest (EpcX2SapUser::HandoverRequestParams req) handoverCommand.mobilityControlInfo.haveRachConfigDedicated = true; handoverCommand.mobilityControlInfo.rachConfigDedicated.raPreambleIndex = anrcrv.raPreambleId; handoverCommand.mobilityControlInfo.rachConfigDedicated.raPrachMaskIndex = anrcrv.raPrachMaskIndex; + + LteEnbCmacSapProvider::RachConfig rc = m_cmacSapProvider->GetRachConfig (); + handoverCommand.mobilityControlInfo.radioResourceConfigCommon.rachConfigCommon.preambleInfo.numberOfRaPreambles = rc.numberOfRaPreambles; + handoverCommand.mobilityControlInfo.radioResourceConfigCommon.rachConfigCommon.raSupervisionInfo.preambleTransMax = rc.preambleTransMax; + handoverCommand.mobilityControlInfo.radioResourceConfigCommon.rachConfigCommon.raSupervisionInfo.raResponseWindowSize = rc.raResponseWindowSize; + Ptr encodedHandoverCommand = m_rrcSapUser->EncodeHandoverCommand (handoverCommand); ackParams.rrcContext = encodedHandoverCommand; diff --git a/src/lte/model/lte-rrc-protocol-real.cc b/src/lte/model/lte-rrc-protocol-real.cc index 0113e84f5..3e2c4a1cf 100644 --- a/src/lte/model/lte-rrc-protocol-real.cc +++ b/src/lte/model/lte-rrc-protocol-real.cc @@ -468,17 +468,24 @@ LteEnbRrcProtocolReal::DoSetupUe (uint16_t rnti, LteEnbRrcSapUser::SetupUeParame // Store SetupUeParameters m_setupUeParametersMap[rnti] = params; - // Create LteRlcSapUser, LtePdcpSapUser - LteRlcSapUser* srb0SapUser = new RealProtocolRlcSapUser (this,rnti); - LtePdcpSapUser* srb1SapUser = new LtePdcpSpecificLtePdcpSapUser (this); LteEnbRrcSapProvider::CompleteSetupUeParameters completeSetupUeParameters; - completeSetupUeParameters.srb0SapUser = srb0SapUser; - completeSetupUeParameters.srb1SapUser = srb1SapUser; - - // Store LteRlcSapUser, LtePdcpSapUser - m_completeSetupUeParametersMap[rnti] = completeSetupUeParameters; - - m_enbRrcSapProvider->CompleteSetupUe (rnti,completeSetupUeParameters); + std::map::iterator + csupIt = m_completeSetupUeParametersMap.find (rnti); + if (csupIt == m_completeSetupUeParametersMap.end ()) + { + // Create LteRlcSapUser, LtePdcpSapUser + LteRlcSapUser* srb0SapUser = new RealProtocolRlcSapUser (this,rnti); + LtePdcpSapUser* srb1SapUser = new LtePdcpSpecificLtePdcpSapUser (this); + completeSetupUeParameters.srb0SapUser = srb0SapUser; + completeSetupUeParameters.srb1SapUser = srb1SapUser; + // Store LteRlcSapUser, LtePdcpSapUser + m_completeSetupUeParametersMap[rnti] = completeSetupUeParameters; + } + else + { + completeSetupUeParameters = csupIt->second; + } + m_enbRrcSapProvider->CompleteSetupUe (rnti, completeSetupUeParameters); } void From 99861b69c9178bb03200cf35821cbfb8cf0a0df4 Mon Sep 17 00:00:00 2001 From: Nicola Baldo Date: Fri, 8 Feb 2013 19:07:39 +0100 Subject: [PATCH 02/10] updated doxygen of RadioBearerStatsCalculator --- src/lte/helper/radio-bearer-stats-calculator.h | 15 ++++++++++++--- 1 file changed, 12 insertions(+), 3 deletions(-) diff --git a/src/lte/helper/radio-bearer-stats-calculator.h b/src/lte/helper/radio-bearer-stats-calculator.h index adb2229f1..51dd73728 100644 --- a/src/lte/helper/radio-bearer-stats-calculator.h +++ b/src/lte/helper/radio-bearer-stats-calculator.h @@ -43,13 +43,22 @@ typedef std::map DoubleMap; typedef std::map FlowIdMap; /** - * Calculation of statistics from the RLC layer for uplink and downlink, the data is dumped into a file periodically. Metrics considered are: + * This class is an ns-3 trace sink that performs the calculation of + * PDU statistics for uplink and downlink. Statistics are generated + * on a per radio bearer basis. This class can be used for + * RLC PDU stats or PDCP PDU stats by connecting to the appropriate + * trace sources at the RLC or PDCP layer. + * + * The statistics are calculated at consecutive time windows and + * periodically written to a file. The calculated statistics are: + * * - Number of transmitted PDUs * - Number of received PDUs * - Number of transmitted bytes * - Number of received bytes - * - Average, min, max and standard deviation of RLC to RLC delay - * - Average, min, max and standard deviation of RLC PDU size + * - Average, min, max and standard deviation of PDU delay (delay is + * calculated from the generation of the PDU to its reception) + * - Average, min, max and standard deviation of PDU size */ class RadioBearerStatsCalculator : public LteStatsCalculator { From cbbeb1f8af7a81ddf2708a548eb3e51af2ba07e6 Mon Sep 17 00:00:00 2001 From: lluis Date: Tue, 19 Feb 2013 14:13:39 +0100 Subject: [PATCH 03/10] Serialization of MeasConfig IE, tiny modification in ThresholdEutra SAP. --- src/lte/model/lte-rrc-header.cc | 982 ++++++++++++++++++++++++++++---- src/lte/model/lte-rrc-header.h | 8 +- src/lte/model/lte-rrc-sap.h | 5 +- 3 files changed, 883 insertions(+), 112 deletions(-) diff --git a/src/lte/model/lte-rrc-header.cc b/src/lte/model/lte-rrc-header.cc index 0621a3d69..19229f29e 100644 --- a/src/lte/model/lte-rrc-header.cc +++ b/src/lte/model/lte-rrc-header.cc @@ -857,6 +857,816 @@ RrcAsn1Header::SerializeRachConfigCommon (LteRrcSap::RachConfigCommon rachConfig SerializeInteger (1,1,8); // maxHARQ-Msg3Tx } +void +RrcAsn1Header::SerializeQoffsetRange (int8_t qOffsetRange) const +{ + switch (qOffsetRange) + { + case -24: + SerializeEnum (32,0); + break; + case -22: + SerializeEnum (32,1); + break; + case -20: + SerializeEnum (32,2); + break; + case -18: + SerializeEnum (32,3); + break; + case -16: + SerializeEnum (32,4); + break; + case -14: + SerializeEnum (32,5); + break; + case -12: + SerializeEnum (32,6); + break; + case -10: + SerializeEnum (32,7); + break; + case -8: + SerializeEnum (32,8); + break; + case -6: + SerializeEnum (32,9); + break; + case -5: + SerializeEnum (32,10); + break; + case -4: + SerializeEnum (32,11); + break; + case -3: + SerializeEnum (32,12); + break; + case -2: + SerializeEnum (32,13); + break; + case -1: + SerializeEnum (32,14); + break; + case 0: + SerializeEnum (32,15); + break; + case 1: + SerializeEnum (32,16); + break; + case 2: + SerializeEnum (32,17); + break; + case 3: + SerializeEnum (32,18); + break; + case 4: + SerializeEnum (32,19); + break; + case 5: + SerializeEnum (32,20); + break; + case 6: + SerializeEnum (32,21); + break; + case 8: + SerializeEnum (32,22); + break; + case 10: + SerializeEnum (32,23); + break; + case 12: + SerializeEnum (32,24); + break; + case 14: + SerializeEnum (32,25); + break; + case 16: + SerializeEnum (32,26); + break; + case 18: + SerializeEnum (32,27); + break; + case 20: + SerializeEnum (32,28); + break; + case 22: + SerializeEnum (32,29); + break; + case 24: + SerializeEnum (32,30); + break; + default: + SerializeEnum (32,15); + } +} + +void +RrcAsn1Header::SerializeThresholdEutra (LteRrcSap::ThresholdEutra thresholdEutra) const +{ + switch (thresholdEutra.choice) + { + case LteRrcSap::ThresholdEutra::thresholdRsrp: + SerializeInteger (thresholdEutra.range, 0, 97); + break; + case LteRrcSap::ThresholdEutra::thresholdRsrq: + default: + SerializeInteger (thresholdEutra.range, 0, 34); + } +} + +void +RrcAsn1Header::SerializeMeasConfig (LteRrcSap::MeasConfig measConfig) const +{ + // Serialize MeasConfig sequence + // 11 optional fields, extension marker present + std::bitset<11> measConfigOptional; + measConfigOptional.set (10, !measConfig.measObjectToRemoveList.empty () ); + measConfigOptional.set (9, !measConfig.measObjectToAddModList.empty () ); + measConfigOptional.set (8, !measConfig.reportConfigToRemoveList.empty () ); + measConfigOptional.set (7, !measConfig.reportConfigToAddModList.empty () ); + measConfigOptional.set (6, !measConfig.measIdToRemoveList.empty () ); + measConfigOptional.set (5, !measConfig.measIdToAddModList.empty () ); + measConfigOptional.set (4, measConfig.haveQuantityConfig ); + measConfigOptional.set (3, measConfig.haveMeasGapConfig ); + measConfigOptional.set (2, measConfig.haveSmeasure ); + measConfigOptional.set (1, false ); // preRegistrationInfoHRPD + measConfigOptional.set (0, measConfig.haveSpeedStatePars ); + SerializeSequence (measConfigOptional,true); + + if (!measConfig.measObjectToRemoveList.empty ()) + { + SerializeSequenceOf (measConfig.measObjectToRemoveList.size (),MAX_OBJECT_ID,1); + for (std::list::iterator it = measConfig.measObjectToRemoveList.begin (); it != measConfig.measObjectToRemoveList.end (); it++) + { + SerializeInteger (*it, 1, MAX_OBJECT_ID); + } + } + + if (!measConfig.measObjectToAddModList.empty ()) + { + SerializeSequenceOf (measConfig.measObjectToAddModList.size (),MAX_OBJECT_ID,1); + for (std::list::iterator it = measConfig.measObjectToAddModList.begin (); it != measConfig.measObjectToAddModList.end (); it++) + { + SerializeSequence (std::bitset<0> (), false); + SerializeInteger (it->measObjectId, 1, MAX_OBJECT_ID); + SerializeChoice (4, 0, true); // Select MeasObjectEUTRA + + // Serialize measObjectEutra + std::bitset<5> measObjOpts; + measObjOpts.set (4,!it->measObjectEutra.cellsToRemoveList.empty () ); + measObjOpts.set (3,!it->measObjectEutra.cellsToAddModList.empty () ); + measObjOpts.set (2,!it->measObjectEutra.blackCellsToRemoveList.empty () ); + measObjOpts.set (1,!it->measObjectEutra.blackCellsToAddModList.empty () ); + measObjOpts.set (0,it->measObjectEutra.haveCellForWhichToReportCGI); + SerializeSequence (measObjOpts, true); + + // Serialize carrierFreq + SerializeInteger (it->measObjectEutra.carrierFreq, 0, MAX_EARFCN); + + // Serialize allowedMeasBandwidth + switch (it->measObjectEutra.allowedMeasBandwidth) + { + case 6: + SerializeEnum (6,0); + break; + case 15: + SerializeEnum (6,1); + break; + case 25: + SerializeEnum (6,2); + break; + case 50: + SerializeEnum (6,3); + break; + case 75: + SerializeEnum (6,4); + break; + case 100: + SerializeEnum (6,5); + break; + default: + SerializeEnum (6,0); + } + + SerializeBoolean (it->measObjectEutra.presenceAntennaPort1); + SerializeBitstring (std::bitset<2> (it->measObjectEutra.neighCellConfig)); + SerializeQoffsetRange (it->measObjectEutra.offsetFreq); + + if (!it->measObjectEutra.cellsToRemoveList.empty ()) + { + SerializeSequenceOf (it->measObjectEutra.cellsToRemoveList.size (),MAX_CELL_MEAS,1); + for (std::list::iterator it2 = it->measObjectEutra.cellsToRemoveList.begin (); it2 != it->measObjectEutra.cellsToRemoveList.end (); it2++) + { + SerializeInteger (*it2, 1, MAX_CELL_MEAS); + } + } + + if (!it->measObjectEutra.cellsToAddModList.empty ()) + { + SerializeSequenceOf (it->measObjectEutra.cellsToAddModList.size (), MAX_CELL_MEAS, 1); + for (std::list::iterator it2 = it->measObjectEutra.cellsToAddModList.begin (); it2 != it->measObjectEutra.cellsToAddModList.end (); it2++) + { + SerializeSequence (std::bitset<0> (), false); + + // Serialize cellIndex + SerializeInteger (it2->cellIndex, 1, MAX_CELL_MEAS); + + // Serialize PhysCellIdRange + // range optional and not present + SerializeSequence (std::bitset<1> (0),false); + SerializeInteger (it2->physCellId,0,503); + + // Serialize cellIndividualOffset + SerializeQoffsetRange (it2->cellIndividualOffset); + } + } + + if (!it->measObjectEutra.blackCellsToRemoveList.empty () ) + { + SerializeSequenceOf (it->measObjectEutra.blackCellsToRemoveList.size (),MAX_CELL_MEAS,1); + for (std::list::iterator it2 = it->measObjectEutra.blackCellsToRemoveList.begin (); it2 != it->measObjectEutra.blackCellsToRemoveList.end (); it2++) + { + SerializeInteger (*it2, 1, MAX_CELL_MEAS); + } + } + + if (!it->measObjectEutra.blackCellsToAddModList.empty () ) + { + SerializeSequenceOf (it->measObjectEutra.blackCellsToAddModList.size (), MAX_CELL_MEAS, 1); + for (std::list::iterator it2 = it->measObjectEutra.blackCellsToAddModList.begin (); it2 != it->measObjectEutra.blackCellsToAddModList.end (); it2++) + { + SerializeSequence (std::bitset<0> (),false); + SerializeInteger (it2->cellIndex, 1, MAX_CELL_MEAS); + + // Serialize PhysCellIdRange + // range optional + std::bitset<1> rangePresent = std::bitset<1> (it2->physCellIdRange.haveRange); + SerializeSequence (rangePresent,false); + SerializeInteger (it2->physCellIdRange.start,0,503); + if (it2->physCellIdRange.haveRange) + { + switch (it2->physCellIdRange.range) + { + case 4: + SerializeEnum (16, 0); + break; + case 8: + SerializeEnum (16, 1); + break; + case 12: + SerializeEnum (16, 2); + break; + case 16: + SerializeEnum (16, 3); + break; + case 24: + SerializeEnum (16, 4); + break; + case 32: + SerializeEnum (16, 5); + break; + case 48: + SerializeEnum (16, 6); + break; + case 64: + SerializeEnum (16, 7); + break; + case 84: + SerializeEnum (16, 8); + break; + case 96: + SerializeEnum (16, 9); + break; + case 128: + SerializeEnum (16, 10); + break; + case 168: + SerializeEnum (16, 11); + break; + case 252: + SerializeEnum (16, 12); + break; + case 504: + SerializeEnum (16, 13); + break; + default: + SerializeEnum (16, 0); + } + } + } + + } + + if (it->measObjectEutra.haveCellForWhichToReportCGI) + { + SerializeInteger (it->measObjectEutra.cellForWhichToReportCGI,0,503); + } + } + } + + + if (!measConfig.reportConfigToRemoveList.empty () ) + { + SerializeSequenceOf (measConfig.reportConfigToRemoveList.size (),MAX_REPORT_CONFIG_ID,1); + for (std::list::iterator it = measConfig.reportConfigToRemoveList.begin (); it != measConfig.reportConfigToRemoveList.end (); it++) + { + SerializeInteger (*it, 1,MAX_REPORT_CONFIG_ID); + } + } + + if (!measConfig.reportConfigToAddModList.empty () ) + { + SerializeSequenceOf (measConfig.reportConfigToAddModList.size (),MAX_REPORT_CONFIG_ID,1); + for (std::list::iterator it = measConfig.reportConfigToAddModList.begin (); it != measConfig.reportConfigToAddModList.end (); it++) + { + SerializeSequence (std::bitset<0> (), false); + SerializeInteger (it->reportConfigId,1,MAX_REPORT_CONFIG_ID); + SerializeChoice (2,0,false); // reportConfigEUTRA + + // Serialize ReportConfigEUTRA + SerializeSequence (std::bitset<0> (), true); + switch (it->reportConfigEutra.triggerType) + { + case LteRrcSap::ReportConfigEutra::periodical: + SerializeChoice (2, 1, false); + SerializeSequence (std::bitset<0> (),false); + switch (it->reportConfigEutra.purpose) + { + case LteRrcSap::ReportConfigEutra::reportCgi: + SerializeEnum (2,1); + break; + case LteRrcSap::ReportConfigEutra::reportStrongestCells: + default: + SerializeEnum (2,0); + } + break; + case LteRrcSap::ReportConfigEutra::event: + default: + SerializeChoice (2, 0, false); + SerializeSequence (std::bitset<0> (),true); + switch (it->reportConfigEutra.eventId) + { + case LteRrcSap::ReportConfigEutra::eventA1: + SerializeChoice (5, 0, true); + SerializeSequence (std::bitset<0> (),false); + SerializeThresholdEutra (it->reportConfigEutra.threshold1); + break; + case LteRrcSap::ReportConfigEutra::eventA2: + SerializeChoice (5, 1, true); + SerializeSequence (std::bitset<0> (),false); + SerializeThresholdEutra (it->reportConfigEutra.threshold1); + break; + case LteRrcSap::ReportConfigEutra::eventA3: + SerializeChoice (5, 2, true); + SerializeSequence (std::bitset<0> (),false); + SerializeInteger (it->reportConfigEutra.a3Offset,-30,30); + SerializeBoolean (it->reportConfigEutra.reportOnLeave); + break; + case LteRrcSap::ReportConfigEutra::eventA4: + SerializeChoice (5, 3, true); + SerializeSequence (std::bitset<0> (),false); + SerializeThresholdEutra (it->reportConfigEutra.threshold1); + break; + case LteRrcSap::ReportConfigEutra::eventA5: + default: + SerializeChoice (5, 4, true); + SerializeSequence (std::bitset<0> (),false); + SerializeThresholdEutra (it->reportConfigEutra.threshold1); + SerializeThresholdEutra (it->reportConfigEutra.threshold2); + } + + SerializeInteger (it->reportConfigEutra.hysteresis, 0, 30); + + switch (it->reportConfigEutra.timeToTrigger) + { + case 0: + SerializeEnum (16, 0); + break; + case 40: + SerializeEnum (16, 1); + break; + case 64: + SerializeEnum (16, 2); + break; + case 80: + SerializeEnum (16, 3); + break; + case 100: + SerializeEnum (16, 4); + break; + case 128: + SerializeEnum (16, 5); + break; + case 160: + SerializeEnum (16, 6); + break; + case 256: + SerializeEnum (16, 7); + break; + case 320: + SerializeEnum (16, 8); + break; + case 480: + SerializeEnum (16, 9); + break; + case 512: + SerializeEnum (16, 10); + break; + case 640: + SerializeEnum (16, 11); + break; + case 1024: + SerializeEnum (16, 12); + break; + case 1280: + SerializeEnum (16, 13); + break; + case 2560: + SerializeEnum (16, 14); + break; + case 5120: + default: + SerializeEnum (16, 15); + } + } // end trigger type + + // Serialize triggerQuantity + if (it->reportConfigEutra.triggerQuantity == LteRrcSap::ReportConfigEutra::rsrp) + { + SerializeEnum (2, 0); + } + else + { + SerializeEnum (2, 1); + } + + // Serialize reportQuantity + if (it->reportConfigEutra.reportQuantity == LteRrcSap::ReportConfigEutra::sameAsTriggerQuantity) + { + SerializeEnum (2, 0); + } + else + { + SerializeEnum (2, 1); + } + + // Serialize maxReportCells + SerializeInteger (it->reportConfigEutra.maxReportCells, 1, MAX_CELL_REPORT); + + // Serialize reportInterval + switch (it->reportConfigEutra.reportInterval) + { + case LteRrcSap::ReportConfigEutra::ms120: + SerializeEnum (16, 0); + break; + case LteRrcSap::ReportConfigEutra::ms240: + SerializeEnum (16, 1); + break; + case LteRrcSap::ReportConfigEutra::ms480: + SerializeEnum (16, 2); + break; + case LteRrcSap::ReportConfigEutra::ms640: + SerializeEnum (16, 3); + break; + case LteRrcSap::ReportConfigEutra::ms1024: + SerializeEnum (16, 4); + break; + case LteRrcSap::ReportConfigEutra::ms2048: + SerializeEnum (16, 5); + break; + case LteRrcSap::ReportConfigEutra::ms5120: + SerializeEnum (16, 6); + break; + case LteRrcSap::ReportConfigEutra::ms10240: + SerializeEnum (16, 7); + break; + case LteRrcSap::ReportConfigEutra::min1: + SerializeEnum (16, 8); + break; + case LteRrcSap::ReportConfigEutra::min6: + SerializeEnum (16, 9); + break; + case LteRrcSap::ReportConfigEutra::min12: + SerializeEnum (16, 10); + break; + case LteRrcSap::ReportConfigEutra::min30: + SerializeEnum (16, 11); + break; + case LteRrcSap::ReportConfigEutra::min60: + SerializeEnum (16, 12); + break; + case LteRrcSap::ReportConfigEutra::spare3: + SerializeEnum (16, 13); + break; + case LteRrcSap::ReportConfigEutra::spare2: + SerializeEnum (16, 14); + break; + case LteRrcSap::ReportConfigEutra::spare1: + default: + SerializeEnum (16, 15); + } + + // Serialize reportAmount + switch (it->reportConfigEutra.reportAmount) + { + case 1: + SerializeEnum (8, 0); + break; + case 2: + SerializeEnum (8, 1); + break; + case 4: + SerializeEnum (8, 2); + break; + case 8: + SerializeEnum (8, 3); + break; + case 16: + SerializeEnum (8, 4); + break; + case 32: + SerializeEnum (8, 5); + break; + case 64: + SerializeEnum (8, 6); + break; + default: + SerializeEnum (8, 7); + } + } + } + + if (!measConfig.measIdToRemoveList.empty () ) + { + SerializeSequenceOf (measConfig.measIdToRemoveList.size (), MAX_MEAS_ID, 1); + for (std::list::iterator it = measConfig.measIdToRemoveList.begin (); it != measConfig.measIdToRemoveList.end (); it++) + { + SerializeInteger (*it, 1, MAX_MEAS_ID); + } + } + + if (!measConfig.measIdToAddModList.empty () ) + { + SerializeSequenceOf ( measConfig.measIdToAddModList.size (), MAX_MEAS_ID, 1); + for (std::list::iterator it = measConfig.measIdToAddModList.begin (); it != measConfig.measIdToAddModList.end (); it++) + { + SerializeInteger (it->measId, 1, MAX_MEAS_ID); + SerializeInteger (it->measObjectId, 1, MAX_OBJECT_ID); + SerializeInteger (it->reportConfigId, 1, MAX_REPORT_CONFIG_ID); + } + } + + if (measConfig.haveQuantityConfig ) + { + // QuantityConfig sequence + // 4 optional fields, only first (EUTRA) present. Extension marker yes. + std::bitset<4> quantityConfigOpts (0); + quantityConfigOpts.set (3,1); + SerializeSequence (quantityConfigOpts, true); + SerializeSequence (std::bitset<0> (), false); + + switch (measConfig.quantityConfig.filterCoefficientRSRP) + { + case 0: + SerializeEnum (16, 0); + break; + case 1: + SerializeEnum (16, 1); + break; + case 2: + SerializeEnum (16, 2); + break; + case 3: + SerializeEnum (16, 3); + break; + case 4: + SerializeEnum (16, 4); + break; + case 5: + SerializeEnum (16, 5); + break; + case 6: + SerializeEnum (16, 6); + break; + case 7: + SerializeEnum (16, 7); + break; + case 8: + SerializeEnum (16, 8); + break; + case 9: + SerializeEnum (16, 9); + break; + case 11: + SerializeEnum (16, 10); + break; + case 13: + SerializeEnum (16, 11); + break; + case 15: + SerializeEnum (16, 12); + break; + case 17: + SerializeEnum (16, 13); + break; + case 19: + SerializeEnum (16, 14); + break; + default: + SerializeEnum (16, 4); + } + + switch (measConfig.quantityConfig.filterCoefficientRSRQ) + { + case 0: + SerializeEnum (16, 0); + break; + case 1: + SerializeEnum (16, 1); + break; + case 2: + SerializeEnum (16, 2); + break; + case 3: + SerializeEnum (16, 3); + break; + case 4: + SerializeEnum (16, 4); + break; + case 5: + SerializeEnum (16, 5); + break; + case 6: + SerializeEnum (16, 6); + break; + case 7: + SerializeEnum (16, 7); + break; + case 8: + SerializeEnum (16, 8); + break; + case 9: + SerializeEnum (16, 9); + break; + case 11: + SerializeEnum (16, 10); + break; + case 13: + SerializeEnum (16, 11); + break; + case 15: + SerializeEnum (16, 12); + break; + case 17: + SerializeEnum (16, 13); + break; + case 19: + SerializeEnum (16, 14); + break; + default: + SerializeEnum (16, 4); + } + } + + if (measConfig.haveMeasGapConfig ) + { + switch (measConfig.measGapConfig.type) + { + case LteRrcSap::MeasGapConfig::RESET: + SerializeChoice (2, 0, false); + SerializeNull (); + break; + case LteRrcSap::MeasGapConfig::SETUP: + default: + SerializeSequence (std::bitset<0> (),false); + switch (measConfig.measGapConfig.gapOffsetChoice) + { + case LteRrcSap::MeasGapConfig::gp0: + SerializeChoice (2, 0, true); + SerializeInteger (measConfig.measGapConfig.gapOffsetValue, 0, 39); + break; + case LteRrcSap::MeasGapConfig::gp1: + default: + SerializeChoice (2, 1, true); + SerializeInteger (measConfig.measGapConfig.gapOffsetValue, 0, 79); + } + } + } + + if (measConfig.haveSmeasure ) + { + SerializeInteger (measConfig.sMeasure, 0, 97); + } + + // ...Here preRegistrationInfoHRPD would be serialized + + if (measConfig.haveSpeedStatePars ) + { + switch (measConfig.speedStatePars.type) + { + case LteRrcSap::SpeedStatePars::RESET: + SerializeChoice (2, 0, false); + SerializeNull (); + break; + case LteRrcSap::SpeedStatePars::SETUP: + default: + SerializeChoice (2, 1, false); + SerializeSequence (std::bitset<0> (), false); + switch (measConfig.speedStatePars.mobilityStateParameters.tEvaluation) + { + case 30: + SerializeEnum (8, 0); + break; + case 60: + SerializeEnum (8, 1); + break; + case 120: + SerializeEnum (8, 2); + break; + case 180: + SerializeEnum (8, 3); + break; + case 240: + SerializeEnum (8, 4); + break; + default: + SerializeEnum (8, 5); + break; + } + + switch (measConfig.speedStatePars.mobilityStateParameters.tHystNormal) + { + case 30: + SerializeEnum (8, 0); + break; + case 60: + SerializeEnum (8, 1); + break; + case 120: + SerializeEnum (8, 2); + break; + case 180: + SerializeEnum (8, 3); + break; + case 240: + SerializeEnum (8, 4); + break; + default: + SerializeEnum (8, 5); + break; + } + + SerializeInteger (measConfig.speedStatePars.mobilityStateParameters.nCellChangeMedium, 1, 16); + SerializeInteger (measConfig.speedStatePars.mobilityStateParameters.nCellChangeHigh, 1, 16); + + SerializeSequence (std::bitset<0> (), false); + switch (measConfig.speedStatePars.timeToTriggerSf.sfMedium) + { + case 25: + SerializeEnum (4, 0); + break; + case 50: + SerializeEnum (4, 1); + break; + case 75: + SerializeEnum (4, 2); + break; + case 100: + default: + SerializeEnum (4, 3); + } + + switch (measConfig.speedStatePars.timeToTriggerSf.sfHigh) + { + case 25: + SerializeEnum (4, 0); + break; + case 50: + SerializeEnum (4, 1); + break; + case 75: + SerializeEnum (4, 2); + break; + case 100: + default: + SerializeEnum (4, 3); + } + } + } +} + +Buffer::Iterator +RrcAsn1Header::DeserializeThresholdEutra (LteRrcSap::ThresholdEutra * thresholdEutra, Buffer::Iterator bIterator) +{ + return bIterator; +} + +Buffer::Iterator +RrcAsn1Header::DeserializeQoffsetRange (int8_t * qOffsetRange, Buffer::Iterator bIterator) +{ + return bIterator; +} + Buffer::Iterator RrcAsn1Header::DeserializeRadioResourceConfigDedicated (LteRrcSap::RadioResourceConfigDedicated *radioResourceConfigDedicated, Buffer::Iterator bIterator) { @@ -1153,11 +1963,11 @@ RrcAsn1Header::DeserializeLogicalChannelConfig (LteRrcSap::LogicalChannelConfig logicalChannelConfig->bucketSizeDurationMs = bucketSizeDurationMs; if (bitset1[0]) - { - // Deserialize logicalChannelGroup - bIterator = DeserializeInteger (&n,0,3,bIterator); - logicalChannelConfig->logicalChannelGroup = n; - } + { + // Deserialize logicalChannelGroup + bIterator = DeserializeInteger (&n,0,3,bIterator); + logicalChannelConfig->logicalChannelGroup = n; + } } return bIterator; } @@ -2092,6 +2902,60 @@ RrcAsn1Header::DeserializePlmnIdentity (uint32_t *plmnId, Buffer::Iterator bIter return bIterator; } +Buffer::Iterator +RrcAsn1Header::DeserializeMeasConfig (LteRrcSap::MeasConfig * measConfig, Buffer::Iterator bIterator) +{ + std::bitset<11> bitset11; + + // measConfig + bIterator = DeserializeSequence (&bitset11,true,bIterator); + + if (bitset11[10]) + { + // measObjectToRemoveList + } + if (bitset11[9]) + { + // measObjectToAddModList + } + if (bitset11[8]) + { + // reportConfigToRemoveList + } + if (bitset11[7]) + { + // reportConfigToAddModList + } + if (bitset11[6]) + { + // measIdToRemoveList + } + if (bitset11[5]) + { + // measIdToAddModList + } + if (bitset11[4]) + { + // quantityConfig + } + if (bitset11[3]) + { + // measGapConfig + } + if (bitset11[2]) + { + // s-Measure + } + if (bitset11[1]) + { + // preRegistrationInfoHRPD + } + if (bitset11[0]) + { + // speedStatePars + } + return bIterator; +} //////////////////// RrcConnectionRequest class //////////////////////// // Constructor @@ -2656,13 +3520,9 @@ RrcConnectionReconfigurationHeader::PreSerialize () const options.set (0,0); // No nonCriticalExtension SerializeSequence (options,false); - if (m_haveMeasConfig) { - // Serialize MeasConfig sequence - // 11 optional fields, extension marker present - std::bitset<11> measConfigOptional (0); - SerializeSequence (measConfigOptional,true); + SerializeMeasConfig (m_measConfig); } if (m_haveMobilityControlInfo) @@ -2810,55 +3670,7 @@ RrcConnectionReconfigurationHeader::Deserialize (Buffer::Iterator bIterator) m_haveMeasConfig = rrcConnRecOpts[5]; if (m_haveMeasConfig) { - std::bitset<11> bitset11; - - // measConfig - bIterator = DeserializeSequence (&bitset11,true,bIterator); - - if (bitset11[10]) - { - // measObjectToRemoveList - } - if (bitset11[9]) - { - // measObjectToAddModList - } - if (bitset11[8]) - { - // reportConfigToRemoveList - } - if (bitset11[7]) - { - // reportConfigToAddModList - } - if (bitset11[6]) - { - // measIdToRemoveList - } - if (bitset11[5]) - { - // measIdToAddModList - } - if (bitset11[4]) - { - // quantityConfig - } - if (bitset11[3]) - { - // measGapConfig - } - if (bitset11[2]) - { - // s-Measure - } - if (bitset11[1]) - { - // preRegistrationInfoHRPD - } - if (bitset11[0]) - { - // speedStatePars - } + bIterator = DeserializeMeasConfig (&m_measConfig, bIterator); } m_haveMobilityControlInfo = rrcConnRecOpts[4]; @@ -3188,9 +4000,7 @@ HandoverPreparationInfoHeader::PreSerialize () const SerializeSequence (std::bitset<0> (),true); // Serialize sourceMeasConfig - // 11 optional fields, extension marker present - std::bitset<11> measConfigOptional (0); - SerializeSequence (measConfigOptional,true); + SerializeMeasConfig (m_asConfig.sourceMeasConfig); // Serialize sourceRadioResourceConfig SerializeRadioResourceConfigDedicated (m_asConfig.sourceRadioResourceConfig); @@ -3279,53 +4089,7 @@ HandoverPreparationInfoHeader::Deserialize (Buffer::Iterator bIterator) bIterator = DeserializeSequence (&bitset0,true,bIterator); // Deserialize sourceMeasConfig - std::bitset<11> bitset11; - bIterator = DeserializeSequence (&bitset11,true,bIterator); - - if (bitset11[10]) //measObjectToRemoveList - { - // ... - } - if (bitset11[9]) //measObjectToAddModList - { - // ... - } - if (bitset11[8]) //reportConfigToRemoveList - { - // ... - } - if (bitset11[7]) //reportConfigToAddModList - { - // ... - } - if (bitset11[6]) //measIdToRemoveList - { - // ... - } - if (bitset11[5]) //measIdToAddModList - { - // ... - } - if (bitset11[4]) //quantityConfig - { - // ... - } - if (bitset11[3]) //measGapConfig - { - // ... - } - if (bitset11[2]) //s-Measure - { - // ... - } - if (bitset11[1]) //preRegistrationInfoHRPD - { - // ... - } - if (bitset11[0]) //speedStatePars - { - // ... - } + bIterator = DeserializeMeasConfig (&m_asConfig.sourceMeasConfig, bIterator); // Deserialize sourceRadioResourceConfig bIterator = DeserializeRadioResourceConfigDedicated (&m_asConfig.sourceRadioResourceConfig,bIterator); diff --git a/src/lte/model/lte-rrc-header.h b/src/lte/model/lte-rrc-header.h index 5325d5934..6164c34e8 100644 --- a/src/lte/model/lte-rrc-header.h +++ b/src/lte/model/lte-rrc-header.h @@ -61,7 +61,10 @@ protected: void SerializeMeasResults (LteRrcSap::MeasResults measResults) const; void SerializePlmnIdentity (uint32_t plmnId) const; void SerializeRachConfigCommon (LteRrcSap::RachConfigCommon rachConfigCommon) const; - + void SerializeMeasConfig (LteRrcSap::MeasConfig measConfig) const; + void SerializeQoffsetRange (int8_t qOffsetRange) const; + void SerializeThresholdEutra (LteRrcSap::ThresholdEutra thresholdEutra) const; + // Deserialization functions Buffer::Iterator DeserializeDrbToAddModList (std::list *drbToAddModLis, Buffer::Iterator bIterator); Buffer::Iterator DeserializeSrbToAddModList (std::list *srbToAddModList, Buffer::Iterator bIterator); @@ -75,6 +78,9 @@ protected: Buffer::Iterator DeserializeMeasResults (LteRrcSap::MeasResults *measResults, Buffer::Iterator bIterator); Buffer::Iterator DeserializePlmnIdentity (uint32_t *plmnId, Buffer::Iterator bIterator); Buffer::Iterator DeserializeRachConfigCommon (LteRrcSap::RachConfigCommon * rachConfigCommon, Buffer::Iterator bIterator); + Buffer::Iterator DeserializeMeasConfig (LteRrcSap::MeasConfig * measConfig, Buffer::Iterator bIterator); + Buffer::Iterator DeserializeQoffsetRange (int8_t * qOffsetRange, Buffer::Iterator bIterator); + Buffer::Iterator DeserializeThresholdEutra (LteRrcSap::ThresholdEutra * thresholdEutra, Buffer::Iterator bIterator); /** * This function prints RadioResourceConfigDedicated IE, for debugging purposes. diff --git a/src/lte/model/lte-rrc-sap.h b/src/lte/model/lte-rrc-sap.h index 25cf06dc0..e63845f24 100644 --- a/src/lte/model/lte-rrc-sap.h +++ b/src/lte/model/lte-rrc-sap.h @@ -218,12 +218,13 @@ public: struct ThresholdEutra { - uint8_t thresholdRsrp; - uint8_t thresholdRsrq; + enum {thresholdRsrp, thresholdRsrq} choice; + uint8_t range; }; struct ReportConfigEutra { + enum {event,periodical} triggerType; enum {eventA1,eventA2,eventA3,eventA4,eventA5} eventId; ThresholdEutra threshold1; // used for A1, A2, A4, A5 ThresholdEutra threshold2; // used for A5 From 168e87360abbb888e6537bd9daaff013066a3715 Mon Sep 17 00:00:00 2001 From: lluis Date: Tue, 19 Feb 2013 18:32:57 +0100 Subject: [PATCH 04/10] Add deserialization code for MeasConfig IE. --- src/lte/model/lte-rrc-header.cc | 758 +++++++++++++++++++++++++++++++- 1 file changed, 752 insertions(+), 6 deletions(-) diff --git a/src/lte/model/lte-rrc-header.cc b/src/lte/model/lte-rrc-header.cc index 19229f29e..80baa7f10 100644 --- a/src/lte/model/lte-rrc-header.cc +++ b/src/lte/model/lte-rrc-header.cc @@ -1658,12 +1658,64 @@ RrcAsn1Header::SerializeMeasConfig (LteRrcSap::MeasConfig measConfig) const Buffer::Iterator RrcAsn1Header::DeserializeThresholdEutra (LteRrcSap::ThresholdEutra * thresholdEutra, Buffer::Iterator bIterator) { + int thresholdEutraChoice, range; + bIterator = DeserializeChoice (2, false, &thresholdEutraChoice, bIterator); + + switch(thresholdEutraChoice) + { + case 0: thresholdEutra->choice = LteRrcSap::ThresholdEutra::thresholdRsrp; + bIterator = DeserializeInteger (&range, 0, 97, bIterator); + thresholdEutra->range = range; + break; + case 1: + default: thresholdEutra->choice = LteRrcSap::ThresholdEutra::thresholdRsrq; + bIterator = DeserializeInteger (&range, 0, 34, bIterator); + thresholdEutra->range = range; + } + return bIterator; } Buffer::Iterator RrcAsn1Header::DeserializeQoffsetRange (int8_t * qOffsetRange, Buffer::Iterator bIterator) { + int n; + bIterator = DeserializeEnum (31, &n, bIterator); + switch(n) + { + case 0: *qOffsetRange = -24; break; + case 1: *qOffsetRange = -22; break; + case 2: *qOffsetRange = -20; break; + case 3: *qOffsetRange = -18; break; + case 4: *qOffsetRange = -16; break; + case 5: *qOffsetRange = -14; break; + case 6: *qOffsetRange = -12; break; + case 7: *qOffsetRange = -10; break; + case 8: *qOffsetRange = -8; break; + case 9: *qOffsetRange = -6; break; + case 10: *qOffsetRange = -5; break; + case 11: *qOffsetRange = -4; break; + case 12: *qOffsetRange = -3; break; + case 13: *qOffsetRange = -2; break; + case 14: *qOffsetRange = -1; break; + case 15: *qOffsetRange = 0; break; + case 16: *qOffsetRange = 1; break; + case 17: *qOffsetRange = 2; break; + case 18: *qOffsetRange = 3; break; + case 19: *qOffsetRange = 4; break; + case 20: *qOffsetRange = 5; break; + case 21: *qOffsetRange = 6; break; + case 22: *qOffsetRange = 8; break; + case 23: *qOffsetRange = 10; break; + case 24: *qOffsetRange = 12; break; + case 25: *qOffsetRange = 14; break; + case 26: *qOffsetRange = 16; break; + case 27: *qOffsetRange = 18; break; + case 28: *qOffsetRange = 20; break; + case 29: *qOffsetRange = 22; break; + case 30: + default: *qOffsetRange = 24; + } return bIterator; } @@ -2905,7 +2957,10 @@ RrcAsn1Header::DeserializePlmnIdentity (uint32_t *plmnId, Buffer::Iterator bIter Buffer::Iterator RrcAsn1Header::DeserializeMeasConfig (LteRrcSap::MeasConfig * measConfig, Buffer::Iterator bIterator) { + std::bitset<0> bitset0; + std::bitset<2> bitset2; std::bitset<11> bitset11; + int n; // measConfig bIterator = DeserializeSequence (&bitset11,true,bIterator); @@ -2913,46 +2968,737 @@ RrcAsn1Header::DeserializeMeasConfig (LteRrcSap::MeasConfig * measConfig, Buffer if (bitset11[10]) { // measObjectToRemoveList + int measObjectToRemoveListElems; + bIterator = DeserializeSequenceOf (&measObjectToRemoveListElems, MAX_OBJECT_ID, 1, bIterator); + + for(int i=0; imeasObjectToRemoveList.push_back (n); + } } + if (bitset11[9]) { // measObjectToAddModList - } + int measObjectToAddModListElems; + bIterator = DeserializeSequenceOf (&measObjectToAddModListElems, MAX_OBJECT_ID, 1, bIterator); + + for(int i=0; imeasObjectId = n; + + int measObjectChoice; + bIterator = DeserializeChoice (4, true, &measObjectChoice, bIterator); + + switch(measObjectChoice) + { + case 1: + // Deserialize measObjectUTRA + // ... + break; + + case 2: + // Deserialize measObjectGERAN + // ... + break; + + case 3: + // Deserialize measObjectCDMA2000 + // ... + break; + + case 0: + default: + // Deserialize measObjectEUTRA + std::bitset<5> measObjectEutraOpts; + bIterator = DeserializeSequence (&measObjectEutraOpts, true, bIterator); + + // carrierFreq + bIterator = DeserializeInteger (&n, 0, MAX_EARFCN, bIterator); + elem->measObjectEutra.carrierFreq = n; + + // allowedMeasBandwidth + bIterator = DeserializeEnum (6, &n, bIterator); + switch(n) + { + case 0: elem->measObjectEutra.allowedMeasBandwidth = 6; + break; + case 1: elem->measObjectEutra.allowedMeasBandwidth = 15; + break; + case 2: elem->measObjectEutra.allowedMeasBandwidth = 25; + break; + case 3: elem->measObjectEutra.allowedMeasBandwidth = 50; + break; + case 4: elem->measObjectEutra.allowedMeasBandwidth = 75; + break; + case 5: + default: + elem->measObjectEutra.allowedMeasBandwidth = 100; + break; + } + + // presenceAntennaPort1 + bIterator = DeserializeBoolean (&elem->measObjectEutra.presenceAntennaPort1, bIterator); + + // neighCellConfig + bIterator = DeserializeBitstring (&bitset2, bIterator); + elem->measObjectEutra.neighCellConfig = bitset2.to_ulong(); + + // offsetFreq + DeserializeQoffsetRange (&elem->measObjectEutra.offsetFreq, bIterator); + + if(measObjectEutraOpts[4]) + { + // cellsToRemoveList + int numElems; + bIterator = DeserializeSequenceOf(&numElems, MAX_CELL_MEAS, 1, bIterator); + + for(int i = 0; imeasObjectEutra.cellsToRemoveList.push_back(n); + } + } + + if(measObjectEutraOpts[3]) + { + // cellsToAddModList + int numElems; + bIterator = DeserializeSequenceOf(&numElems, MAX_CELL_MEAS, 1, bIterator); + + for(int i = 0; icellIndex = n; + + // PhysCellId + bIterator = DeserializeInteger (&n, 0, 503, bIterator); + cellsToAddMod->physCellId = n; + + // cellIndividualOffset + bIterator = DeserializeQoffsetRange( &cellsToAddMod->cellIndividualOffset, bIterator); + + elem->measObjectEutra.cellsToAddModList.push_back(*cellsToAddMod); + } + } + + if(measObjectEutraOpts[2]) + { + // blackCellsToRemoveList + int numElems; + bIterator = DeserializeSequenceOf(&numElems, MAX_CELL_MEAS, 1, bIterator); + + for(int i = 0; imeasObjectEutra.blackCellsToRemoveList.push_back(n); + } + } + + + if(measObjectEutraOpts[1]) + { + // blackCellsToAddModList + int numElems; + bIterator = DeserializeSequenceOf(&numElems, MAX_CELL_MEAS, 1, bIterator); + + for(int i = 0; icellIndex = n; + + // PhysCellIdRange + std::bitset<1> isRangePresent; + bIterator = DeserializeSequence (&isRangePresent, false, bIterator); + + // start + bIterator = DeserializeInteger (&n, 0, 503, bIterator); + blackCellsToAddMod->physCellIdRange.start = n; + + blackCellsToAddMod->physCellIdRange.haveRange=isRangePresent[0]; + if (blackCellsToAddMod->physCellIdRange.haveRange) + { + // range + bIterator = DeserializeEnum (16, &n, bIterator); + switch(n) + { + case 0: blackCellsToAddMod->physCellIdRange.range = 4; break; + case 1: blackCellsToAddMod->physCellIdRange.range = 8; break; + case 2: blackCellsToAddMod->physCellIdRange.range = 12; break; + case 3: blackCellsToAddMod->physCellIdRange.range = 16; break; + case 4: blackCellsToAddMod->physCellIdRange.range = 24; break; + case 5: blackCellsToAddMod->physCellIdRange.range = 32; break; + case 6: blackCellsToAddMod->physCellIdRange.range = 48; break; + case 7: blackCellsToAddMod->physCellIdRange.range = 64; break; + case 8: blackCellsToAddMod->physCellIdRange.range = 84; break; + case 9: blackCellsToAddMod->physCellIdRange.range = 96; break; + case 10: blackCellsToAddMod->physCellIdRange.range = 128; break; + case 11: blackCellsToAddMod->physCellIdRange.range = 168; break; + case 12: blackCellsToAddMod->physCellIdRange.range = 252; break; + case 13: blackCellsToAddMod->physCellIdRange.range = 504; break; + default: blackCellsToAddMod->physCellIdRange.range = 0; + } + } + + elem->measObjectEutra.blackCellsToAddModList.push_back(*blackCellsToAddMod); + } + } + + elem->measObjectEutra.haveCellForWhichToReportCGI = measObjectEutraOpts[0]; + if(measObjectEutraOpts[0]) + { + // cellForWhichToReportCGI + bIterator = DeserializeInteger (&n, 0, 503, bIterator); + elem->measObjectEutra.cellForWhichToReportCGI = n; + } + } + measConfig->measObjectToAddModList.push_back (*elem); + } + } + if (bitset11[8]) { // reportConfigToRemoveList + int reportConfigToRemoveListElems; + bIterator = DeserializeSequenceOf (&reportConfigToRemoveListElems, MAX_REPORT_CONFIG_ID, 1, bIterator); + + for(int i=0; ireportConfigToRemoveList.push_back (n); + } } + if (bitset11[7]) { // reportConfigToAddModList + int reportConfigToAddModListElems; + bIterator = DeserializeSequenceOf (&reportConfigToAddModListElems, MAX_REPORT_CONFIG_ID, 1, bIterator); + + for(int i=0; ireportConfigId = n; + + // Deserialize reportConfig + int reportConfigChoice; + bIterator = DeserializeChoice (2, false, &reportConfigChoice, bIterator); + + if(reportConfigChoice == 0) + { + // reportConfigEUTRA + bIterator = DeserializeSequence (&bitset0, true, bIterator); + + // triggerType + int triggerTypeChoice; + bIterator = DeserializeChoice (2, false, &triggerTypeChoice, bIterator); + + if (triggerTypeChoice == 0) + { + // event + elem->reportConfigEutra.triggerType = LteRrcSap::ReportConfigEutra::event; + bIterator = DeserializeSequence (&bitset0, false, bIterator); + + // eventId + int eventIdChoice; + bIterator = DeserializeChoice (5, true, &eventIdChoice, bIterator); + + switch(eventIdChoice) + { + case 0: elem->reportConfigEutra.eventId = LteRrcSap::ReportConfigEutra::eventA1; + bIterator = DeserializeSequence (&bitset0, false, bIterator); + bIterator = DeserializeThresholdEutra (&elem->reportConfigEutra.threshold1, bIterator); + break; + + case 1: elem->reportConfigEutra.eventId = LteRrcSap::ReportConfigEutra::eventA2; + bIterator = DeserializeSequence (&bitset0, false, bIterator); + bIterator = DeserializeThresholdEutra (&elem->reportConfigEutra.threshold1, bIterator); + break; + + case 2: elem->reportConfigEutra.eventId = LteRrcSap::ReportConfigEutra::eventA3; + bIterator = DeserializeSequence (&bitset0, false, bIterator); + bIterator = DeserializeInteger (&n, -30, 30, bIterator); + elem->reportConfigEutra.a3Offset = n; + bIterator = DeserializeBoolean (&elem->reportConfigEutra.reportOnLeave, bIterator); + break; + + case 3: elem->reportConfigEutra.eventId = LteRrcSap::ReportConfigEutra::eventA4; + bIterator = DeserializeSequence (&bitset0, false, bIterator); + bIterator = DeserializeThresholdEutra (&elem->reportConfigEutra.threshold1, bIterator); + break; + + default: elem->reportConfigEutra.eventId = LteRrcSap::ReportConfigEutra::eventA5; + bIterator = DeserializeSequence (&bitset0, false, bIterator); + bIterator = DeserializeThresholdEutra (&elem->reportConfigEutra.threshold1, bIterator); + bIterator = DeserializeThresholdEutra (&elem->reportConfigEutra.threshold2, bIterator); + break; + } + + bIterator = DeserializeInteger (&n, 0, 30, bIterator); + elem->reportConfigEutra.hysteresis = n; + + bIterator = DeserializeEnum (16, &n, bIterator); + switch(n) + { + case 0: elem->reportConfigEutra.timeToTrigger = 0; break; + case 1: elem->reportConfigEutra.timeToTrigger = 40; break; + case 2: elem->reportConfigEutra.timeToTrigger = 64; break; + case 3: elem->reportConfigEutra.timeToTrigger = 80; break; + case 4: elem->reportConfigEutra.timeToTrigger = 100; break; + case 5: elem->reportConfigEutra.timeToTrigger = 128; break; + case 6: elem->reportConfigEutra.timeToTrigger = 160; break; + case 7: elem->reportConfigEutra.timeToTrigger = 256; break; + case 8: elem->reportConfigEutra.timeToTrigger = 320; break; + case 9: elem->reportConfigEutra.timeToTrigger = 480; break; + case 10: elem->reportConfigEutra.timeToTrigger = 512; break; + case 11: elem->reportConfigEutra.timeToTrigger = 640; break; + case 12: elem->reportConfigEutra.timeToTrigger = 1024; break; + case 13: elem->reportConfigEutra.timeToTrigger = 1280; break; + case 14: elem->reportConfigEutra.timeToTrigger = 2560; break; + case 15: + default: + elem->reportConfigEutra.timeToTrigger = 5120; break; + } + } + + if (triggerTypeChoice == 1) + { + // periodical + elem->reportConfigEutra.triggerType = LteRrcSap::ReportConfigEutra::periodical; + + bIterator = DeserializeSequence (&bitset0, false, bIterator); + bIterator = DeserializeEnum (2, &n, bIterator); + if(n==0) + { + elem->reportConfigEutra.purpose = LteRrcSap::ReportConfigEutra::reportStrongestCells; + } + else + { + elem->reportConfigEutra.purpose = LteRrcSap::ReportConfigEutra::reportCgi; + } + } + + // triggerQuantity + bIterator = DeserializeEnum (2, &n, bIterator); + if(n==0) + { + elem->reportConfigEutra.triggerQuantity = LteRrcSap::ReportConfigEutra::rsrp; + } + else + { + elem->reportConfigEutra.triggerQuantity = LteRrcSap::ReportConfigEutra::rsrq; + } + + // reportQuantity + bIterator = DeserializeEnum (2, &n, bIterator); + if(n==0) + { + elem->reportConfigEutra.reportQuantity = LteRrcSap::ReportConfigEutra::sameAsTriggerQuantity; + } + else + { + elem->reportConfigEutra.reportQuantity = LteRrcSap::ReportConfigEutra::both; + } + + // maxReportCells + bIterator = DeserializeInteger(&n, 1, MAX_CELL_REPORT, bIterator); + elem->reportConfigEutra.maxReportCells = n; + + // reportInterval + bIterator = DeserializeEnum (16, &n, bIterator); + switch(n) + { + case 0: + elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms120; + break; + case 1: + elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms240; + break; + case 2: + elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms480; + break; + case 3: + elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms640; + break; + case 4: + elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms1024; + break; + case 5: + elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms2048; + break; + case 6: + elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms5120; + break; + case 7: + elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms10240; + break; + case 8: + elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::min1; + break; + case 9: + elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::min6; + break; + case 10: + elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::min12; + break; + case 11: + elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::min30; + break; + case 12: + elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::min60; + break; + case 13: + elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::spare3; + break; + case 14: + elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::spare2; + break; + case 15: + default: + elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::spare1; + } + + // reportAmount + bIterator = DeserializeEnum (8, &n, bIterator); + switch(n) + { + case 0: elem->reportConfigEutra.reportAmount = 1; break; + case 1: elem->reportConfigEutra.reportAmount = 2; break; + case 2: elem->reportConfigEutra.reportAmount = 4; break; + case 3: elem->reportConfigEutra.reportAmount = 8; break; + case 4: elem->reportConfigEutra.reportAmount = 16; break; + case 5: elem->reportConfigEutra.reportAmount = 32; break; + case 6: elem->reportConfigEutra.reportAmount = 64; break; + default: elem->reportConfigEutra.reportAmount = 0; + } + } + + if(reportConfigChoice == 1) + { + // ReportConfigInterRAT + // ... + } + + measConfig->reportConfigToAddModList.push_back (*elem); + } } + if (bitset11[6]) { // measIdToRemoveList + int measIdToRemoveListElems; + bIterator = DeserializeSequenceOf (&measIdToRemoveListElems, MAX_MEAS_ID, 1, bIterator); + + for(int i=0; imeasIdToRemoveList.push_back (n); + } } + if (bitset11[5]) { // measIdToAddModList + int measIdToAddModListElems; + bIterator = DeserializeSequenceOf (&measIdToAddModListElems, MAX_MEAS_ID, 1, bIterator); + + for(int i=0; imeasId = n; + + bIterator = DeserializeInteger (&n, 1, MAX_OBJECT_ID, bIterator); + elem->measObjectId = n; + + bIterator = DeserializeInteger (&n, 1, MAX_REPORT_CONFIG_ID, bIterator); + elem->reportConfigId = n; + + measConfig->measIdToAddModList.push_back (*elem); + } } - if (bitset11[4]) + + measConfig->haveQuantityConfig = bitset11[4]; + if (measConfig->haveQuantityConfig) { // quantityConfig + std::bitset<4> quantityConfigOpts; + bIterator = DeserializeSequence (&quantityConfigOpts, true, bIterator); + + if(quantityConfigOpts[3]) + { + // quantityConfigEUTRA + bIterator = DeserializeSequence (&bitset0,false,bIterator); + bIterator = DeserializeEnum (16, &n, bIterator); + switch(n) + { + case 0: + measConfig->quantityConfig.filterCoefficientRSRP = 0; + break; + case 1: + measConfig->quantityConfig.filterCoefficientRSRP = 1; + break; + case 2: + measConfig->quantityConfig.filterCoefficientRSRP = 2; + break; + case 3: + measConfig->quantityConfig.filterCoefficientRSRP = 3; + break; + case 4: + measConfig->quantityConfig.filterCoefficientRSRP = 4; + break; + case 5: + measConfig->quantityConfig.filterCoefficientRSRP = 5; + break; + case 6: + measConfig->quantityConfig.filterCoefficientRSRP = 6; + break; + case 7: + measConfig->quantityConfig.filterCoefficientRSRP = 7; + break; + case 8: + measConfig->quantityConfig.filterCoefficientRSRP = 8; + break; + case 9: + measConfig->quantityConfig.filterCoefficientRSRP = 9; + break; + case 10: + measConfig->quantityConfig.filterCoefficientRSRP = 11; + break; + case 11: + measConfig->quantityConfig.filterCoefficientRSRP = 13; + break; + case 12: + measConfig->quantityConfig.filterCoefficientRSRP = 15; + break; + case 13: + measConfig->quantityConfig.filterCoefficientRSRP = 17; + break; + case 14: + measConfig->quantityConfig.filterCoefficientRSRP = 19; + break; + case 15: + measConfig->quantityConfig.filterCoefficientRSRP = 0; + break; + default: + measConfig->quantityConfig.filterCoefficientRSRP = 4; + } + bIterator = DeserializeEnum (16, &n, bIterator); + switch(n) + { + case 0: + measConfig->quantityConfig.filterCoefficientRSRQ = 0; + break; + case 1: + measConfig->quantityConfig.filterCoefficientRSRQ = 1; + break; + case 2: + measConfig->quantityConfig.filterCoefficientRSRQ = 2; + break; + case 3: + measConfig->quantityConfig.filterCoefficientRSRQ = 3; + break; + case 4: + measConfig->quantityConfig.filterCoefficientRSRQ = 4; + break; + case 5: + measConfig->quantityConfig.filterCoefficientRSRQ = 5; + break; + case 6: + measConfig->quantityConfig.filterCoefficientRSRQ = 6; + break; + case 7: + measConfig->quantityConfig.filterCoefficientRSRQ = 7; + break; + case 8: + measConfig->quantityConfig.filterCoefficientRSRQ = 8; + break; + case 9: + measConfig->quantityConfig.filterCoefficientRSRQ = 9; + break; + case 10: + measConfig->quantityConfig.filterCoefficientRSRQ = 11; + break; + case 11: + measConfig->quantityConfig.filterCoefficientRSRQ = 13; + break; + case 12: + measConfig->quantityConfig.filterCoefficientRSRQ = 15; + break; + case 13: + measConfig->quantityConfig.filterCoefficientRSRQ = 17; + break; + case 14: + measConfig->quantityConfig.filterCoefficientRSRQ = 19; + break; + case 15: + measConfig->quantityConfig.filterCoefficientRSRQ = 0; + break; + default: + measConfig->quantityConfig.filterCoefficientRSRQ = 4; + } + } + if(quantityConfigOpts[2]) + { + // quantityConfigUTRA + // ... + } + if(quantityConfigOpts[1]) + { + // quantityConfigGERAN + // ... + } + if(quantityConfigOpts[0]) + { + // quantityConfigCDMA2000 + // ... + } } - if (bitset11[3]) + + measConfig->haveMeasGapConfig = bitset11[3]; + if (measConfig->haveMeasGapConfig) { // measGapConfig + int measGapConfigChoice; + bIterator = DeserializeChoice (2, false, &measGapConfigChoice, bIterator); + switch (measGapConfigChoice) + { + case 0: + measConfig->measGapConfig.type = LteRrcSap::MeasGapConfig::RESET; + bIterator = DeserializeNull (bIterator); + break; + case 1: + default: + measConfig->measGapConfig.type = LteRrcSap::MeasGapConfig::SETUP; + bIterator = DeserializeSequence (&bitset0, false, bIterator); + + int gapOffsetChoice; + bIterator = DeserializeChoice (2, true, &gapOffsetChoice, bIterator); + switch(gapOffsetChoice) + { + case 0: + measConfig->measGapConfig.gapOffsetChoice = LteRrcSap::MeasGapConfig::gp0; + bIterator = DeserializeInteger (&n, 0, 39, bIterator); + measConfig->measGapConfig.gapOffsetValue = n; + break; + case 1: + default: + measConfig->measGapConfig.gapOffsetChoice = LteRrcSap::MeasGapConfig::gp1; + bIterator = DeserializeInteger (&n, 0, 79, bIterator); + measConfig->measGapConfig.gapOffsetValue = n; + } + } } - if (bitset11[2]) + + measConfig->haveSmeasure = bitset11[2]; + if (measConfig->haveSmeasure) { // s-Measure + bIterator = DeserializeInteger (&n, 0, 97, bIterator); + measConfig->sMeasure = n; } + if (bitset11[1]) { // preRegistrationInfoHRPD + // ... } - if (bitset11[0]) + + measConfig->haveSpeedStatePars = bitset11[0]; + if (measConfig->haveSpeedStatePars) { - // speedStatePars + // speedStatePars + int speedStateParsChoice; + bIterator = DeserializeChoice (2 , false, &speedStateParsChoice, bIterator); + switch(speedStateParsChoice) + { + case 0: + measConfig->speedStatePars.type = LteRrcSap::SpeedStatePars::RESET; + bIterator = DeserializeNull (bIterator); + break; + case 1: + default: + measConfig->speedStatePars.type = LteRrcSap::SpeedStatePars::SETUP; + bIterator = DeserializeSequence (&bitset0, false, bIterator); + + // Deserialize mobilityStateParameters + // Deserialize t-Evaluation + bIterator = DeserializeEnum (8, &n, bIterator); + switch(n) + { + case 0: + measConfig->speedStatePars.mobilityStateParameters.tEvaluation = 30; + break; + case 1: + measConfig->speedStatePars.mobilityStateParameters.tEvaluation = 60; + break; + case 2: + measConfig->speedStatePars.mobilityStateParameters.tEvaluation = 120; + break; + case 3: + measConfig->speedStatePars.mobilityStateParameters.tEvaluation = 180; + break; + case 4: + measConfig->speedStatePars.mobilityStateParameters.tEvaluation = 240; + break; + default: + measConfig->speedStatePars.mobilityStateParameters.tEvaluation = 0; + } + // Deserialize t-HystNormal + bIterator = DeserializeEnum (8, &n, bIterator); + switch(n) + { + case 0: + measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 30; + break; + case 1: + measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 60; + break; + case 2: + measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 120; + break; + case 3: + measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 180; + break; + case 4: + measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 240; + break; + default: + measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 0; + } + + bIterator = DeserializeInteger (&n, 1, 16, bIterator); + measConfig->speedStatePars.mobilityStateParameters.nCellChangeMedium = n; + + bIterator = DeserializeInteger (&n, 1, 16, bIterator); + measConfig->speedStatePars.mobilityStateParameters.nCellChangeHigh = n; + + // Deserialize timeToTriggerSf + bIterator = DeserializeEnum (4, &n, bIterator); + measConfig->speedStatePars.timeToTriggerSf.sfMedium = (n+1)*25; + bIterator = DeserializeEnum (4, &n, bIterator); + measConfig->speedStatePars.timeToTriggerSf.sfHigh = (n+1)*25; + } } return bIterator; } From ef2f84ea7138f5e1f828954102152b518546d95e Mon Sep 17 00:00:00 2001 From: lluis Date: Tue, 19 Feb 2013 19:40:15 +0100 Subject: [PATCH 05/10] Test MeasConfig IE --- src/lte/model/lte-rrc-header.cc | 71 ++++++++++++++++++++++++++++++ src/lte/test/test-asn1-encoding.cc | 38 +++++++++++++++- 2 files changed, 108 insertions(+), 1 deletion(-) diff --git a/src/lte/model/lte-rrc-header.cc b/src/lte/model/lte-rrc-header.cc index 80baa7f10..bcc545a22 100644 --- a/src/lte/model/lte-rrc-header.cc +++ b/src/lte/model/lte-rrc-header.cc @@ -1538,6 +1538,7 @@ RrcAsn1Header::SerializeMeasConfig (LteRrcSap::MeasConfig measConfig) const break; case LteRrcSap::MeasGapConfig::SETUP: default: + SerializeChoice (2, 1, false); SerializeSequence (std::bitset<0> (),false); switch (measConfig.measGapConfig.gapOffsetChoice) { @@ -4573,6 +4574,76 @@ RrcConnectionReconfigurationHeader::Print (std::ostream &os) const { os << "rrcTransactionIdentifier: " << (int) m_rrcTransactionIdentifier << std::endl; os << "haveMeasConfig: " << m_haveMeasConfig << std::endl; + if (m_haveMobilityControlInfo) + { + if(!m_measConfig.measObjectToRemoveList.empty()) + { + os << " measObjectToRemoveList: " ; + std::list auxList = m_measConfig.measObjectToRemoveList; + std::list::iterator it = auxList.begin (); + for ( ; it != auxList.end(); it++) + { + os << (int) *it << ", "; + } + os << std::endl; + } + if(!m_measConfig.reportConfigToRemoveList.empty()) + { + os << " reportConfigToRemoveList: " ; + std::list auxList = m_measConfig.reportConfigToRemoveList; + std::list::iterator it = auxList.begin (); + for ( ; it != auxList.end(); it++) + { + os << (int) *it << ", "; + } + os << std::endl; + } + if(!m_measConfig.measIdToRemoveList.empty()) + { + os << " measIdToRemoveList: " ; + std::list auxList = m_measConfig.measIdToRemoveList; + std::list::iterator it = auxList.begin (); + for ( ; it != auxList.end(); it++) + { + os << (int) *it << ", "; + } + os << std::endl; + } + + os << " haveQuantityConfig: " << m_measConfig.haveQuantityConfig << std::endl; + if (m_measConfig.haveQuantityConfig) + { + os << " filterCoefficientRSRP: " << (int)m_measConfig.quantityConfig.filterCoefficientRSRP << std::endl; + os << " filterCoefficientRSRQ:" << (int)m_measConfig.quantityConfig.filterCoefficientRSRQ << std::endl; + } + + os << " haveMeasGapConfig: " << m_measConfig.haveMeasGapConfig << std::endl; + if (m_measConfig.haveMeasGapConfig) + { + os << " measGapConfig.type: " << m_measConfig.measGapConfig.type << std::endl; + os << " measGapConfig.gap (gap0/1,value): (" << m_measConfig.measGapConfig.gapOffsetChoice + << "," << (int) m_measConfig.measGapConfig.gapOffsetValue << ")" << std::endl; + } + + os << " haveSmeasure: " << m_measConfig.haveSmeasure << std::endl; + if (m_measConfig.haveSmeasure) + { + os << " sMeasure: " << (int) m_measConfig.sMeasure << std::endl; + } + + os << " haveSpeedStatePars: " << m_measConfig.haveSpeedStatePars << std::endl; + if (m_measConfig.haveSpeedStatePars) + { + os << " speedStatePars.type: " << m_measConfig.speedStatePars.type << std::endl; + os << " speedStatePars.mobilityStateParameters.tEvaluation: " << (int)m_measConfig.speedStatePars.mobilityStateParameters.tEvaluation << std::endl; + os << " speedStatePars.mobilityStateParameters.tHystNormal: " << (int)m_measConfig.speedStatePars.mobilityStateParameters.tHystNormal << std::endl; + os << " speedStatePars.mobilityStateParameters.nCellChangeMedium: " << (int)m_measConfig.speedStatePars.mobilityStateParameters.nCellChangeMedium << std::endl; + os << " speedStatePars.mobilityStateParameters.nCellChangeHigh: " << (int)m_measConfig.speedStatePars.mobilityStateParameters.nCellChangeHigh << std::endl; + os << " speedStatePars.timeToTriggerSf.sfMedium: " << (int)m_measConfig.speedStatePars.timeToTriggerSf.sfMedium << std::endl; + os << " speedStatePars.timeToTriggerSf.sfHigh: " << (int)m_measConfig.speedStatePars.timeToTriggerSf.sfHigh << std::endl; + } + } + os << "haveMobilityControlInfo: " << m_haveMobilityControlInfo << std::endl; if (m_haveMobilityControlInfo) { diff --git a/src/lte/test/test-asn1-encoding.cc b/src/lte/test/test-asn1-encoding.cc index 1e9ce8fe3..7a6f95944 100644 --- a/src/lte/test/test-asn1-encoding.cc +++ b/src/lte/test/test-asn1-encoding.cc @@ -450,7 +450,43 @@ RrcConnectionReconfigurationTestCase::DoRun (void) LteRrcSap::RrcConnectionReconfiguration msg; msg.rrcTransactionIdentifier = 2; - msg.haveMeasConfig = false; + msg.haveMeasConfig = true; + + msg.measConfig.haveQuantityConfig = true; + msg.measConfig.quantityConfig.filterCoefficientRSRP = 8; + msg.measConfig.quantityConfig.filterCoefficientRSRQ = 7; + + msg.measConfig.haveMeasGapConfig = true; + msg.measConfig.measGapConfig.type = LteRrcSap::MeasGapConfig::SETUP; + msg.measConfig.measGapConfig.gapOffsetChoice = LteRrcSap::MeasGapConfig::gp0; + msg.measConfig.measGapConfig.gapOffsetValue = 21; + + msg.measConfig.haveSmeasure = true; + msg.measConfig.sMeasure = 57; + + msg.measConfig.haveSpeedStatePars = true; + msg.measConfig.speedStatePars.type = LteRrcSap::SpeedStatePars::SETUP; + msg.measConfig.speedStatePars.mobilityStateParameters.tEvaluation = 240; + msg.measConfig.speedStatePars.mobilityStateParameters.tHystNormal = 60; + msg.measConfig.speedStatePars.mobilityStateParameters.nCellChangeMedium = 5; + msg.measConfig.speedStatePars.mobilityStateParameters.nCellChangeHigh = 13; + msg.measConfig.speedStatePars.timeToTriggerSf.sfMedium = 25; + msg.measConfig.speedStatePars.timeToTriggerSf.sfHigh = 75; + + msg.measConfig.measObjectToRemoveList.push_back(23); + msg.measConfig.measObjectToRemoveList.push_back(13); + + msg.measConfig.reportConfigToRemoveList.push_back(7); + msg.measConfig.reportConfigToRemoveList.push_back(16); + + msg.measConfig.measIdToRemoveList.push_back(4); + msg.measConfig.measIdToRemoveList.push_back(18); + + // TODO: Test the following: + // std::list measObjectToAddModList; + // std::list reportConfigToAddModList; + // std::list measIdToAddModList; + msg.haveMobilityControlInfo = true; msg.mobilityControlInfo.targetPhysCellId = 4; msg.mobilityControlInfo.haveCarrierFreq = true; From 870ac2024e5392ea3ce72383991c8d8219d18e4e Mon Sep 17 00:00:00 2001 From: lluis Date: Tue, 19 Feb 2013 19:42:02 +0100 Subject: [PATCH 06/10] ns3 formatting --- src/lte/model/lte-rrc-header.cc | 1478 +++++++++++++++------------- src/lte/test/test-asn1-encoding.cc | 108 +- 2 files changed, 867 insertions(+), 719 deletions(-) diff --git a/src/lte/model/lte-rrc-header.cc b/src/lte/model/lte-rrc-header.cc index bcc545a22..955e2fb35 100644 --- a/src/lte/model/lte-rrc-header.cc +++ b/src/lte/model/lte-rrc-header.cc @@ -1661,19 +1661,21 @@ RrcAsn1Header::DeserializeThresholdEutra (LteRrcSap::ThresholdEutra * thresholdE { int thresholdEutraChoice, range; bIterator = DeserializeChoice (2, false, &thresholdEutraChoice, bIterator); - - switch(thresholdEutraChoice) - { - case 0: thresholdEutra->choice = LteRrcSap::ThresholdEutra::thresholdRsrp; + + switch (thresholdEutraChoice) + { + case 0: + thresholdEutra->choice = LteRrcSap::ThresholdEutra::thresholdRsrp; bIterator = DeserializeInteger (&range, 0, 97, bIterator); thresholdEutra->range = range; - break; + break; case 1: - default: thresholdEutra->choice = LteRrcSap::ThresholdEutra::thresholdRsrq; + default: + thresholdEutra->choice = LteRrcSap::ThresholdEutra::thresholdRsrq; bIterator = DeserializeInteger (&range, 0, 34, bIterator); thresholdEutra->range = range; - } - + } + return bIterator; } @@ -1682,41 +1684,102 @@ RrcAsn1Header::DeserializeQoffsetRange (int8_t * qOffsetRange, Buffer::Iterator { int n; bIterator = DeserializeEnum (31, &n, bIterator); - switch(n) - { - case 0: *qOffsetRange = -24; break; - case 1: *qOffsetRange = -22; break; - case 2: *qOffsetRange = -20; break; - case 3: *qOffsetRange = -18; break; - case 4: *qOffsetRange = -16; break; - case 5: *qOffsetRange = -14; break; - case 6: *qOffsetRange = -12; break; - case 7: *qOffsetRange = -10; break; - case 8: *qOffsetRange = -8; break; - case 9: *qOffsetRange = -6; break; - case 10: *qOffsetRange = -5; break; - case 11: *qOffsetRange = -4; break; - case 12: *qOffsetRange = -3; break; - case 13: *qOffsetRange = -2; break; - case 14: *qOffsetRange = -1; break; - case 15: *qOffsetRange = 0; break; - case 16: *qOffsetRange = 1; break; - case 17: *qOffsetRange = 2; break; - case 18: *qOffsetRange = 3; break; - case 19: *qOffsetRange = 4; break; - case 20: *qOffsetRange = 5; break; - case 21: *qOffsetRange = 6; break; - case 22: *qOffsetRange = 8; break; - case 23: *qOffsetRange = 10; break; - case 24: *qOffsetRange = 12; break; - case 25: *qOffsetRange = 14; break; - case 26: *qOffsetRange = 16; break; - case 27: *qOffsetRange = 18; break; - case 28: *qOffsetRange = 20; break; - case 29: *qOffsetRange = 22; break; + switch (n) + { + case 0: + *qOffsetRange = -24; + break; + case 1: + *qOffsetRange = -22; + break; + case 2: + *qOffsetRange = -20; + break; + case 3: + *qOffsetRange = -18; + break; + case 4: + *qOffsetRange = -16; + break; + case 5: + *qOffsetRange = -14; + break; + case 6: + *qOffsetRange = -12; + break; + case 7: + *qOffsetRange = -10; + break; + case 8: + *qOffsetRange = -8; + break; + case 9: + *qOffsetRange = -6; + break; + case 10: + *qOffsetRange = -5; + break; + case 11: + *qOffsetRange = -4; + break; + case 12: + *qOffsetRange = -3; + break; + case 13: + *qOffsetRange = -2; + break; + case 14: + *qOffsetRange = -1; + break; + case 15: + *qOffsetRange = 0; + break; + case 16: + *qOffsetRange = 1; + break; + case 17: + *qOffsetRange = 2; + break; + case 18: + *qOffsetRange = 3; + break; + case 19: + *qOffsetRange = 4; + break; + case 20: + *qOffsetRange = 5; + break; + case 21: + *qOffsetRange = 6; + break; + case 22: + *qOffsetRange = 8; + break; + case 23: + *qOffsetRange = 10; + break; + case 24: + *qOffsetRange = 12; + break; + case 25: + *qOffsetRange = 14; + break; + case 26: + *qOffsetRange = 16; + break; + case 27: + *qOffsetRange = 18; + break; + case 28: + *qOffsetRange = 20; + break; + case 29: + *qOffsetRange = 22; + break; case 30: - default: *qOffsetRange = 24; - } + default: + *qOffsetRange = 24; + } return bIterator; } @@ -2971,434 +3034,519 @@ RrcAsn1Header::DeserializeMeasConfig (LteRrcSap::MeasConfig * measConfig, Buffer // measObjectToRemoveList int measObjectToRemoveListElems; bIterator = DeserializeSequenceOf (&measObjectToRemoveListElems, MAX_OBJECT_ID, 1, bIterator); - - for(int i=0; imeasObjectToRemoveList.push_back (n); - } + + for (int i = 0; i < measObjectToRemoveListElems; i++) + { + bIterator = DeserializeInteger (&n, 1, MAX_OBJECT_ID, bIterator); + measConfig->measObjectToRemoveList.push_back (n); + } } - + if (bitset11[9]) { // measObjectToAddModList int measObjectToAddModListElems; bIterator = DeserializeSequenceOf (&measObjectToAddModListElems, MAX_OBJECT_ID, 1, bIterator); - - for(int i=0; imeasObjectId = n; - - int measObjectChoice; - bIterator = DeserializeChoice (4, true, &measObjectChoice, bIterator); - switch(measObjectChoice) + for (int i = 0; i < measObjectToAddModListElems; i++) { - case 1: - // Deserialize measObjectUTRA - // ... - break; - - case 2: - // Deserialize measObjectGERAN - // ... - break; - - case 3: - // Deserialize measObjectCDMA2000 - // ... - break; - - case 0: - default: - // Deserialize measObjectEUTRA - std::bitset<5> measObjectEutraOpts; - bIterator = DeserializeSequence (&measObjectEutraOpts, true, bIterator); - - // carrierFreq - bIterator = DeserializeInteger (&n, 0, MAX_EARFCN, bIterator); - elem->measObjectEutra.carrierFreq = n; - - // allowedMeasBandwidth - bIterator = DeserializeEnum (6, &n, bIterator); - switch(n) - { - case 0: elem->measObjectEutra.allowedMeasBandwidth = 6; - break; - case 1: elem->measObjectEutra.allowedMeasBandwidth = 15; - break; - case 2: elem->measObjectEutra.allowedMeasBandwidth = 25; - break; - case 3: elem->measObjectEutra.allowedMeasBandwidth = 50; - break; - case 4: elem->measObjectEutra.allowedMeasBandwidth = 75; - break; - case 5: + LteRrcSap::MeasObjectToAddMod * elem = new LteRrcSap::MeasObjectToAddMod (); + + bIterator = DeserializeSequence (&bitset0, false, bIterator); + + bIterator = DeserializeInteger (&n, 1, MAX_OBJECT_ID, bIterator); + elem->measObjectId = n; + + int measObjectChoice; + bIterator = DeserializeChoice (4, true, &measObjectChoice, bIterator); + + switch (measObjectChoice) + { + case 1: + // Deserialize measObjectUTRA + // ... + break; + + case 2: + // Deserialize measObjectGERAN + // ... + break; + + case 3: + // Deserialize measObjectCDMA2000 + // ... + break; + + case 0: default: - elem->measObjectEutra.allowedMeasBandwidth = 100; - break; - } - - // presenceAntennaPort1 - bIterator = DeserializeBoolean (&elem->measObjectEutra.presenceAntennaPort1, bIterator); - - // neighCellConfig - bIterator = DeserializeBitstring (&bitset2, bIterator); - elem->measObjectEutra.neighCellConfig = bitset2.to_ulong(); - - // offsetFreq - DeserializeQoffsetRange (&elem->measObjectEutra.offsetFreq, bIterator); + // Deserialize measObjectEUTRA + std::bitset<5> measObjectEutraOpts; + bIterator = DeserializeSequence (&measObjectEutraOpts, true, bIterator); - if(measObjectEutraOpts[4]) - { - // cellsToRemoveList - int numElems; - bIterator = DeserializeSequenceOf(&numElems, MAX_CELL_MEAS, 1, bIterator); - - for(int i = 0; imeasObjectEutra.cellsToRemoveList.push_back(n); - } - } + // carrierFreq + bIterator = DeserializeInteger (&n, 0, MAX_EARFCN, bIterator); + elem->measObjectEutra.carrierFreq = n; - if(measObjectEutraOpts[3]) - { - // cellsToAddModList - int numElems; - bIterator = DeserializeSequenceOf(&numElems, MAX_CELL_MEAS, 1, bIterator); - - for(int i = 0; icellIndex = n; - - // PhysCellId - bIterator = DeserializeInteger (&n, 0, 503, bIterator); - cellsToAddMod->physCellId = n; - - // cellIndividualOffset - bIterator = DeserializeQoffsetRange( &cellsToAddMod->cellIndividualOffset, bIterator); - - elem->measObjectEutra.cellsToAddModList.push_back(*cellsToAddMod); - } - } - - if(measObjectEutraOpts[2]) - { - // blackCellsToRemoveList - int numElems; - bIterator = DeserializeSequenceOf(&numElems, MAX_CELL_MEAS, 1, bIterator); - - for(int i = 0; imeasObjectEutra.blackCellsToRemoveList.push_back(n); - } - } - - - if(measObjectEutraOpts[1]) - { - // blackCellsToAddModList - int numElems; - bIterator = DeserializeSequenceOf(&numElems, MAX_CELL_MEAS, 1, bIterator); - - for(int i = 0; icellIndex = n; - - // PhysCellIdRange - std::bitset<1> isRangePresent; - bIterator = DeserializeSequence (&isRangePresent, false, bIterator); - - // start - bIterator = DeserializeInteger (&n, 0, 503, bIterator); - blackCellsToAddMod->physCellIdRange.start = n; - - blackCellsToAddMod->physCellIdRange.haveRange=isRangePresent[0]; - if (blackCellsToAddMod->physCellIdRange.haveRange) - { - // range - bIterator = DeserializeEnum (16, &n, bIterator); - switch(n) + // allowedMeasBandwidth + bIterator = DeserializeEnum (6, &n, bIterator); + switch (n) { - case 0: blackCellsToAddMod->physCellIdRange.range = 4; break; - case 1: blackCellsToAddMod->physCellIdRange.range = 8; break; - case 2: blackCellsToAddMod->physCellIdRange.range = 12; break; - case 3: blackCellsToAddMod->physCellIdRange.range = 16; break; - case 4: blackCellsToAddMod->physCellIdRange.range = 24; break; - case 5: blackCellsToAddMod->physCellIdRange.range = 32; break; - case 6: blackCellsToAddMod->physCellIdRange.range = 48; break; - case 7: blackCellsToAddMod->physCellIdRange.range = 64; break; - case 8: blackCellsToAddMod->physCellIdRange.range = 84; break; - case 9: blackCellsToAddMod->physCellIdRange.range = 96; break; - case 10: blackCellsToAddMod->physCellIdRange.range = 128; break; - case 11: blackCellsToAddMod->physCellIdRange.range = 168; break; - case 12: blackCellsToAddMod->physCellIdRange.range = 252; break; - case 13: blackCellsToAddMod->physCellIdRange.range = 504; break; - default: blackCellsToAddMod->physCellIdRange.range = 0; + case 0: + elem->measObjectEutra.allowedMeasBandwidth = 6; + break; + case 1: + elem->measObjectEutra.allowedMeasBandwidth = 15; + break; + case 2: + elem->measObjectEutra.allowedMeasBandwidth = 25; + break; + case 3: + elem->measObjectEutra.allowedMeasBandwidth = 50; + break; + case 4: + elem->measObjectEutra.allowedMeasBandwidth = 75; + break; + case 5: + default: + elem->measObjectEutra.allowedMeasBandwidth = 100; + break; } - } - - elem->measObjectEutra.blackCellsToAddModList.push_back(*blackCellsToAddMod); - } - } - elem->measObjectEutra.haveCellForWhichToReportCGI = measObjectEutraOpts[0]; - if(measObjectEutraOpts[0]) - { - // cellForWhichToReportCGI - bIterator = DeserializeInteger (&n, 0, 503, bIterator); - elem->measObjectEutra.cellForWhichToReportCGI = n; - } + // presenceAntennaPort1 + bIterator = DeserializeBoolean (&elem->measObjectEutra.presenceAntennaPort1, bIterator); + + // neighCellConfig + bIterator = DeserializeBitstring (&bitset2, bIterator); + elem->measObjectEutra.neighCellConfig = bitset2.to_ulong (); + + // offsetFreq + DeserializeQoffsetRange (&elem->measObjectEutra.offsetFreq, bIterator); + + if (measObjectEutraOpts[4]) + { + // cellsToRemoveList + int numElems; + bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS, 1, bIterator); + + for (int i = 0; i < numElems; i++) + { + bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIterator); + elem->measObjectEutra.cellsToRemoveList.push_back (n); + } + } + + if (measObjectEutraOpts[3]) + { + // cellsToAddModList + int numElems; + bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS, 1, bIterator); + + for (int i = 0; i < numElems; i++) + { + LteRrcSap::CellsToAddMod * cellsToAddMod = new LteRrcSap::CellsToAddMod (); + + bIterator = DeserializeSequence (&bitset0, false, bIterator); + + // cellIndex + bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIterator); + cellsToAddMod->cellIndex = n; + + // PhysCellId + bIterator = DeserializeInteger (&n, 0, 503, bIterator); + cellsToAddMod->physCellId = n; + + // cellIndividualOffset + bIterator = DeserializeQoffsetRange ( &cellsToAddMod->cellIndividualOffset, bIterator); + + elem->measObjectEutra.cellsToAddModList.push_back (*cellsToAddMod); + } + } + + if (measObjectEutraOpts[2]) + { + // blackCellsToRemoveList + int numElems; + bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS, 1, bIterator); + + for (int i = 0; i < numElems; i++) + { + bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIterator); + elem->measObjectEutra.blackCellsToRemoveList.push_back (n); + } + } + + + if (measObjectEutraOpts[1]) + { + // blackCellsToAddModList + int numElems; + bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS, 1, bIterator); + + for (int i = 0; i < numElems; i++) + { + LteRrcSap::BlackCellsToAddMod * blackCellsToAddMod = new LteRrcSap::BlackCellsToAddMod (); + bIterator = DeserializeSequence (&bitset0, false, bIterator); + + bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIterator); + blackCellsToAddMod->cellIndex = n; + + // PhysCellIdRange + std::bitset<1> isRangePresent; + bIterator = DeserializeSequence (&isRangePresent, false, bIterator); + + // start + bIterator = DeserializeInteger (&n, 0, 503, bIterator); + blackCellsToAddMod->physCellIdRange.start = n; + + blackCellsToAddMod->physCellIdRange.haveRange = isRangePresent[0]; + if (blackCellsToAddMod->physCellIdRange.haveRange) + { + // range + bIterator = DeserializeEnum (16, &n, bIterator); + switch (n) + { + case 0: + blackCellsToAddMod->physCellIdRange.range = 4; + break; + case 1: + blackCellsToAddMod->physCellIdRange.range = 8; + break; + case 2: + blackCellsToAddMod->physCellIdRange.range = 12; + break; + case 3: + blackCellsToAddMod->physCellIdRange.range = 16; + break; + case 4: + blackCellsToAddMod->physCellIdRange.range = 24; + break; + case 5: + blackCellsToAddMod->physCellIdRange.range = 32; + break; + case 6: + blackCellsToAddMod->physCellIdRange.range = 48; + break; + case 7: + blackCellsToAddMod->physCellIdRange.range = 64; + break; + case 8: + blackCellsToAddMod->physCellIdRange.range = 84; + break; + case 9: + blackCellsToAddMod->physCellIdRange.range = 96; + break; + case 10: + blackCellsToAddMod->physCellIdRange.range = 128; + break; + case 11: + blackCellsToAddMod->physCellIdRange.range = 168; + break; + case 12: + blackCellsToAddMod->physCellIdRange.range = 252; + break; + case 13: + blackCellsToAddMod->physCellIdRange.range = 504; + break; + default: + blackCellsToAddMod->physCellIdRange.range = 0; + } + } + + elem->measObjectEutra.blackCellsToAddModList.push_back (*blackCellsToAddMod); + } + } + + elem->measObjectEutra.haveCellForWhichToReportCGI = measObjectEutraOpts[0]; + if (measObjectEutraOpts[0]) + { + // cellForWhichToReportCGI + bIterator = DeserializeInteger (&n, 0, 503, bIterator); + elem->measObjectEutra.cellForWhichToReportCGI = n; + } + } + measConfig->measObjectToAddModList.push_back (*elem); } - measConfig->measObjectToAddModList.push_back (*elem); - } - } - + } + if (bitset11[8]) { // reportConfigToRemoveList int reportConfigToRemoveListElems; bIterator = DeserializeSequenceOf (&reportConfigToRemoveListElems, MAX_REPORT_CONFIG_ID, 1, bIterator); - - for(int i=0; ireportConfigToRemoveList.push_back (n); - } + + for (int i = 0; i < reportConfigToRemoveListElems; i++) + { + bIterator = DeserializeInteger (&n, 1, MAX_REPORT_CONFIG_ID, bIterator); + measConfig->reportConfigToRemoveList.push_back (n); + } } - + if (bitset11[7]) { // reportConfigToAddModList int reportConfigToAddModListElems; bIterator = DeserializeSequenceOf (&reportConfigToAddModListElems, MAX_REPORT_CONFIG_ID, 1, bIterator); - - for(int i=0; ireportConfigId = n; - - // Deserialize reportConfig - int reportConfigChoice; - bIterator = DeserializeChoice (2, false, &reportConfigChoice, bIterator); - - if(reportConfigChoice == 0) + + for (int i = 0; i < reportConfigToAddModListElems; i++) { - // reportConfigEUTRA - bIterator = DeserializeSequence (&bitset0, true, bIterator); - - // triggerType - int triggerTypeChoice; - bIterator = DeserializeChoice (2, false, &triggerTypeChoice, bIterator); - - if (triggerTypeChoice == 0) - { - // event - elem->reportConfigEutra.triggerType = LteRrcSap::ReportConfigEutra::event; - bIterator = DeserializeSequence (&bitset0, false, bIterator); - - // eventId - int eventIdChoice; - bIterator = DeserializeChoice (5, true, &eventIdChoice, bIterator); - - switch(eventIdChoice) + LteRrcSap::ReportConfigToAddMod * elem = new LteRrcSap::ReportConfigToAddMod (); + + bIterator = DeserializeSequence (&bitset0, false, bIterator); + bIterator = DeserializeInteger (&n, 1, MAX_REPORT_CONFIG_ID, bIterator); + elem->reportConfigId = n; + + // Deserialize reportConfig + int reportConfigChoice; + bIterator = DeserializeChoice (2, false, &reportConfigChoice, bIterator); + + if (reportConfigChoice == 0) { - case 0: elem->reportConfigEutra.eventId = LteRrcSap::ReportConfigEutra::eventA1; - bIterator = DeserializeSequence (&bitset0, false, bIterator); - bIterator = DeserializeThresholdEutra (&elem->reportConfigEutra.threshold1, bIterator); - break; + // reportConfigEUTRA + bIterator = DeserializeSequence (&bitset0, true, bIterator); - case 1: elem->reportConfigEutra.eventId = LteRrcSap::ReportConfigEutra::eventA2; - bIterator = DeserializeSequence (&bitset0, false, bIterator); - bIterator = DeserializeThresholdEutra (&elem->reportConfigEutra.threshold1, bIterator); - break; + // triggerType + int triggerTypeChoice; + bIterator = DeserializeChoice (2, false, &triggerTypeChoice, bIterator); - case 2: elem->reportConfigEutra.eventId = LteRrcSap::ReportConfigEutra::eventA3; - bIterator = DeserializeSequence (&bitset0, false, bIterator); - bIterator = DeserializeInteger (&n, -30, 30, bIterator); - elem->reportConfigEutra.a3Offset = n; - bIterator = DeserializeBoolean (&elem->reportConfigEutra.reportOnLeave, bIterator); - break; + if (triggerTypeChoice == 0) + { + // event + elem->reportConfigEutra.triggerType = LteRrcSap::ReportConfigEutra::event; + bIterator = DeserializeSequence (&bitset0, false, bIterator); - case 3: elem->reportConfigEutra.eventId = LteRrcSap::ReportConfigEutra::eventA4; - bIterator = DeserializeSequence (&bitset0, false, bIterator); - bIterator = DeserializeThresholdEutra (&elem->reportConfigEutra.threshold1, bIterator); - break; + // eventId + int eventIdChoice; + bIterator = DeserializeChoice (5, true, &eventIdChoice, bIterator); - default: elem->reportConfigEutra.eventId = LteRrcSap::ReportConfigEutra::eventA5; - bIterator = DeserializeSequence (&bitset0, false, bIterator); - bIterator = DeserializeThresholdEutra (&elem->reportConfigEutra.threshold1, bIterator); - bIterator = DeserializeThresholdEutra (&elem->reportConfigEutra.threshold2, bIterator); - break; + switch (eventIdChoice) + { + case 0: + elem->reportConfigEutra.eventId = LteRrcSap::ReportConfigEutra::eventA1; + bIterator = DeserializeSequence (&bitset0, false, bIterator); + bIterator = DeserializeThresholdEutra (&elem->reportConfigEutra.threshold1, bIterator); + break; + + case 1: + elem->reportConfigEutra.eventId = LteRrcSap::ReportConfigEutra::eventA2; + bIterator = DeserializeSequence (&bitset0, false, bIterator); + bIterator = DeserializeThresholdEutra (&elem->reportConfigEutra.threshold1, bIterator); + break; + + case 2: + elem->reportConfigEutra.eventId = LteRrcSap::ReportConfigEutra::eventA3; + bIterator = DeserializeSequence (&bitset0, false, bIterator); + bIterator = DeserializeInteger (&n, -30, 30, bIterator); + elem->reportConfigEutra.a3Offset = n; + bIterator = DeserializeBoolean (&elem->reportConfigEutra.reportOnLeave, bIterator); + break; + + case 3: + elem->reportConfigEutra.eventId = LteRrcSap::ReportConfigEutra::eventA4; + bIterator = DeserializeSequence (&bitset0, false, bIterator); + bIterator = DeserializeThresholdEutra (&elem->reportConfigEutra.threshold1, bIterator); + break; + + default: + elem->reportConfigEutra.eventId = LteRrcSap::ReportConfigEutra::eventA5; + bIterator = DeserializeSequence (&bitset0, false, bIterator); + bIterator = DeserializeThresholdEutra (&elem->reportConfigEutra.threshold1, bIterator); + bIterator = DeserializeThresholdEutra (&elem->reportConfigEutra.threshold2, bIterator); + break; + } + + bIterator = DeserializeInteger (&n, 0, 30, bIterator); + elem->reportConfigEutra.hysteresis = n; + + bIterator = DeserializeEnum (16, &n, bIterator); + switch (n) + { + case 0: + elem->reportConfigEutra.timeToTrigger = 0; + break; + case 1: + elem->reportConfigEutra.timeToTrigger = 40; + break; + case 2: + elem->reportConfigEutra.timeToTrigger = 64; + break; + case 3: + elem->reportConfigEutra.timeToTrigger = 80; + break; + case 4: + elem->reportConfigEutra.timeToTrigger = 100; + break; + case 5: + elem->reportConfigEutra.timeToTrigger = 128; + break; + case 6: + elem->reportConfigEutra.timeToTrigger = 160; + break; + case 7: + elem->reportConfigEutra.timeToTrigger = 256; + break; + case 8: + elem->reportConfigEutra.timeToTrigger = 320; + break; + case 9: + elem->reportConfigEutra.timeToTrigger = 480; + break; + case 10: + elem->reportConfigEutra.timeToTrigger = 512; + break; + case 11: + elem->reportConfigEutra.timeToTrigger = 640; + break; + case 12: + elem->reportConfigEutra.timeToTrigger = 1024; + break; + case 13: + elem->reportConfigEutra.timeToTrigger = 1280; + break; + case 14: + elem->reportConfigEutra.timeToTrigger = 2560; + break; + case 15: + default: + elem->reportConfigEutra.timeToTrigger = 5120; + break; + } + } + + if (triggerTypeChoice == 1) + { + // periodical + elem->reportConfigEutra.triggerType = LteRrcSap::ReportConfigEutra::periodical; + + bIterator = DeserializeSequence (&bitset0, false, bIterator); + bIterator = DeserializeEnum (2, &n, bIterator); + if (n == 0) + { + elem->reportConfigEutra.purpose = LteRrcSap::ReportConfigEutra::reportStrongestCells; + } + else + { + elem->reportConfigEutra.purpose = LteRrcSap::ReportConfigEutra::reportCgi; + } + } + + // triggerQuantity + bIterator = DeserializeEnum (2, &n, bIterator); + if (n == 0) + { + elem->reportConfigEutra.triggerQuantity = LteRrcSap::ReportConfigEutra::rsrp; + } + else + { + elem->reportConfigEutra.triggerQuantity = LteRrcSap::ReportConfigEutra::rsrq; + } + + // reportQuantity + bIterator = DeserializeEnum (2, &n, bIterator); + if (n == 0) + { + elem->reportConfigEutra.reportQuantity = LteRrcSap::ReportConfigEutra::sameAsTriggerQuantity; + } + else + { + elem->reportConfigEutra.reportQuantity = LteRrcSap::ReportConfigEutra::both; + } + + // maxReportCells + bIterator = DeserializeInteger (&n, 1, MAX_CELL_REPORT, bIterator); + elem->reportConfigEutra.maxReportCells = n; + + // reportInterval + bIterator = DeserializeEnum (16, &n, bIterator); + switch (n) + { + case 0: + elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms120; + break; + case 1: + elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms240; + break; + case 2: + elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms480; + break; + case 3: + elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms640; + break; + case 4: + elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms1024; + break; + case 5: + elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms2048; + break; + case 6: + elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms5120; + break; + case 7: + elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms10240; + break; + case 8: + elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::min1; + break; + case 9: + elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::min6; + break; + case 10: + elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::min12; + break; + case 11: + elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::min30; + break; + case 12: + elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::min60; + break; + case 13: + elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::spare3; + break; + case 14: + elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::spare2; + break; + case 15: + default: + elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::spare1; + } + + // reportAmount + bIterator = DeserializeEnum (8, &n, bIterator); + switch (n) + { + case 0: + elem->reportConfigEutra.reportAmount = 1; + break; + case 1: + elem->reportConfigEutra.reportAmount = 2; + break; + case 2: + elem->reportConfigEutra.reportAmount = 4; + break; + case 3: + elem->reportConfigEutra.reportAmount = 8; + break; + case 4: + elem->reportConfigEutra.reportAmount = 16; + break; + case 5: + elem->reportConfigEutra.reportAmount = 32; + break; + case 6: + elem->reportConfigEutra.reportAmount = 64; + break; + default: + elem->reportConfigEutra.reportAmount = 0; + } } - - bIterator = DeserializeInteger (&n, 0, 30, bIterator); - elem->reportConfigEutra.hysteresis = n; - bIterator = DeserializeEnum (16, &n, bIterator); - switch(n) + if (reportConfigChoice == 1) { - case 0: elem->reportConfigEutra.timeToTrigger = 0; break; - case 1: elem->reportConfigEutra.timeToTrigger = 40; break; - case 2: elem->reportConfigEutra.timeToTrigger = 64; break; - case 3: elem->reportConfigEutra.timeToTrigger = 80; break; - case 4: elem->reportConfigEutra.timeToTrigger = 100; break; - case 5: elem->reportConfigEutra.timeToTrigger = 128; break; - case 6: elem->reportConfigEutra.timeToTrigger = 160; break; - case 7: elem->reportConfigEutra.timeToTrigger = 256; break; - case 8: elem->reportConfigEutra.timeToTrigger = 320; break; - case 9: elem->reportConfigEutra.timeToTrigger = 480; break; - case 10: elem->reportConfigEutra.timeToTrigger = 512; break; - case 11: elem->reportConfigEutra.timeToTrigger = 640; break; - case 12: elem->reportConfigEutra.timeToTrigger = 1024; break; - case 13: elem->reportConfigEutra.timeToTrigger = 1280; break; - case 14: elem->reportConfigEutra.timeToTrigger = 2560; break; - case 15: - default: - elem->reportConfigEutra.timeToTrigger = 5120; break; - } - } - - if (triggerTypeChoice == 1) - { - // periodical - elem->reportConfigEutra.triggerType = LteRrcSap::ReportConfigEutra::periodical; - - bIterator = DeserializeSequence (&bitset0, false, bIterator); - bIterator = DeserializeEnum (2, &n, bIterator); - if(n==0) - { - elem->reportConfigEutra.purpose = LteRrcSap::ReportConfigEutra::reportStrongestCells; + // ReportConfigInterRAT + // ... } - else - { - elem->reportConfigEutra.purpose = LteRrcSap::ReportConfigEutra::reportCgi; - } - } - - // triggerQuantity - bIterator = DeserializeEnum (2, &n, bIterator); - if(n==0) - { - elem->reportConfigEutra.triggerQuantity = LteRrcSap::ReportConfigEutra::rsrp; - } - else - { - elem->reportConfigEutra.triggerQuantity = LteRrcSap::ReportConfigEutra::rsrq; - } - - // reportQuantity - bIterator = DeserializeEnum (2, &n, bIterator); - if(n==0) - { - elem->reportConfigEutra.reportQuantity = LteRrcSap::ReportConfigEutra::sameAsTriggerQuantity; - } - else - { - elem->reportConfigEutra.reportQuantity = LteRrcSap::ReportConfigEutra::both; - } - - // maxReportCells - bIterator = DeserializeInteger(&n, 1, MAX_CELL_REPORT, bIterator); - elem->reportConfigEutra.maxReportCells = n; - - // reportInterval - bIterator = DeserializeEnum (16, &n, bIterator); - switch(n) - { - case 0: - elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms120; - break; - case 1: - elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms240; - break; - case 2: - elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms480; - break; - case 3: - elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms640; - break; - case 4: - elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms1024; - break; - case 5: - elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms2048; - break; - case 6: - elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms5120; - break; - case 7: - elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms10240; - break; - case 8: - elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::min1; - break; - case 9: - elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::min6; - break; - case 10: - elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::min12; - break; - case 11: - elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::min30; - break; - case 12: - elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::min60; - break; - case 13: - elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::spare3; - break; - case 14: - elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::spare2; - break; - case 15: - default: - elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::spare1; - } - - // reportAmount - bIterator = DeserializeEnum (8, &n, bIterator); - switch(n) - { - case 0: elem->reportConfigEutra.reportAmount = 1; break; - case 1: elem->reportConfigEutra.reportAmount = 2; break; - case 2: elem->reportConfigEutra.reportAmount = 4; break; - case 3: elem->reportConfigEutra.reportAmount = 8; break; - case 4: elem->reportConfigEutra.reportAmount = 16; break; - case 5: elem->reportConfigEutra.reportAmount = 32; break; - case 6: elem->reportConfigEutra.reportAmount = 64; break; - default: elem->reportConfigEutra.reportAmount = 0; - } + + measConfig->reportConfigToAddModList.push_back (*elem); } - - if(reportConfigChoice == 1) - { - // ReportConfigInterRAT - // ... - } - - measConfig->reportConfigToAddModList.push_back (*elem); - } } if (bitset11[6]) @@ -3406,12 +3554,12 @@ RrcAsn1Header::DeserializeMeasConfig (LteRrcSap::MeasConfig * measConfig, Buffer // measIdToRemoveList int measIdToRemoveListElems; bIterator = DeserializeSequenceOf (&measIdToRemoveListElems, MAX_MEAS_ID, 1, bIterator); - - for(int i=0; imeasIdToRemoveList.push_back (n); - } + + for (int i = 0; i < measIdToRemoveListElems; i++) + { + bIterator = DeserializeInteger (&n, 1, MAX_MEAS_ID, bIterator); + measConfig->measIdToRemoveList.push_back (n); + } } if (bitset11[5]) @@ -3419,163 +3567,163 @@ RrcAsn1Header::DeserializeMeasConfig (LteRrcSap::MeasConfig * measConfig, Buffer // measIdToAddModList int measIdToAddModListElems; bIterator = DeserializeSequenceOf (&measIdToAddModListElems, MAX_MEAS_ID, 1, bIterator); - - for(int i=0; imeasId = n; - - bIterator = DeserializeInteger (&n, 1, MAX_OBJECT_ID, bIterator); - elem->measObjectId = n; - - bIterator = DeserializeInteger (&n, 1, MAX_REPORT_CONFIG_ID, bIterator); - elem->reportConfigId = n; - - measConfig->measIdToAddModList.push_back (*elem); - } + + for (int i = 0; i < measIdToAddModListElems; i++) + { + LteRrcSap::MeasIdToAddMod * elem = new LteRrcSap::MeasIdToAddMod (); + + bIterator = DeserializeSequence (&bitset0, false, bIterator); + + bIterator = DeserializeInteger (&n, 1, MAX_MEAS_ID, bIterator); + elem->measId = n; + + bIterator = DeserializeInteger (&n, 1, MAX_OBJECT_ID, bIterator); + elem->measObjectId = n; + + bIterator = DeserializeInteger (&n, 1, MAX_REPORT_CONFIG_ID, bIterator); + elem->reportConfigId = n; + + measConfig->measIdToAddModList.push_back (*elem); + } } - + measConfig->haveQuantityConfig = bitset11[4]; if (measConfig->haveQuantityConfig) { // quantityConfig std::bitset<4> quantityConfigOpts; bIterator = DeserializeSequence (&quantityConfigOpts, true, bIterator); - - if(quantityConfigOpts[3]) - { - // quantityConfigEUTRA - bIterator = DeserializeSequence (&bitset0,false,bIterator); - bIterator = DeserializeEnum (16, &n, bIterator); - switch(n) + + if (quantityConfigOpts[3]) { - case 0: - measConfig->quantityConfig.filterCoefficientRSRP = 0; - break; - case 1: - measConfig->quantityConfig.filterCoefficientRSRP = 1; - break; - case 2: - measConfig->quantityConfig.filterCoefficientRSRP = 2; - break; - case 3: - measConfig->quantityConfig.filterCoefficientRSRP = 3; - break; - case 4: - measConfig->quantityConfig.filterCoefficientRSRP = 4; - break; - case 5: - measConfig->quantityConfig.filterCoefficientRSRP = 5; - break; - case 6: - measConfig->quantityConfig.filterCoefficientRSRP = 6; - break; - case 7: - measConfig->quantityConfig.filterCoefficientRSRP = 7; - break; - case 8: - measConfig->quantityConfig.filterCoefficientRSRP = 8; - break; - case 9: - measConfig->quantityConfig.filterCoefficientRSRP = 9; - break; - case 10: - measConfig->quantityConfig.filterCoefficientRSRP = 11; - break; - case 11: - measConfig->quantityConfig.filterCoefficientRSRP = 13; - break; - case 12: - measConfig->quantityConfig.filterCoefficientRSRP = 15; - break; - case 13: - measConfig->quantityConfig.filterCoefficientRSRP = 17; - break; - case 14: - measConfig->quantityConfig.filterCoefficientRSRP = 19; - break; - case 15: - measConfig->quantityConfig.filterCoefficientRSRP = 0; - break; - default: - measConfig->quantityConfig.filterCoefficientRSRP = 4; + // quantityConfigEUTRA + bIterator = DeserializeSequence (&bitset0,false,bIterator); + bIterator = DeserializeEnum (16, &n, bIterator); + switch (n) + { + case 0: + measConfig->quantityConfig.filterCoefficientRSRP = 0; + break; + case 1: + measConfig->quantityConfig.filterCoefficientRSRP = 1; + break; + case 2: + measConfig->quantityConfig.filterCoefficientRSRP = 2; + break; + case 3: + measConfig->quantityConfig.filterCoefficientRSRP = 3; + break; + case 4: + measConfig->quantityConfig.filterCoefficientRSRP = 4; + break; + case 5: + measConfig->quantityConfig.filterCoefficientRSRP = 5; + break; + case 6: + measConfig->quantityConfig.filterCoefficientRSRP = 6; + break; + case 7: + measConfig->quantityConfig.filterCoefficientRSRP = 7; + break; + case 8: + measConfig->quantityConfig.filterCoefficientRSRP = 8; + break; + case 9: + measConfig->quantityConfig.filterCoefficientRSRP = 9; + break; + case 10: + measConfig->quantityConfig.filterCoefficientRSRP = 11; + break; + case 11: + measConfig->quantityConfig.filterCoefficientRSRP = 13; + break; + case 12: + measConfig->quantityConfig.filterCoefficientRSRP = 15; + break; + case 13: + measConfig->quantityConfig.filterCoefficientRSRP = 17; + break; + case 14: + measConfig->quantityConfig.filterCoefficientRSRP = 19; + break; + case 15: + measConfig->quantityConfig.filterCoefficientRSRP = 0; + break; + default: + measConfig->quantityConfig.filterCoefficientRSRP = 4; + } + bIterator = DeserializeEnum (16, &n, bIterator); + switch (n) + { + case 0: + measConfig->quantityConfig.filterCoefficientRSRQ = 0; + break; + case 1: + measConfig->quantityConfig.filterCoefficientRSRQ = 1; + break; + case 2: + measConfig->quantityConfig.filterCoefficientRSRQ = 2; + break; + case 3: + measConfig->quantityConfig.filterCoefficientRSRQ = 3; + break; + case 4: + measConfig->quantityConfig.filterCoefficientRSRQ = 4; + break; + case 5: + measConfig->quantityConfig.filterCoefficientRSRQ = 5; + break; + case 6: + measConfig->quantityConfig.filterCoefficientRSRQ = 6; + break; + case 7: + measConfig->quantityConfig.filterCoefficientRSRQ = 7; + break; + case 8: + measConfig->quantityConfig.filterCoefficientRSRQ = 8; + break; + case 9: + measConfig->quantityConfig.filterCoefficientRSRQ = 9; + break; + case 10: + measConfig->quantityConfig.filterCoefficientRSRQ = 11; + break; + case 11: + measConfig->quantityConfig.filterCoefficientRSRQ = 13; + break; + case 12: + measConfig->quantityConfig.filterCoefficientRSRQ = 15; + break; + case 13: + measConfig->quantityConfig.filterCoefficientRSRQ = 17; + break; + case 14: + measConfig->quantityConfig.filterCoefficientRSRQ = 19; + break; + case 15: + measConfig->quantityConfig.filterCoefficientRSRQ = 0; + break; + default: + measConfig->quantityConfig.filterCoefficientRSRQ = 4; + } } - bIterator = DeserializeEnum (16, &n, bIterator); - switch(n) + if (quantityConfigOpts[2]) { - case 0: - measConfig->quantityConfig.filterCoefficientRSRQ = 0; - break; - case 1: - measConfig->quantityConfig.filterCoefficientRSRQ = 1; - break; - case 2: - measConfig->quantityConfig.filterCoefficientRSRQ = 2; - break; - case 3: - measConfig->quantityConfig.filterCoefficientRSRQ = 3; - break; - case 4: - measConfig->quantityConfig.filterCoefficientRSRQ = 4; - break; - case 5: - measConfig->quantityConfig.filterCoefficientRSRQ = 5; - break; - case 6: - measConfig->quantityConfig.filterCoefficientRSRQ = 6; - break; - case 7: - measConfig->quantityConfig.filterCoefficientRSRQ = 7; - break; - case 8: - measConfig->quantityConfig.filterCoefficientRSRQ = 8; - break; - case 9: - measConfig->quantityConfig.filterCoefficientRSRQ = 9; - break; - case 10: - measConfig->quantityConfig.filterCoefficientRSRQ = 11; - break; - case 11: - measConfig->quantityConfig.filterCoefficientRSRQ = 13; - break; - case 12: - measConfig->quantityConfig.filterCoefficientRSRQ = 15; - break; - case 13: - measConfig->quantityConfig.filterCoefficientRSRQ = 17; - break; - case 14: - measConfig->quantityConfig.filterCoefficientRSRQ = 19; - break; - case 15: - measConfig->quantityConfig.filterCoefficientRSRQ = 0; - break; - default: - measConfig->quantityConfig.filterCoefficientRSRQ = 4; + // quantityConfigUTRA + // ... + } + if (quantityConfigOpts[1]) + { + // quantityConfigGERAN + // ... + } + if (quantityConfigOpts[0]) + { + // quantityConfigCDMA2000 + // ... } - } - if(quantityConfigOpts[2]) - { - // quantityConfigUTRA - // ... - } - if(quantityConfigOpts[1]) - { - // quantityConfigGERAN - // ... - } - if(quantityConfigOpts[0]) - { - // quantityConfigCDMA2000 - // ... - } } - + measConfig->haveMeasGapConfig = bitset11[3]; if (measConfig->haveMeasGapConfig) { @@ -3583,7 +3731,7 @@ RrcAsn1Header::DeserializeMeasConfig (LteRrcSap::MeasConfig * measConfig, Buffer int measGapConfigChoice; bIterator = DeserializeChoice (2, false, &measGapConfigChoice, bIterator); switch (measGapConfigChoice) - { + { case 0: measConfig->measGapConfig.type = LteRrcSap::MeasGapConfig::RESET; bIterator = DeserializeNull (bIterator); @@ -3592,11 +3740,11 @@ RrcAsn1Header::DeserializeMeasConfig (LteRrcSap::MeasConfig * measConfig, Buffer default: measConfig->measGapConfig.type = LteRrcSap::MeasGapConfig::SETUP; bIterator = DeserializeSequence (&bitset0, false, bIterator); - + int gapOffsetChoice; bIterator = DeserializeChoice (2, true, &gapOffsetChoice, bIterator); - switch(gapOffsetChoice) - { + switch (gapOffsetChoice) + { case 0: measConfig->measGapConfig.gapOffsetChoice = LteRrcSap::MeasGapConfig::gp0; bIterator = DeserializeInteger (&n, 0, 39, bIterator); @@ -3606,11 +3754,11 @@ RrcAsn1Header::DeserializeMeasConfig (LteRrcSap::MeasConfig * measConfig, Buffer default: measConfig->measGapConfig.gapOffsetChoice = LteRrcSap::MeasGapConfig::gp1; bIterator = DeserializeInteger (&n, 0, 79, bIterator); - measConfig->measGapConfig.gapOffsetValue = n; - } - } + measConfig->measGapConfig.gapOffsetValue = n; + } + } } - + measConfig->haveSmeasure = bitset11[2]; if (measConfig->haveSmeasure) { @@ -3624,15 +3772,15 @@ RrcAsn1Header::DeserializeMeasConfig (LteRrcSap::MeasConfig * measConfig, Buffer // preRegistrationInfoHRPD // ... } - + measConfig->haveSpeedStatePars = bitset11[0]; if (measConfig->haveSpeedStatePars) { - // speedStatePars + // speedStatePars int speedStateParsChoice; - bIterator = DeserializeChoice (2 , false, &speedStateParsChoice, bIterator); - switch(speedStateParsChoice) - { + bIterator = DeserializeChoice (2, false, &speedStateParsChoice, bIterator); + switch (speedStateParsChoice) + { case 0: measConfig->speedStatePars.type = LteRrcSap::SpeedStatePars::RESET; bIterator = DeserializeNull (bIterator); @@ -3641,12 +3789,12 @@ RrcAsn1Header::DeserializeMeasConfig (LteRrcSap::MeasConfig * measConfig, Buffer default: measConfig->speedStatePars.type = LteRrcSap::SpeedStatePars::SETUP; bIterator = DeserializeSequence (&bitset0, false, bIterator); - + // Deserialize mobilityStateParameters // Deserialize t-Evaluation bIterator = DeserializeEnum (8, &n, bIterator); - switch(n) - { + switch (n) + { case 0: measConfig->speedStatePars.mobilityStateParameters.tEvaluation = 30; break; @@ -3664,11 +3812,11 @@ RrcAsn1Header::DeserializeMeasConfig (LteRrcSap::MeasConfig * measConfig, Buffer break; default: measConfig->speedStatePars.mobilityStateParameters.tEvaluation = 0; - } + } // Deserialize t-HystNormal bIterator = DeserializeEnum (8, &n, bIterator); - switch(n) - { + switch (n) + { case 0: measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 30; break; @@ -3686,20 +3834,20 @@ RrcAsn1Header::DeserializeMeasConfig (LteRrcSap::MeasConfig * measConfig, Buffer break; default: measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 0; - } - + } + bIterator = DeserializeInteger (&n, 1, 16, bIterator); measConfig->speedStatePars.mobilityStateParameters.nCellChangeMedium = n; - + bIterator = DeserializeInteger (&n, 1, 16, bIterator); measConfig->speedStatePars.mobilityStateParameters.nCellChangeHigh = n; - + // Deserialize timeToTriggerSf bIterator = DeserializeEnum (4, &n, bIterator); - measConfig->speedStatePars.timeToTriggerSf.sfMedium = (n+1)*25; + measConfig->speedStatePars.timeToTriggerSf.sfMedium = (n + 1) * 25; bIterator = DeserializeEnum (4, &n, bIterator); - measConfig->speedStatePars.timeToTriggerSf.sfHigh = (n+1)*25; - } + measConfig->speedStatePars.timeToTriggerSf.sfHigh = (n + 1) * 25; + } } return bIterator; } @@ -4576,74 +4724,74 @@ RrcConnectionReconfigurationHeader::Print (std::ostream &os) const os << "haveMeasConfig: " << m_haveMeasConfig << std::endl; if (m_haveMobilityControlInfo) { - if(!m_measConfig.measObjectToRemoveList.empty()) - { - os << " measObjectToRemoveList: " ; - std::list auxList = m_measConfig.measObjectToRemoveList; - std::list::iterator it = auxList.begin (); - for ( ; it != auxList.end(); it++) + if (!m_measConfig.measObjectToRemoveList.empty ()) { - os << (int) *it << ", "; - } - os << std::endl; - } - if(!m_measConfig.reportConfigToRemoveList.empty()) - { - os << " reportConfigToRemoveList: " ; - std::list auxList = m_measConfig.reportConfigToRemoveList; - std::list::iterator it = auxList.begin (); - for ( ; it != auxList.end(); it++) + os << " measObjectToRemoveList: "; + std::list auxList = m_measConfig.measObjectToRemoveList; + std::list::iterator it = auxList.begin (); + for (; it != auxList.end (); it++) + { + os << (int) *it << ", "; + } + os << std::endl; + } + if (!m_measConfig.reportConfigToRemoveList.empty ()) { - os << (int) *it << ", "; - } - os << std::endl; - } - if(!m_measConfig.measIdToRemoveList.empty()) - { - os << " measIdToRemoveList: " ; - std::list auxList = m_measConfig.measIdToRemoveList; - std::list::iterator it = auxList.begin (); - for ( ; it != auxList.end(); it++) + os << " reportConfigToRemoveList: "; + std::list auxList = m_measConfig.reportConfigToRemoveList; + std::list::iterator it = auxList.begin (); + for (; it != auxList.end (); it++) + { + os << (int) *it << ", "; + } + os << std::endl; + } + if (!m_measConfig.measIdToRemoveList.empty ()) { - os << (int) *it << ", "; - } - os << std::endl; - } - + os << " measIdToRemoveList: "; + std::list auxList = m_measConfig.measIdToRemoveList; + std::list::iterator it = auxList.begin (); + for (; it != auxList.end (); it++) + { + os << (int) *it << ", "; + } + os << std::endl; + } + os << " haveQuantityConfig: " << m_measConfig.haveQuantityConfig << std::endl; if (m_measConfig.haveQuantityConfig) - { - os << " filterCoefficientRSRP: " << (int)m_measConfig.quantityConfig.filterCoefficientRSRP << std::endl; - os << " filterCoefficientRSRQ:" << (int)m_measConfig.quantityConfig.filterCoefficientRSRQ << std::endl; - } - + { + os << " filterCoefficientRSRP: " << (int)m_measConfig.quantityConfig.filterCoefficientRSRP << std::endl; + os << " filterCoefficientRSRQ:" << (int)m_measConfig.quantityConfig.filterCoefficientRSRQ << std::endl; + } + os << " haveMeasGapConfig: " << m_measConfig.haveMeasGapConfig << std::endl; if (m_measConfig.haveMeasGapConfig) - { - os << " measGapConfig.type: " << m_measConfig.measGapConfig.type << std::endl; - os << " measGapConfig.gap (gap0/1,value): (" << m_measConfig.measGapConfig.gapOffsetChoice - << "," << (int) m_measConfig.measGapConfig.gapOffsetValue << ")" << std::endl; - } - + { + os << " measGapConfig.type: " << m_measConfig.measGapConfig.type << std::endl; + os << " measGapConfig.gap (gap0/1,value): (" << m_measConfig.measGapConfig.gapOffsetChoice + << "," << (int) m_measConfig.measGapConfig.gapOffsetValue << ")" << std::endl; + } + os << " haveSmeasure: " << m_measConfig.haveSmeasure << std::endl; if (m_measConfig.haveSmeasure) - { - os << " sMeasure: " << (int) m_measConfig.sMeasure << std::endl; - } + { + os << " sMeasure: " << (int) m_measConfig.sMeasure << std::endl; + } os << " haveSpeedStatePars: " << m_measConfig.haveSpeedStatePars << std::endl; if (m_measConfig.haveSpeedStatePars) - { - os << " speedStatePars.type: " << m_measConfig.speedStatePars.type << std::endl; - os << " speedStatePars.mobilityStateParameters.tEvaluation: " << (int)m_measConfig.speedStatePars.mobilityStateParameters.tEvaluation << std::endl; - os << " speedStatePars.mobilityStateParameters.tHystNormal: " << (int)m_measConfig.speedStatePars.mobilityStateParameters.tHystNormal << std::endl; - os << " speedStatePars.mobilityStateParameters.nCellChangeMedium: " << (int)m_measConfig.speedStatePars.mobilityStateParameters.nCellChangeMedium << std::endl; - os << " speedStatePars.mobilityStateParameters.nCellChangeHigh: " << (int)m_measConfig.speedStatePars.mobilityStateParameters.nCellChangeHigh << std::endl; - os << " speedStatePars.timeToTriggerSf.sfMedium: " << (int)m_measConfig.speedStatePars.timeToTriggerSf.sfMedium << std::endl; - os << " speedStatePars.timeToTriggerSf.sfHigh: " << (int)m_measConfig.speedStatePars.timeToTriggerSf.sfHigh << std::endl; - } + { + os << " speedStatePars.type: " << m_measConfig.speedStatePars.type << std::endl; + os << " speedStatePars.mobilityStateParameters.tEvaluation: " << (int)m_measConfig.speedStatePars.mobilityStateParameters.tEvaluation << std::endl; + os << " speedStatePars.mobilityStateParameters.tHystNormal: " << (int)m_measConfig.speedStatePars.mobilityStateParameters.tHystNormal << std::endl; + os << " speedStatePars.mobilityStateParameters.nCellChangeMedium: " << (int)m_measConfig.speedStatePars.mobilityStateParameters.nCellChangeMedium << std::endl; + os << " speedStatePars.mobilityStateParameters.nCellChangeHigh: " << (int)m_measConfig.speedStatePars.mobilityStateParameters.nCellChangeHigh << std::endl; + os << " speedStatePars.timeToTriggerSf.sfMedium: " << (int)m_measConfig.speedStatePars.timeToTriggerSf.sfMedium << std::endl; + os << " speedStatePars.timeToTriggerSf.sfHigh: " << (int)m_measConfig.speedStatePars.timeToTriggerSf.sfHigh << std::endl; + } } - + os << "haveMobilityControlInfo: " << m_haveMobilityControlInfo << std::endl; if (m_haveMobilityControlInfo) { diff --git a/src/lte/test/test-asn1-encoding.cc b/src/lte/test/test-asn1-encoding.cc index 7a6f95944..8997f396f 100644 --- a/src/lte/test/test-asn1-encoding.cc +++ b/src/lte/test/test-asn1-encoding.cc @@ -46,7 +46,7 @@ public: pkt->CopyData (buffer, psize); for (uint32_t i = 0; i < psize; i++) { - sprintf (&sbuffer[i*3],"%02x ",buffer[i]); + sprintf (&sbuffer[i * 3],"%02x ",buffer[i]); } return std::string (sbuffer); } @@ -95,12 +95,12 @@ public: virtual void DoRun (void) = 0; LteRrcSap::RadioResourceConfigDedicated CreateRadioResourceConfigDedicated (); void AssertEqualRadioResourceConfigDedicated (LteRrcSap::RadioResourceConfigDedicated rrcd1, LteRrcSap::RadioResourceConfigDedicated rrcd2); - + protected: Ptr packet; }; -RrcHeaderTestCase :: RrcHeaderTestCase(std::string s) : TestCase(s) +RrcHeaderTestCase :: RrcHeaderTestCase (std::string s) : TestCase (s) { } @@ -254,7 +254,7 @@ RrcConnectionRequestTestCase::RrcConnectionRequestTestCase () : RrcHeaderTestCas void RrcConnectionRequestTestCase::DoRun (void) { - packet = Create(); + packet = Create (); NS_LOG_DEBUG ("============= RrcConnectionRequestTestCase ==========="); LteRrcSap::RrcConnectionRequest msg; @@ -282,7 +282,7 @@ RrcConnectionRequestTestCase::DoRun (void) // Check that the destination and source headers contain the same values NS_TEST_ASSERT_MSG_EQ (source.GetMmec (),destination.GetMmec (), "Different m_mmec!"); NS_TEST_ASSERT_MSG_EQ (source.GetMtmsi (),destination.GetMtmsi (), "Different m_mTmsi!"); - + packet = 0; } @@ -301,7 +301,7 @@ RrcConnectionSetupTestCase::RrcConnectionSetupTestCase () : RrcHeaderTestCase (" void RrcConnectionSetupTestCase::DoRun (void) { - packet = Create(); + packet = Create (); NS_LOG_DEBUG ("============= RrcConnectionSetupTestCase ==========="); LteRrcSap::RrcConnectionSetup msg; @@ -331,7 +331,7 @@ RrcConnectionSetupTestCase::DoRun (void) NS_TEST_ASSERT_MSG_EQ (source.GetRrcTransactionIdentifier (),destination.GetRrcTransactionIdentifier (), "RrcTransactionIdentifier"); AssertEqualRadioResourceConfigDedicated (source.GetRadioResourceConfigDedicated (),destination.GetRadioResourceConfigDedicated ()); - + packet = 0; } @@ -350,7 +350,7 @@ RrcConnectionSetupCompleteTestCase::RrcConnectionSetupCompleteTestCase () : RrcH void RrcConnectionSetupCompleteTestCase::DoRun (void) { - packet = Create(); + packet = Create (); NS_LOG_DEBUG ("============= RrcConnectionSetupCompleteTestCase ==========="); LteRrcSap::RrcConnectionSetupCompleted msg; @@ -377,7 +377,7 @@ RrcConnectionSetupCompleteTestCase::DoRun (void) // Check that the destination and source headers contain the same values NS_TEST_ASSERT_MSG_EQ (source.GetRrcTransactionIdentifier (),destination.GetRrcTransactionIdentifier (), "RrcTransactionIdentifier"); - + packet = 0; } @@ -397,7 +397,7 @@ RrcConnectionReconfigurationCompleteTestCase::RrcConnectionReconfigurationComple void RrcConnectionReconfigurationCompleteTestCase::DoRun (void) { - packet = Create(); + packet = Create (); NS_LOG_DEBUG ("============= RrcConnectionReconfigurationCompleteTestCase ==========="); LteRrcSap::RrcConnectionReconfigurationCompleted msg; @@ -424,7 +424,7 @@ RrcConnectionReconfigurationCompleteTestCase::DoRun (void) // Check that the destination and source headers contain the same values NS_TEST_ASSERT_MSG_EQ (source.GetRrcTransactionIdentifier (),destination.GetRrcTransactionIdentifier (), "RrcTransactionIdentifier"); - + packet = 0; } @@ -444,26 +444,26 @@ RrcConnectionReconfigurationTestCase::RrcConnectionReconfigurationTestCase () void RrcConnectionReconfigurationTestCase::DoRun (void) { - packet = Create(); + packet = Create (); NS_LOG_DEBUG ("============= RrcConnectionReconfigurationTestCase ==========="); LteRrcSap::RrcConnectionReconfiguration msg; msg.rrcTransactionIdentifier = 2; msg.haveMeasConfig = true; - + msg.measConfig.haveQuantityConfig = true; msg.measConfig.quantityConfig.filterCoefficientRSRP = 8; msg.measConfig.quantityConfig.filterCoefficientRSRQ = 7; - + msg.measConfig.haveMeasGapConfig = true; msg.measConfig.measGapConfig.type = LteRrcSap::MeasGapConfig::SETUP; msg.measConfig.measGapConfig.gapOffsetChoice = LteRrcSap::MeasGapConfig::gp0; - msg.measConfig.measGapConfig.gapOffsetValue = 21; - + msg.measConfig.measGapConfig.gapOffsetValue = 21; + msg.measConfig.haveSmeasure = true; msg.measConfig.sMeasure = 57; - + msg.measConfig.haveSpeedStatePars = true; msg.measConfig.speedStatePars.type = LteRrcSap::SpeedStatePars::SETUP; msg.measConfig.speedStatePars.mobilityStateParameters.tEvaluation = 240; @@ -472,21 +472,21 @@ RrcConnectionReconfigurationTestCase::DoRun (void) msg.measConfig.speedStatePars.mobilityStateParameters.nCellChangeHigh = 13; msg.measConfig.speedStatePars.timeToTriggerSf.sfMedium = 25; msg.measConfig.speedStatePars.timeToTriggerSf.sfHigh = 75; - - msg.measConfig.measObjectToRemoveList.push_back(23); - msg.measConfig.measObjectToRemoveList.push_back(13); - - msg.measConfig.reportConfigToRemoveList.push_back(7); - msg.measConfig.reportConfigToRemoveList.push_back(16); - msg.measConfig.measIdToRemoveList.push_back(4); - msg.measConfig.measIdToRemoveList.push_back(18); + msg.measConfig.measObjectToRemoveList.push_back (23); + msg.measConfig.measObjectToRemoveList.push_back (13); + + msg.measConfig.reportConfigToRemoveList.push_back (7); + msg.measConfig.reportConfigToRemoveList.push_back (16); + + msg.measConfig.measIdToRemoveList.push_back (4); + msg.measConfig.measIdToRemoveList.push_back (18); // TODO: Test the following: // std::list measObjectToAddModList; // std::list reportConfigToAddModList; // std::list measIdToAddModList; - + msg.haveMobilityControlInfo = true; msg.mobilityControlInfo.targetPhysCellId = 4; msg.mobilityControlInfo.haveCarrierFreq = true; @@ -575,7 +575,7 @@ RrcConnectionReconfigurationTestCase::DoRun (void) { AssertEqualRadioResourceConfigDedicated (source.GetRadioResourceConfigDedicated (), destination.GetRadioResourceConfigDedicated ()); } - + packet = 0; } @@ -594,7 +594,7 @@ HandoverPreparationInfoTestCase::HandoverPreparationInfoTestCase () : RrcHeaderT void HandoverPreparationInfoTestCase::DoRun (void) { - packet = Create(); + packet = Create (); NS_LOG_DEBUG ("============= HandoverPreparationInfoTestCase ==========="); LteRrcSap::HandoverPreparationInfo msg; @@ -609,12 +609,12 @@ HandoverPreparationInfoTestCase::DoRun (void) msg.asConfig.sourceSystemInformationBlockType1.cellAccessRelatedInfo.csgIdentity = 4; msg.asConfig.sourceSystemInformationBlockType1.cellAccessRelatedInfo.plmnIdentityInfo.plmnIdentity = 123; - msg.asConfig.sourceSystemInformationBlockType2.freqInfo.ulBandwidth=100; - msg.asConfig.sourceSystemInformationBlockType2.freqInfo.ulCarrierFreq=10; + msg.asConfig.sourceSystemInformationBlockType2.freqInfo.ulBandwidth = 100; + msg.asConfig.sourceSystemInformationBlockType2.freqInfo.ulCarrierFreq = 10; msg.asConfig.sourceSystemInformationBlockType2.radioResourceConfigCommon.rachConfigCommon.preambleInfo.numberOfRaPreambles = 4; msg.asConfig.sourceSystemInformationBlockType2.radioResourceConfigCommon.rachConfigCommon.raSupervisionInfo.preambleTransMax = 3; msg.asConfig.sourceSystemInformationBlockType2.radioResourceConfigCommon.rachConfigCommon.raSupervisionInfo.raResponseWindowSize = 6; - + HandoverPreparationInfoHeader source; source.SetMessage (msg); @@ -644,8 +644,8 @@ HandoverPreparationInfoTestCase::DoRun (void) NS_TEST_ASSERT_MSG_EQ (source.GetAsConfig ().sourceSystemInformationBlockType1.cellAccessRelatedInfo.cellIdentity, destination.GetAsConfig ().sourceSystemInformationBlockType1.cellAccessRelatedInfo.cellIdentity, "cellIdentity"); NS_TEST_ASSERT_MSG_EQ (source.GetAsConfig ().sourceSystemInformationBlockType1.cellAccessRelatedInfo.csgIdentity, destination.GetAsConfig ().sourceSystemInformationBlockType1.cellAccessRelatedInfo.csgIdentity, "csgIdentity"); NS_TEST_ASSERT_MSG_EQ (source.GetAsConfig ().sourceDlCarrierFreq, destination.GetAsConfig ().sourceDlCarrierFreq, "sourceDlCarrierFreq"); - - packet = 0; + + packet = 0; } // --------------------------- CLASS RrcConnectionReestablishmentRequestTestCase ----------------------------- @@ -663,7 +663,7 @@ RrcConnectionReestablishmentRequestTestCase::RrcConnectionReestablishmentRequest void RrcConnectionReestablishmentRequestTestCase::DoRun (void) { - packet = Create(); + packet = Create (); NS_LOG_DEBUG ("============= RrcConnectionReestablishmentRequestTestCase ==========="); LteRrcSap::RrcConnectionReestablishmentRequest msg; @@ -694,7 +694,7 @@ RrcConnectionReestablishmentRequestTestCase::DoRun (void) NS_TEST_ASSERT_MSG_EQ (source.GetUeIdentity ().cRnti, destination.GetUeIdentity ().cRnti, "cRnti"); NS_TEST_ASSERT_MSG_EQ (source.GetUeIdentity ().physCellId, destination.GetUeIdentity ().physCellId, "physCellId"); NS_TEST_ASSERT_MSG_EQ (source.GetReestablishmentCause (),destination.GetReestablishmentCause (), "ReestablishmentCause"); - + packet = 0; } @@ -713,7 +713,7 @@ RrcConnectionReestablishmentTestCase::RrcConnectionReestablishmentTestCase () : void RrcConnectionReestablishmentTestCase::DoRun (void) { - packet = Create(); + packet = Create (); NS_LOG_DEBUG ("============= RrcConnectionReestablishmentTestCase ==========="); LteRrcSap::RrcConnectionReestablishment msg; @@ -742,7 +742,7 @@ RrcConnectionReestablishmentTestCase::DoRun (void) // Check that the destination and source headers contain the same values NS_TEST_ASSERT_MSG_EQ (source.GetRrcTransactionIdentifier (), destination.GetRrcTransactionIdentifier (), "rrcTransactionIdentifier"); AssertEqualRadioResourceConfigDedicated (source.GetRadioResourceConfigDedicated (),destination.GetRadioResourceConfigDedicated ()); - + packet = 0; } @@ -761,7 +761,7 @@ RrcConnectionReestablishmentCompleteTestCase::RrcConnectionReestablishmentComple void RrcConnectionReestablishmentCompleteTestCase::DoRun (void) { - packet = Create(); + packet = Create (); NS_LOG_DEBUG ("============= RrcConnectionReestablishmentCompleteTestCase ==========="); LteRrcSap::RrcConnectionReestablishmentComplete msg; @@ -788,7 +788,7 @@ RrcConnectionReestablishmentCompleteTestCase::DoRun (void) // Check that the destination and source headers contain the same values NS_TEST_ASSERT_MSG_EQ (source.GetRrcTransactionIdentifier (), destination.GetRrcTransactionIdentifier (), "rrcTransactionIdentifier"); - + packet = 0; } @@ -807,7 +807,7 @@ RrcConnectionRejectTestCase::RrcConnectionRejectTestCase () : RrcHeaderTestCase void RrcConnectionRejectTestCase::DoRun (void) { - packet = Create(); + packet = Create (); NS_LOG_DEBUG ("============= RrcConnectionRejectTestCase ==========="); LteRrcSap::RrcConnectionReject msg; @@ -834,7 +834,7 @@ RrcConnectionRejectTestCase::DoRun (void) // Check that the destination and source headers contain the same values NS_TEST_ASSERT_MSG_EQ (source.GetMessage ().waitTime, destination.GetMessage ().waitTime, "Different waitTime!"); - + packet = 0; } @@ -853,7 +853,7 @@ MeasurementReportTestCase::MeasurementReportTestCase () : RrcHeaderTestCase ("Te void MeasurementReportTestCase::DoRun (void) { - packet = Create(); + packet = Create (); NS_LOG_DEBUG ("============= MeasurementReportTestCase ==========="); LteRrcSap::MeasurementReport msg; @@ -945,7 +945,7 @@ MeasurementReportTestCase::DoRun (void) } } - packet = 0; + packet = 0; } // --------------------------- CLASS Asn1EncodingSuite ----------------------------- @@ -959,17 +959,17 @@ Asn1EncodingSuite::Asn1EncodingSuite () : TestSuite ("test-asn1-encoding", UNIT) { NS_LOG_FUNCTION (this); - AddTestCase (new RrcConnectionRequestTestCase()); - AddTestCase (new RrcConnectionSetupTestCase()); - AddTestCase (new RrcConnectionSetupCompleteTestCase()); - AddTestCase (new RrcConnectionReconfigurationCompleteTestCase()); - AddTestCase (new RrcConnectionReconfigurationTestCase()); - AddTestCase (new HandoverPreparationInfoTestCase()); - AddTestCase (new RrcConnectionReestablishmentRequestTestCase()); - AddTestCase (new RrcConnectionReestablishmentTestCase()); - AddTestCase (new RrcConnectionReestablishmentCompleteTestCase()); - AddTestCase (new RrcConnectionRejectTestCase()); - AddTestCase (new MeasurementReportTestCase()); + AddTestCase (new RrcConnectionRequestTestCase ()); + AddTestCase (new RrcConnectionSetupTestCase ()); + AddTestCase (new RrcConnectionSetupCompleteTestCase ()); + AddTestCase (new RrcConnectionReconfigurationCompleteTestCase ()); + AddTestCase (new RrcConnectionReconfigurationTestCase ()); + AddTestCase (new HandoverPreparationInfoTestCase ()); + AddTestCase (new RrcConnectionReestablishmentRequestTestCase ()); + AddTestCase (new RrcConnectionReestablishmentTestCase ()); + AddTestCase (new RrcConnectionReestablishmentCompleteTestCase ()); + AddTestCase (new RrcConnectionRejectTestCase ()); + AddTestCase (new MeasurementReportTestCase ()); } Asn1EncodingSuite asn1EncodingSuite; From 0e4a2fc5d452efb04aa07036d8ecb0c77e6fe264 Mon Sep 17 00:00:00 2001 From: lluis Date: Wed, 20 Feb 2013 10:33:53 +0100 Subject: [PATCH 07/10] Fix valgrind errors --- src/lte/test/test-asn1-encoding.cc | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/lte/test/test-asn1-encoding.cc b/src/lte/test/test-asn1-encoding.cc index 8997f396f..580e25dee 100644 --- a/src/lte/test/test-asn1-encoding.cc +++ b/src/lte/test/test-asn1-encoding.cc @@ -615,6 +615,11 @@ HandoverPreparationInfoTestCase::DoRun (void) msg.asConfig.sourceSystemInformationBlockType2.radioResourceConfigCommon.rachConfigCommon.raSupervisionInfo.preambleTransMax = 3; msg.asConfig.sourceSystemInformationBlockType2.radioResourceConfigCommon.rachConfigCommon.raSupervisionInfo.raResponseWindowSize = 6; + msg.asConfig.sourceMeasConfig.haveQuantityConfig = false; + msg.asConfig.sourceMeasConfig.haveMeasGapConfig = false; + msg.asConfig.sourceMeasConfig.haveSmeasure = false; + msg.asConfig.sourceMeasConfig.haveSpeedStatePars = false; + HandoverPreparationInfoHeader source; source.SetMessage (msg); From 9b1edab9abcd9e2adb69defdee49b799d5b366e4 Mon Sep 17 00:00:00 2001 From: Lluis Parcerisa Date: Wed, 20 Feb 2013 12:05:44 +0100 Subject: [PATCH 08/10] merge --- src/lte/model/lte-rrc-header.cc | 1982 ++++++++++++++++++++++++++-- src/lte/model/lte-rrc-header.h | 8 +- src/lte/model/lte-rrc-sap.h | 5 +- src/lte/test/test-asn1-encoding.cc | 142 +- 4 files changed, 1984 insertions(+), 153 deletions(-) diff --git a/src/lte/model/lte-rrc-header.cc b/src/lte/model/lte-rrc-header.cc index 0621a3d69..31b68ca42 100644 --- a/src/lte/model/lte-rrc-header.cc +++ b/src/lte/model/lte-rrc-header.cc @@ -857,6 +857,932 @@ RrcAsn1Header::SerializeRachConfigCommon (LteRrcSap::RachConfigCommon rachConfig SerializeInteger (1,1,8); // maxHARQ-Msg3Tx } +void +RrcAsn1Header::SerializeQoffsetRange (int8_t qOffsetRange) const +{ + switch (qOffsetRange) + { + case -24: + SerializeEnum (32,0); + break; + case -22: + SerializeEnum (32,1); + break; + case -20: + SerializeEnum (32,2); + break; + case -18: + SerializeEnum (32,3); + break; + case -16: + SerializeEnum (32,4); + break; + case -14: + SerializeEnum (32,5); + break; + case -12: + SerializeEnum (32,6); + break; + case -10: + SerializeEnum (32,7); + break; + case -8: + SerializeEnum (32,8); + break; + case -6: + SerializeEnum (32,9); + break; + case -5: + SerializeEnum (32,10); + break; + case -4: + SerializeEnum (32,11); + break; + case -3: + SerializeEnum (32,12); + break; + case -2: + SerializeEnum (32,13); + break; + case -1: + SerializeEnum (32,14); + break; + case 0: + SerializeEnum (32,15); + break; + case 1: + SerializeEnum (32,16); + break; + case 2: + SerializeEnum (32,17); + break; + case 3: + SerializeEnum (32,18); + break; + case 4: + SerializeEnum (32,19); + break; + case 5: + SerializeEnum (32,20); + break; + case 6: + SerializeEnum (32,21); + break; + case 8: + SerializeEnum (32,22); + break; + case 10: + SerializeEnum (32,23); + break; + case 12: + SerializeEnum (32,24); + break; + case 14: + SerializeEnum (32,25); + break; + case 16: + SerializeEnum (32,26); + break; + case 18: + SerializeEnum (32,27); + break; + case 20: + SerializeEnum (32,28); + break; + case 22: + SerializeEnum (32,29); + break; + case 24: + SerializeEnum (32,30); + break; + default: + SerializeEnum (32,15); + } +} + +void +RrcAsn1Header::SerializeThresholdEutra (LteRrcSap::ThresholdEutra thresholdEutra) const +{ + switch (thresholdEutra.choice) + { + case LteRrcSap::ThresholdEutra::thresholdRsrp: + SerializeInteger (thresholdEutra.range, 0, 97); + break; + case LteRrcSap::ThresholdEutra::thresholdRsrq: + default: + SerializeInteger (thresholdEutra.range, 0, 34); + } +} + +void +RrcAsn1Header::SerializeMeasConfig (LteRrcSap::MeasConfig measConfig) const +{ + // Serialize MeasConfig sequence + // 11 optional fields, extension marker present + std::bitset<11> measConfigOptional; + measConfigOptional.set (10, !measConfig.measObjectToRemoveList.empty () ); + measConfigOptional.set (9, !measConfig.measObjectToAddModList.empty () ); + measConfigOptional.set (8, !measConfig.reportConfigToRemoveList.empty () ); + measConfigOptional.set (7, !measConfig.reportConfigToAddModList.empty () ); + measConfigOptional.set (6, !measConfig.measIdToRemoveList.empty () ); + measConfigOptional.set (5, !measConfig.measIdToAddModList.empty () ); + measConfigOptional.set (4, measConfig.haveQuantityConfig ); + measConfigOptional.set (3, measConfig.haveMeasGapConfig ); + measConfigOptional.set (2, measConfig.haveSmeasure ); + measConfigOptional.set (1, false ); // preRegistrationInfoHRPD + measConfigOptional.set (0, measConfig.haveSpeedStatePars ); + SerializeSequence (measConfigOptional,true); + + if (!measConfig.measObjectToRemoveList.empty ()) + { + SerializeSequenceOf (measConfig.measObjectToRemoveList.size (),MAX_OBJECT_ID,1); + for (std::list::iterator it = measConfig.measObjectToRemoveList.begin (); it != measConfig.measObjectToRemoveList.end (); it++) + { + SerializeInteger (*it, 1, MAX_OBJECT_ID); + } + } + + if (!measConfig.measObjectToAddModList.empty ()) + { + SerializeSequenceOf (measConfig.measObjectToAddModList.size (),MAX_OBJECT_ID,1); + for (std::list::iterator it = measConfig.measObjectToAddModList.begin (); it != measConfig.measObjectToAddModList.end (); it++) + { + SerializeSequence (std::bitset<0> (), false); + SerializeInteger (it->measObjectId, 1, MAX_OBJECT_ID); + SerializeChoice (4, 0, true); // Select MeasObjectEUTRA + + // Serialize measObjectEutra + std::bitset<5> measObjOpts; + measObjOpts.set (4,!it->measObjectEutra.cellsToRemoveList.empty () ); + measObjOpts.set (3,!it->measObjectEutra.cellsToAddModList.empty () ); + measObjOpts.set (2,!it->measObjectEutra.blackCellsToRemoveList.empty () ); + measObjOpts.set (1,!it->measObjectEutra.blackCellsToAddModList.empty () ); + measObjOpts.set (0,it->measObjectEutra.haveCellForWhichToReportCGI); + SerializeSequence (measObjOpts, true); + + // Serialize carrierFreq + SerializeInteger (it->measObjectEutra.carrierFreq, 0, MAX_EARFCN); + + // Serialize allowedMeasBandwidth + switch (it->measObjectEutra.allowedMeasBandwidth) + { + case 6: + SerializeEnum (6,0); + break; + case 15: + SerializeEnum (6,1); + break; + case 25: + SerializeEnum (6,2); + break; + case 50: + SerializeEnum (6,3); + break; + case 75: + SerializeEnum (6,4); + break; + case 100: + SerializeEnum (6,5); + break; + default: + SerializeEnum (6,0); + } + + SerializeBoolean (it->measObjectEutra.presenceAntennaPort1); + SerializeBitstring (std::bitset<2> (it->measObjectEutra.neighCellConfig)); + SerializeQoffsetRange (it->measObjectEutra.offsetFreq); + + if (!it->measObjectEutra.cellsToRemoveList.empty ()) + { + SerializeSequenceOf (it->measObjectEutra.cellsToRemoveList.size (),MAX_CELL_MEAS,1); + for (std::list::iterator it2 = it->measObjectEutra.cellsToRemoveList.begin (); it2 != it->measObjectEutra.cellsToRemoveList.end (); it2++) + { + SerializeInteger (*it2, 1, MAX_CELL_MEAS); + } + } + + if (!it->measObjectEutra.cellsToAddModList.empty ()) + { + SerializeSequenceOf (it->measObjectEutra.cellsToAddModList.size (), MAX_CELL_MEAS, 1); + for (std::list::iterator it2 = it->measObjectEutra.cellsToAddModList.begin (); it2 != it->measObjectEutra.cellsToAddModList.end (); it2++) + { + SerializeSequence (std::bitset<0> (), false); + + // Serialize cellIndex + SerializeInteger (it2->cellIndex, 1, MAX_CELL_MEAS); + + // Serialize PhysCellIdRange + // range optional and not present + SerializeSequence (std::bitset<1> (0),false); + SerializeInteger (it2->physCellId,0,503); + + // Serialize cellIndividualOffset + SerializeQoffsetRange (it2->cellIndividualOffset); + } + } + + if (!it->measObjectEutra.blackCellsToRemoveList.empty () ) + { + SerializeSequenceOf (it->measObjectEutra.blackCellsToRemoveList.size (),MAX_CELL_MEAS,1); + for (std::list::iterator it2 = it->measObjectEutra.blackCellsToRemoveList.begin (); it2 != it->measObjectEutra.blackCellsToRemoveList.end (); it2++) + { + SerializeInteger (*it2, 1, MAX_CELL_MEAS); + } + } + + if (!it->measObjectEutra.blackCellsToAddModList.empty () ) + { + SerializeSequenceOf (it->measObjectEutra.blackCellsToAddModList.size (), MAX_CELL_MEAS, 1); + for (std::list::iterator it2 = it->measObjectEutra.blackCellsToAddModList.begin (); it2 != it->measObjectEutra.blackCellsToAddModList.end (); it2++) + { + SerializeSequence (std::bitset<0> (),false); + SerializeInteger (it2->cellIndex, 1, MAX_CELL_MEAS); + + // Serialize PhysCellIdRange + // range optional + std::bitset<1> rangePresent = std::bitset<1> (it2->physCellIdRange.haveRange); + SerializeSequence (rangePresent,false); + SerializeInteger (it2->physCellIdRange.start,0,503); + if (it2->physCellIdRange.haveRange) + { + switch (it2->physCellIdRange.range) + { + case 4: + SerializeEnum (16, 0); + break; + case 8: + SerializeEnum (16, 1); + break; + case 12: + SerializeEnum (16, 2); + break; + case 16: + SerializeEnum (16, 3); + break; + case 24: + SerializeEnum (16, 4); + break; + case 32: + SerializeEnum (16, 5); + break; + case 48: + SerializeEnum (16, 6); + break; + case 64: + SerializeEnum (16, 7); + break; + case 84: + SerializeEnum (16, 8); + break; + case 96: + SerializeEnum (16, 9); + break; + case 128: + SerializeEnum (16, 10); + break; + case 168: + SerializeEnum (16, 11); + break; + case 252: + SerializeEnum (16, 12); + break; + case 504: + SerializeEnum (16, 13); + break; + default: + SerializeEnum (16, 0); + } + } + } + + } + + if (it->measObjectEutra.haveCellForWhichToReportCGI) + { + SerializeInteger (it->measObjectEutra.cellForWhichToReportCGI,0,503); + } + } + } + + + if (!measConfig.reportConfigToRemoveList.empty () ) + { + SerializeSequenceOf (measConfig.reportConfigToRemoveList.size (),MAX_REPORT_CONFIG_ID,1); + for (std::list::iterator it = measConfig.reportConfigToRemoveList.begin (); it != measConfig.reportConfigToRemoveList.end (); it++) + { + SerializeInteger (*it, 1,MAX_REPORT_CONFIG_ID); + } + } + + if (!measConfig.reportConfigToAddModList.empty () ) + { + SerializeSequenceOf (measConfig.reportConfigToAddModList.size (),MAX_REPORT_CONFIG_ID,1); + for (std::list::iterator it = measConfig.reportConfigToAddModList.begin (); it != measConfig.reportConfigToAddModList.end (); it++) + { + SerializeSequence (std::bitset<0> (), false); + SerializeInteger (it->reportConfigId,1,MAX_REPORT_CONFIG_ID); + SerializeChoice (2,0,false); // reportConfigEUTRA + + // Serialize ReportConfigEUTRA + SerializeSequence (std::bitset<0> (), true); + switch (it->reportConfigEutra.triggerType) + { + case LteRrcSap::ReportConfigEutra::periodical: + SerializeChoice (2, 1, false); + SerializeSequence (std::bitset<0> (),false); + switch (it->reportConfigEutra.purpose) + { + case LteRrcSap::ReportConfigEutra::reportCgi: + SerializeEnum (2,1); + break; + case LteRrcSap::ReportConfigEutra::reportStrongestCells: + default: + SerializeEnum (2,0); + } + break; + case LteRrcSap::ReportConfigEutra::event: + default: + SerializeChoice (2, 0, false); + SerializeSequence (std::bitset<0> (),true); + switch (it->reportConfigEutra.eventId) + { + case LteRrcSap::ReportConfigEutra::eventA1: + SerializeChoice (5, 0, true); + SerializeSequence (std::bitset<0> (),false); + SerializeThresholdEutra (it->reportConfigEutra.threshold1); + break; + case LteRrcSap::ReportConfigEutra::eventA2: + SerializeChoice (5, 1, true); + SerializeSequence (std::bitset<0> (),false); + SerializeThresholdEutra (it->reportConfigEutra.threshold1); + break; + case LteRrcSap::ReportConfigEutra::eventA3: + SerializeChoice (5, 2, true); + SerializeSequence (std::bitset<0> (),false); + SerializeInteger (it->reportConfigEutra.a3Offset,-30,30); + SerializeBoolean (it->reportConfigEutra.reportOnLeave); + break; + case LteRrcSap::ReportConfigEutra::eventA4: + SerializeChoice (5, 3, true); + SerializeSequence (std::bitset<0> (),false); + SerializeThresholdEutra (it->reportConfigEutra.threshold1); + break; + case LteRrcSap::ReportConfigEutra::eventA5: + default: + SerializeChoice (5, 4, true); + SerializeSequence (std::bitset<0> (),false); + SerializeThresholdEutra (it->reportConfigEutra.threshold1); + SerializeThresholdEutra (it->reportConfigEutra.threshold2); + } + + SerializeInteger (it->reportConfigEutra.hysteresis, 0, 30); + + switch (it->reportConfigEutra.timeToTrigger) + { + case 0: + SerializeEnum (16, 0); + break; + case 40: + SerializeEnum (16, 1); + break; + case 64: + SerializeEnum (16, 2); + break; + case 80: + SerializeEnum (16, 3); + break; + case 100: + SerializeEnum (16, 4); + break; + case 128: + SerializeEnum (16, 5); + break; + case 160: + SerializeEnum (16, 6); + break; + case 256: + SerializeEnum (16, 7); + break; + case 320: + SerializeEnum (16, 8); + break; + case 480: + SerializeEnum (16, 9); + break; + case 512: + SerializeEnum (16, 10); + break; + case 640: + SerializeEnum (16, 11); + break; + case 1024: + SerializeEnum (16, 12); + break; + case 1280: + SerializeEnum (16, 13); + break; + case 2560: + SerializeEnum (16, 14); + break; + case 5120: + default: + SerializeEnum (16, 15); + } + } // end trigger type + + // Serialize triggerQuantity + if (it->reportConfigEutra.triggerQuantity == LteRrcSap::ReportConfigEutra::rsrp) + { + SerializeEnum (2, 0); + } + else + { + SerializeEnum (2, 1); + } + + // Serialize reportQuantity + if (it->reportConfigEutra.reportQuantity == LteRrcSap::ReportConfigEutra::sameAsTriggerQuantity) + { + SerializeEnum (2, 0); + } + else + { + SerializeEnum (2, 1); + } + + // Serialize maxReportCells + SerializeInteger (it->reportConfigEutra.maxReportCells, 1, MAX_CELL_REPORT); + + // Serialize reportInterval + switch (it->reportConfigEutra.reportInterval) + { + case LteRrcSap::ReportConfigEutra::ms120: + SerializeEnum (16, 0); + break; + case LteRrcSap::ReportConfigEutra::ms240: + SerializeEnum (16, 1); + break; + case LteRrcSap::ReportConfigEutra::ms480: + SerializeEnum (16, 2); + break; + case LteRrcSap::ReportConfigEutra::ms640: + SerializeEnum (16, 3); + break; + case LteRrcSap::ReportConfigEutra::ms1024: + SerializeEnum (16, 4); + break; + case LteRrcSap::ReportConfigEutra::ms2048: + SerializeEnum (16, 5); + break; + case LteRrcSap::ReportConfigEutra::ms5120: + SerializeEnum (16, 6); + break; + case LteRrcSap::ReportConfigEutra::ms10240: + SerializeEnum (16, 7); + break; + case LteRrcSap::ReportConfigEutra::min1: + SerializeEnum (16, 8); + break; + case LteRrcSap::ReportConfigEutra::min6: + SerializeEnum (16, 9); + break; + case LteRrcSap::ReportConfigEutra::min12: + SerializeEnum (16, 10); + break; + case LteRrcSap::ReportConfigEutra::min30: + SerializeEnum (16, 11); + break; + case LteRrcSap::ReportConfigEutra::min60: + SerializeEnum (16, 12); + break; + case LteRrcSap::ReportConfigEutra::spare3: + SerializeEnum (16, 13); + break; + case LteRrcSap::ReportConfigEutra::spare2: + SerializeEnum (16, 14); + break; + case LteRrcSap::ReportConfigEutra::spare1: + default: + SerializeEnum (16, 15); + } + + // Serialize reportAmount + switch (it->reportConfigEutra.reportAmount) + { + case 1: + SerializeEnum (8, 0); + break; + case 2: + SerializeEnum (8, 1); + break; + case 4: + SerializeEnum (8, 2); + break; + case 8: + SerializeEnum (8, 3); + break; + case 16: + SerializeEnum (8, 4); + break; + case 32: + SerializeEnum (8, 5); + break; + case 64: + SerializeEnum (8, 6); + break; + default: + SerializeEnum (8, 7); + } + } + } + + if (!measConfig.measIdToRemoveList.empty () ) + { + SerializeSequenceOf (measConfig.measIdToRemoveList.size (), MAX_MEAS_ID, 1); + for (std::list::iterator it = measConfig.measIdToRemoveList.begin (); it != measConfig.measIdToRemoveList.end (); it++) + { + SerializeInteger (*it, 1, MAX_MEAS_ID); + } + } + + if (!measConfig.measIdToAddModList.empty () ) + { + SerializeSequenceOf ( measConfig.measIdToAddModList.size (), MAX_MEAS_ID, 1); + for (std::list::iterator it = measConfig.measIdToAddModList.begin (); it != measConfig.measIdToAddModList.end (); it++) + { + SerializeInteger (it->measId, 1, MAX_MEAS_ID); + SerializeInteger (it->measObjectId, 1, MAX_OBJECT_ID); + SerializeInteger (it->reportConfigId, 1, MAX_REPORT_CONFIG_ID); + } + } + + if (measConfig.haveQuantityConfig ) + { + // QuantityConfig sequence + // 4 optional fields, only first (EUTRA) present. Extension marker yes. + std::bitset<4> quantityConfigOpts (0); + quantityConfigOpts.set (3,1); + SerializeSequence (quantityConfigOpts, true); + SerializeSequence (std::bitset<0> (), false); + + switch (measConfig.quantityConfig.filterCoefficientRSRP) + { + case 0: + SerializeEnum (16, 0); + break; + case 1: + SerializeEnum (16, 1); + break; + case 2: + SerializeEnum (16, 2); + break; + case 3: + SerializeEnum (16, 3); + break; + case 4: + SerializeEnum (16, 4); + break; + case 5: + SerializeEnum (16, 5); + break; + case 6: + SerializeEnum (16, 6); + break; + case 7: + SerializeEnum (16, 7); + break; + case 8: + SerializeEnum (16, 8); + break; + case 9: + SerializeEnum (16, 9); + break; + case 11: + SerializeEnum (16, 10); + break; + case 13: + SerializeEnum (16, 11); + break; + case 15: + SerializeEnum (16, 12); + break; + case 17: + SerializeEnum (16, 13); + break; + case 19: + SerializeEnum (16, 14); + break; + default: + SerializeEnum (16, 4); + } + + switch (measConfig.quantityConfig.filterCoefficientRSRQ) + { + case 0: + SerializeEnum (16, 0); + break; + case 1: + SerializeEnum (16, 1); + break; + case 2: + SerializeEnum (16, 2); + break; + case 3: + SerializeEnum (16, 3); + break; + case 4: + SerializeEnum (16, 4); + break; + case 5: + SerializeEnum (16, 5); + break; + case 6: + SerializeEnum (16, 6); + break; + case 7: + SerializeEnum (16, 7); + break; + case 8: + SerializeEnum (16, 8); + break; + case 9: + SerializeEnum (16, 9); + break; + case 11: + SerializeEnum (16, 10); + break; + case 13: + SerializeEnum (16, 11); + break; + case 15: + SerializeEnum (16, 12); + break; + case 17: + SerializeEnum (16, 13); + break; + case 19: + SerializeEnum (16, 14); + break; + default: + SerializeEnum (16, 4); + } + } + + if (measConfig.haveMeasGapConfig ) + { + switch (measConfig.measGapConfig.type) + { + case LteRrcSap::MeasGapConfig::RESET: + SerializeChoice (2, 0, false); + SerializeNull (); + break; + case LteRrcSap::MeasGapConfig::SETUP: + default: + SerializeChoice (2, 1, false); + SerializeSequence (std::bitset<0> (),false); + switch (measConfig.measGapConfig.gapOffsetChoice) + { + case LteRrcSap::MeasGapConfig::gp0: + SerializeChoice (2, 0, true); + SerializeInteger (measConfig.measGapConfig.gapOffsetValue, 0, 39); + break; + case LteRrcSap::MeasGapConfig::gp1: + default: + SerializeChoice (2, 1, true); + SerializeInteger (measConfig.measGapConfig.gapOffsetValue, 0, 79); + } + } + } + + if (measConfig.haveSmeasure ) + { + SerializeInteger (measConfig.sMeasure, 0, 97); + } + + // ...Here preRegistrationInfoHRPD would be serialized + + if (measConfig.haveSpeedStatePars ) + { + switch (measConfig.speedStatePars.type) + { + case LteRrcSap::SpeedStatePars::RESET: + SerializeChoice (2, 0, false); + SerializeNull (); + break; + case LteRrcSap::SpeedStatePars::SETUP: + default: + SerializeChoice (2, 1, false); + SerializeSequence (std::bitset<0> (), false); + switch (measConfig.speedStatePars.mobilityStateParameters.tEvaluation) + { + case 30: + SerializeEnum (8, 0); + break; + case 60: + SerializeEnum (8, 1); + break; + case 120: + SerializeEnum (8, 2); + break; + case 180: + SerializeEnum (8, 3); + break; + case 240: + SerializeEnum (8, 4); + break; + default: + SerializeEnum (8, 5); + break; + } + + switch (measConfig.speedStatePars.mobilityStateParameters.tHystNormal) + { + case 30: + SerializeEnum (8, 0); + break; + case 60: + SerializeEnum (8, 1); + break; + case 120: + SerializeEnum (8, 2); + break; + case 180: + SerializeEnum (8, 3); + break; + case 240: + SerializeEnum (8, 4); + break; + default: + SerializeEnum (8, 5); + break; + } + + SerializeInteger (measConfig.speedStatePars.mobilityStateParameters.nCellChangeMedium, 1, 16); + SerializeInteger (measConfig.speedStatePars.mobilityStateParameters.nCellChangeHigh, 1, 16); + + SerializeSequence (std::bitset<0> (), false); + switch (measConfig.speedStatePars.timeToTriggerSf.sfMedium) + { + case 25: + SerializeEnum (4, 0); + break; + case 50: + SerializeEnum (4, 1); + break; + case 75: + SerializeEnum (4, 2); + break; + case 100: + default: + SerializeEnum (4, 3); + } + + switch (measConfig.speedStatePars.timeToTriggerSf.sfHigh) + { + case 25: + SerializeEnum (4, 0); + break; + case 50: + SerializeEnum (4, 1); + break; + case 75: + SerializeEnum (4, 2); + break; + case 100: + default: + SerializeEnum (4, 3); + } + } + } +} + +Buffer::Iterator +RrcAsn1Header::DeserializeThresholdEutra (LteRrcSap::ThresholdEutra * thresholdEutra, Buffer::Iterator bIterator) +{ + int thresholdEutraChoice, range; + bIterator = DeserializeChoice (2, false, &thresholdEutraChoice, bIterator); + + switch (thresholdEutraChoice) + { + case 0: + thresholdEutra->choice = LteRrcSap::ThresholdEutra::thresholdRsrp; + bIterator = DeserializeInteger (&range, 0, 97, bIterator); + thresholdEutra->range = range; + break; + case 1: + default: + thresholdEutra->choice = LteRrcSap::ThresholdEutra::thresholdRsrq; + bIterator = DeserializeInteger (&range, 0, 34, bIterator); + thresholdEutra->range = range; + } + + return bIterator; +} + +Buffer::Iterator +RrcAsn1Header::DeserializeQoffsetRange (int8_t * qOffsetRange, Buffer::Iterator bIterator) +{ + int n; + bIterator = DeserializeEnum (31, &n, bIterator); + switch (n) + { + case 0: + *qOffsetRange = -24; + break; + case 1: + *qOffsetRange = -22; + break; + case 2: + *qOffsetRange = -20; + break; + case 3: + *qOffsetRange = -18; + break; + case 4: + *qOffsetRange = -16; + break; + case 5: + *qOffsetRange = -14; + break; + case 6: + *qOffsetRange = -12; + break; + case 7: + *qOffsetRange = -10; + break; + case 8: + *qOffsetRange = -8; + break; + case 9: + *qOffsetRange = -6; + break; + case 10: + *qOffsetRange = -5; + break; + case 11: + *qOffsetRange = -4; + break; + case 12: + *qOffsetRange = -3; + break; + case 13: + *qOffsetRange = -2; + break; + case 14: + *qOffsetRange = -1; + break; + case 15: + *qOffsetRange = 0; + break; + case 16: + *qOffsetRange = 1; + break; + case 17: + *qOffsetRange = 2; + break; + case 18: + *qOffsetRange = 3; + break; + case 19: + *qOffsetRange = 4; + break; + case 20: + *qOffsetRange = 5; + break; + case 21: + *qOffsetRange = 6; + break; + case 22: + *qOffsetRange = 8; + break; + case 23: + *qOffsetRange = 10; + break; + case 24: + *qOffsetRange = 12; + break; + case 25: + *qOffsetRange = 14; + break; + case 26: + *qOffsetRange = 16; + break; + case 27: + *qOffsetRange = 18; + break; + case 28: + *qOffsetRange = 20; + break; + case 29: + *qOffsetRange = 22; + break; + case 30: + default: + *qOffsetRange = 24; + } + return bIterator; +} + Buffer::Iterator RrcAsn1Header::DeserializeRadioResourceConfigDedicated (LteRrcSap::RadioResourceConfigDedicated *radioResourceConfigDedicated, Buffer::Iterator bIterator) { @@ -1153,11 +2079,11 @@ RrcAsn1Header::DeserializeLogicalChannelConfig (LteRrcSap::LogicalChannelConfig logicalChannelConfig->bucketSizeDurationMs = bucketSizeDurationMs; if (bitset1[0]) - { - // Deserialize logicalChannelGroup - bIterator = DeserializeInteger (&n,0,3,bIterator); - logicalChannelConfig->logicalChannelGroup = n; - } + { + // Deserialize logicalChannelGroup + bIterator = DeserializeInteger (&n,0,3,bIterator); + logicalChannelConfig->logicalChannelGroup = n; + } } return bIterator; } @@ -2092,6 +3018,839 @@ RrcAsn1Header::DeserializePlmnIdentity (uint32_t *plmnId, Buffer::Iterator bIter return bIterator; } +Buffer::Iterator +RrcAsn1Header::DeserializeMeasConfig (LteRrcSap::MeasConfig * measConfig, Buffer::Iterator bIterator) +{ + std::bitset<0> bitset0; + std::bitset<2> bitset2; + std::bitset<11> bitset11; + int n; + + // measConfig + bIterator = DeserializeSequence (&bitset11,true,bIterator); + + if (bitset11[10]) + { + // measObjectToRemoveList + int measObjectToRemoveListElems; + bIterator = DeserializeSequenceOf (&measObjectToRemoveListElems, MAX_OBJECT_ID, 1, bIterator); + + for (int i = 0; i < measObjectToRemoveListElems; i++) + { + bIterator = DeserializeInteger (&n, 1, MAX_OBJECT_ID, bIterator); + measConfig->measObjectToRemoveList.push_back (n); + } + } + + if (bitset11[9]) + { + // measObjectToAddModList + int measObjectToAddModListElems; + bIterator = DeserializeSequenceOf (&measObjectToAddModListElems, MAX_OBJECT_ID, 1, bIterator); + + for (int i = 0; i < measObjectToAddModListElems; i++) + { + LteRrcSap::MeasObjectToAddMod * elem = new LteRrcSap::MeasObjectToAddMod (); + + bIterator = DeserializeSequence (&bitset0, false, bIterator); + + bIterator = DeserializeInteger (&n, 1, MAX_OBJECT_ID, bIterator); + elem->measObjectId = n; + + int measObjectChoice; + bIterator = DeserializeChoice (4, true, &measObjectChoice, bIterator); + + switch (measObjectChoice) + { + case 1: + // Deserialize measObjectUTRA + // ... + break; + + case 2: + // Deserialize measObjectGERAN + // ... + break; + + case 3: + // Deserialize measObjectCDMA2000 + // ... + break; + + case 0: + default: + // Deserialize measObjectEUTRA + std::bitset<5> measObjectEutraOpts; + bIterator = DeserializeSequence (&measObjectEutraOpts, true, bIterator); + + // carrierFreq + bIterator = DeserializeInteger (&n, 0, MAX_EARFCN, bIterator); + elem->measObjectEutra.carrierFreq = n; + + // allowedMeasBandwidth + bIterator = DeserializeEnum (6, &n, bIterator); + switch (n) + { + case 0: + elem->measObjectEutra.allowedMeasBandwidth = 6; + break; + case 1: + elem->measObjectEutra.allowedMeasBandwidth = 15; + break; + case 2: + elem->measObjectEutra.allowedMeasBandwidth = 25; + break; + case 3: + elem->measObjectEutra.allowedMeasBandwidth = 50; + break; + case 4: + elem->measObjectEutra.allowedMeasBandwidth = 75; + break; + case 5: + default: + elem->measObjectEutra.allowedMeasBandwidth = 100; + break; + } + + // presenceAntennaPort1 + bIterator = DeserializeBoolean (&elem->measObjectEutra.presenceAntennaPort1, bIterator); + + // neighCellConfig + bIterator = DeserializeBitstring (&bitset2, bIterator); + elem->measObjectEutra.neighCellConfig = bitset2.to_ulong (); + + // offsetFreq + DeserializeQoffsetRange (&elem->measObjectEutra.offsetFreq, bIterator); + + if (measObjectEutraOpts[4]) + { + // cellsToRemoveList + int numElems; + bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS, 1, bIterator); + + for (int i = 0; i < numElems; i++) + { + bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIterator); + elem->measObjectEutra.cellsToRemoveList.push_back (n); + } + } + + if (measObjectEutraOpts[3]) + { + // cellsToAddModList + int numElems; + bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS, 1, bIterator); + + for (int i = 0; i < numElems; i++) + { + LteRrcSap::CellsToAddMod * cellsToAddMod = new LteRrcSap::CellsToAddMod (); + + bIterator = DeserializeSequence (&bitset0, false, bIterator); + + // cellIndex + bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIterator); + cellsToAddMod->cellIndex = n; + + // PhysCellId + bIterator = DeserializeInteger (&n, 0, 503, bIterator); + cellsToAddMod->physCellId = n; + + // cellIndividualOffset + bIterator = DeserializeQoffsetRange ( &cellsToAddMod->cellIndividualOffset, bIterator); + + elem->measObjectEutra.cellsToAddModList.push_back (*cellsToAddMod); + } + } + + if (measObjectEutraOpts[2]) + { + // blackCellsToRemoveList + int numElems; + bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS, 1, bIterator); + + for (int i = 0; i < numElems; i++) + { + bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIterator); + elem->measObjectEutra.blackCellsToRemoveList.push_back (n); + } + } + + + if (measObjectEutraOpts[1]) + { + // blackCellsToAddModList + int numElems; + bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS, 1, bIterator); + + for (int i = 0; i < numElems; i++) + { + LteRrcSap::BlackCellsToAddMod * blackCellsToAddMod = new LteRrcSap::BlackCellsToAddMod (); + bIterator = DeserializeSequence (&bitset0, false, bIterator); + + bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIterator); + blackCellsToAddMod->cellIndex = n; + + // PhysCellIdRange + std::bitset<1> isRangePresent; + bIterator = DeserializeSequence (&isRangePresent, false, bIterator); + + // start + bIterator = DeserializeInteger (&n, 0, 503, bIterator); + blackCellsToAddMod->physCellIdRange.start = n; + + blackCellsToAddMod->physCellIdRange.haveRange = isRangePresent[0]; + if (blackCellsToAddMod->physCellIdRange.haveRange) + { + // range + bIterator = DeserializeEnum (16, &n, bIterator); + switch (n) + { + case 0: + blackCellsToAddMod->physCellIdRange.range = 4; + break; + case 1: + blackCellsToAddMod->physCellIdRange.range = 8; + break; + case 2: + blackCellsToAddMod->physCellIdRange.range = 12; + break; + case 3: + blackCellsToAddMod->physCellIdRange.range = 16; + break; + case 4: + blackCellsToAddMod->physCellIdRange.range = 24; + break; + case 5: + blackCellsToAddMod->physCellIdRange.range = 32; + break; + case 6: + blackCellsToAddMod->physCellIdRange.range = 48; + break; + case 7: + blackCellsToAddMod->physCellIdRange.range = 64; + break; + case 8: + blackCellsToAddMod->physCellIdRange.range = 84; + break; + case 9: + blackCellsToAddMod->physCellIdRange.range = 96; + break; + case 10: + blackCellsToAddMod->physCellIdRange.range = 128; + break; + case 11: + blackCellsToAddMod->physCellIdRange.range = 168; + break; + case 12: + blackCellsToAddMod->physCellIdRange.range = 252; + break; + case 13: + blackCellsToAddMod->physCellIdRange.range = 504; + break; + default: + blackCellsToAddMod->physCellIdRange.range = 0; + } + } + + elem->measObjectEutra.blackCellsToAddModList.push_back (*blackCellsToAddMod); + } + } + + elem->measObjectEutra.haveCellForWhichToReportCGI = measObjectEutraOpts[0]; + if (measObjectEutraOpts[0]) + { + // cellForWhichToReportCGI + bIterator = DeserializeInteger (&n, 0, 503, bIterator); + elem->measObjectEutra.cellForWhichToReportCGI = n; + } + } + measConfig->measObjectToAddModList.push_back (*elem); + } + } + + if (bitset11[8]) + { + // reportConfigToRemoveList + int reportConfigToRemoveListElems; + bIterator = DeserializeSequenceOf (&reportConfigToRemoveListElems, MAX_REPORT_CONFIG_ID, 1, bIterator); + + for (int i = 0; i < reportConfigToRemoveListElems; i++) + { + bIterator = DeserializeInteger (&n, 1, MAX_REPORT_CONFIG_ID, bIterator); + measConfig->reportConfigToRemoveList.push_back (n); + } + } + + if (bitset11[7]) + { + // reportConfigToAddModList + int reportConfigToAddModListElems; + bIterator = DeserializeSequenceOf (&reportConfigToAddModListElems, MAX_REPORT_CONFIG_ID, 1, bIterator); + + for (int i = 0; i < reportConfigToAddModListElems; i++) + { + LteRrcSap::ReportConfigToAddMod * elem = new LteRrcSap::ReportConfigToAddMod (); + + bIterator = DeserializeSequence (&bitset0, false, bIterator); + bIterator = DeserializeInteger (&n, 1, MAX_REPORT_CONFIG_ID, bIterator); + elem->reportConfigId = n; + + // Deserialize reportConfig + int reportConfigChoice; + bIterator = DeserializeChoice (2, false, &reportConfigChoice, bIterator); + + if (reportConfigChoice == 0) + { + // reportConfigEUTRA + bIterator = DeserializeSequence (&bitset0, true, bIterator); + + // triggerType + int triggerTypeChoice; + bIterator = DeserializeChoice (2, false, &triggerTypeChoice, bIterator); + + if (triggerTypeChoice == 0) + { + // event + elem->reportConfigEutra.triggerType = LteRrcSap::ReportConfigEutra::event; + bIterator = DeserializeSequence (&bitset0, false, bIterator); + + // eventId + int eventIdChoice; + bIterator = DeserializeChoice (5, true, &eventIdChoice, bIterator); + + switch (eventIdChoice) + { + case 0: + elem->reportConfigEutra.eventId = LteRrcSap::ReportConfigEutra::eventA1; + bIterator = DeserializeSequence (&bitset0, false, bIterator); + bIterator = DeserializeThresholdEutra (&elem->reportConfigEutra.threshold1, bIterator); + break; + + case 1: + elem->reportConfigEutra.eventId = LteRrcSap::ReportConfigEutra::eventA2; + bIterator = DeserializeSequence (&bitset0, false, bIterator); + bIterator = DeserializeThresholdEutra (&elem->reportConfigEutra.threshold1, bIterator); + break; + + case 2: + elem->reportConfigEutra.eventId = LteRrcSap::ReportConfigEutra::eventA3; + bIterator = DeserializeSequence (&bitset0, false, bIterator); + bIterator = DeserializeInteger (&n, -30, 30, bIterator); + elem->reportConfigEutra.a3Offset = n; + bIterator = DeserializeBoolean (&elem->reportConfigEutra.reportOnLeave, bIterator); + break; + + case 3: + elem->reportConfigEutra.eventId = LteRrcSap::ReportConfigEutra::eventA4; + bIterator = DeserializeSequence (&bitset0, false, bIterator); + bIterator = DeserializeThresholdEutra (&elem->reportConfigEutra.threshold1, bIterator); + break; + + default: + elem->reportConfigEutra.eventId = LteRrcSap::ReportConfigEutra::eventA5; + bIterator = DeserializeSequence (&bitset0, false, bIterator); + bIterator = DeserializeThresholdEutra (&elem->reportConfigEutra.threshold1, bIterator); + bIterator = DeserializeThresholdEutra (&elem->reportConfigEutra.threshold2, bIterator); + break; + } + + bIterator = DeserializeInteger (&n, 0, 30, bIterator); + elem->reportConfigEutra.hysteresis = n; + + bIterator = DeserializeEnum (16, &n, bIterator); + switch (n) + { + case 0: + elem->reportConfigEutra.timeToTrigger = 0; + break; + case 1: + elem->reportConfigEutra.timeToTrigger = 40; + break; + case 2: + elem->reportConfigEutra.timeToTrigger = 64; + break; + case 3: + elem->reportConfigEutra.timeToTrigger = 80; + break; + case 4: + elem->reportConfigEutra.timeToTrigger = 100; + break; + case 5: + elem->reportConfigEutra.timeToTrigger = 128; + break; + case 6: + elem->reportConfigEutra.timeToTrigger = 160; + break; + case 7: + elem->reportConfigEutra.timeToTrigger = 256; + break; + case 8: + elem->reportConfigEutra.timeToTrigger = 320; + break; + case 9: + elem->reportConfigEutra.timeToTrigger = 480; + break; + case 10: + elem->reportConfigEutra.timeToTrigger = 512; + break; + case 11: + elem->reportConfigEutra.timeToTrigger = 640; + break; + case 12: + elem->reportConfigEutra.timeToTrigger = 1024; + break; + case 13: + elem->reportConfigEutra.timeToTrigger = 1280; + break; + case 14: + elem->reportConfigEutra.timeToTrigger = 2560; + break; + case 15: + default: + elem->reportConfigEutra.timeToTrigger = 5120; + break; + } + } + + if (triggerTypeChoice == 1) + { + // periodical + elem->reportConfigEutra.triggerType = LteRrcSap::ReportConfigEutra::periodical; + + bIterator = DeserializeSequence (&bitset0, false, bIterator); + bIterator = DeserializeEnum (2, &n, bIterator); + if (n == 0) + { + elem->reportConfigEutra.purpose = LteRrcSap::ReportConfigEutra::reportStrongestCells; + } + else + { + elem->reportConfigEutra.purpose = LteRrcSap::ReportConfigEutra::reportCgi; + } + } + + // triggerQuantity + bIterator = DeserializeEnum (2, &n, bIterator); + if (n == 0) + { + elem->reportConfigEutra.triggerQuantity = LteRrcSap::ReportConfigEutra::rsrp; + } + else + { + elem->reportConfigEutra.triggerQuantity = LteRrcSap::ReportConfigEutra::rsrq; + } + + // reportQuantity + bIterator = DeserializeEnum (2, &n, bIterator); + if (n == 0) + { + elem->reportConfigEutra.reportQuantity = LteRrcSap::ReportConfigEutra::sameAsTriggerQuantity; + } + else + { + elem->reportConfigEutra.reportQuantity = LteRrcSap::ReportConfigEutra::both; + } + + // maxReportCells + bIterator = DeserializeInteger (&n, 1, MAX_CELL_REPORT, bIterator); + elem->reportConfigEutra.maxReportCells = n; + + // reportInterval + bIterator = DeserializeEnum (16, &n, bIterator); + switch (n) + { + case 0: + elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms120; + break; + case 1: + elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms240; + break; + case 2: + elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms480; + break; + case 3: + elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms640; + break; + case 4: + elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms1024; + break; + case 5: + elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms2048; + break; + case 6: + elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms5120; + break; + case 7: + elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms10240; + break; + case 8: + elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::min1; + break; + case 9: + elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::min6; + break; + case 10: + elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::min12; + break; + case 11: + elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::min30; + break; + case 12: + elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::min60; + break; + case 13: + elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::spare3; + break; + case 14: + elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::spare2; + break; + case 15: + default: + elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::spare1; + } + + // reportAmount + bIterator = DeserializeEnum (8, &n, bIterator); + switch (n) + { + case 0: + elem->reportConfigEutra.reportAmount = 1; + break; + case 1: + elem->reportConfigEutra.reportAmount = 2; + break; + case 2: + elem->reportConfigEutra.reportAmount = 4; + break; + case 3: + elem->reportConfigEutra.reportAmount = 8; + break; + case 4: + elem->reportConfigEutra.reportAmount = 16; + break; + case 5: + elem->reportConfigEutra.reportAmount = 32; + break; + case 6: + elem->reportConfigEutra.reportAmount = 64; + break; + default: + elem->reportConfigEutra.reportAmount = 0; + } + } + + if (reportConfigChoice == 1) + { + // ReportConfigInterRAT + // ... + } + + measConfig->reportConfigToAddModList.push_back (*elem); + } + } + + if (bitset11[6]) + { + // measIdToRemoveList + int measIdToRemoveListElems; + bIterator = DeserializeSequenceOf (&measIdToRemoveListElems, MAX_MEAS_ID, 1, bIterator); + + for (int i = 0; i < measIdToRemoveListElems; i++) + { + bIterator = DeserializeInteger (&n, 1, MAX_MEAS_ID, bIterator); + measConfig->measIdToRemoveList.push_back (n); + } + } + + if (bitset11[5]) + { + // measIdToAddModList + int measIdToAddModListElems; + bIterator = DeserializeSequenceOf (&measIdToAddModListElems, MAX_MEAS_ID, 1, bIterator); + + for (int i = 0; i < measIdToAddModListElems; i++) + { + LteRrcSap::MeasIdToAddMod * elem = new LteRrcSap::MeasIdToAddMod (); + + bIterator = DeserializeSequence (&bitset0, false, bIterator); + + bIterator = DeserializeInteger (&n, 1, MAX_MEAS_ID, bIterator); + elem->measId = n; + + bIterator = DeserializeInteger (&n, 1, MAX_OBJECT_ID, bIterator); + elem->measObjectId = n; + + bIterator = DeserializeInteger (&n, 1, MAX_REPORT_CONFIG_ID, bIterator); + elem->reportConfigId = n; + + measConfig->measIdToAddModList.push_back (*elem); + } + } + + measConfig->haveQuantityConfig = bitset11[4]; + if (measConfig->haveQuantityConfig) + { + // quantityConfig + std::bitset<4> quantityConfigOpts; + bIterator = DeserializeSequence (&quantityConfigOpts, true, bIterator); + + if (quantityConfigOpts[3]) + { + // quantityConfigEUTRA + bIterator = DeserializeSequence (&bitset0,false,bIterator); + bIterator = DeserializeEnum (16, &n, bIterator); + switch (n) + { + case 0: + measConfig->quantityConfig.filterCoefficientRSRP = 0; + break; + case 1: + measConfig->quantityConfig.filterCoefficientRSRP = 1; + break; + case 2: + measConfig->quantityConfig.filterCoefficientRSRP = 2; + break; + case 3: + measConfig->quantityConfig.filterCoefficientRSRP = 3; + break; + case 4: + measConfig->quantityConfig.filterCoefficientRSRP = 4; + break; + case 5: + measConfig->quantityConfig.filterCoefficientRSRP = 5; + break; + case 6: + measConfig->quantityConfig.filterCoefficientRSRP = 6; + break; + case 7: + measConfig->quantityConfig.filterCoefficientRSRP = 7; + break; + case 8: + measConfig->quantityConfig.filterCoefficientRSRP = 8; + break; + case 9: + measConfig->quantityConfig.filterCoefficientRSRP = 9; + break; + case 10: + measConfig->quantityConfig.filterCoefficientRSRP = 11; + break; + case 11: + measConfig->quantityConfig.filterCoefficientRSRP = 13; + break; + case 12: + measConfig->quantityConfig.filterCoefficientRSRP = 15; + break; + case 13: + measConfig->quantityConfig.filterCoefficientRSRP = 17; + break; + case 14: + measConfig->quantityConfig.filterCoefficientRSRP = 19; + break; + case 15: + measConfig->quantityConfig.filterCoefficientRSRP = 0; + break; + default: + measConfig->quantityConfig.filterCoefficientRSRP = 4; + } + bIterator = DeserializeEnum (16, &n, bIterator); + switch (n) + { + case 0: + measConfig->quantityConfig.filterCoefficientRSRQ = 0; + break; + case 1: + measConfig->quantityConfig.filterCoefficientRSRQ = 1; + break; + case 2: + measConfig->quantityConfig.filterCoefficientRSRQ = 2; + break; + case 3: + measConfig->quantityConfig.filterCoefficientRSRQ = 3; + break; + case 4: + measConfig->quantityConfig.filterCoefficientRSRQ = 4; + break; + case 5: + measConfig->quantityConfig.filterCoefficientRSRQ = 5; + break; + case 6: + measConfig->quantityConfig.filterCoefficientRSRQ = 6; + break; + case 7: + measConfig->quantityConfig.filterCoefficientRSRQ = 7; + break; + case 8: + measConfig->quantityConfig.filterCoefficientRSRQ = 8; + break; + case 9: + measConfig->quantityConfig.filterCoefficientRSRQ = 9; + break; + case 10: + measConfig->quantityConfig.filterCoefficientRSRQ = 11; + break; + case 11: + measConfig->quantityConfig.filterCoefficientRSRQ = 13; + break; + case 12: + measConfig->quantityConfig.filterCoefficientRSRQ = 15; + break; + case 13: + measConfig->quantityConfig.filterCoefficientRSRQ = 17; + break; + case 14: + measConfig->quantityConfig.filterCoefficientRSRQ = 19; + break; + case 15: + measConfig->quantityConfig.filterCoefficientRSRQ = 0; + break; + default: + measConfig->quantityConfig.filterCoefficientRSRQ = 4; + } + } + if (quantityConfigOpts[2]) + { + // quantityConfigUTRA + // ... + } + if (quantityConfigOpts[1]) + { + // quantityConfigGERAN + // ... + } + if (quantityConfigOpts[0]) + { + // quantityConfigCDMA2000 + // ... + } + } + + measConfig->haveMeasGapConfig = bitset11[3]; + if (measConfig->haveMeasGapConfig) + { + // measGapConfig + int measGapConfigChoice; + bIterator = DeserializeChoice (2, false, &measGapConfigChoice, bIterator); + switch (measGapConfigChoice) + { + case 0: + measConfig->measGapConfig.type = LteRrcSap::MeasGapConfig::RESET; + bIterator = DeserializeNull (bIterator); + break; + case 1: + default: + measConfig->measGapConfig.type = LteRrcSap::MeasGapConfig::SETUP; + bIterator = DeserializeSequence (&bitset0, false, bIterator); + + int gapOffsetChoice; + bIterator = DeserializeChoice (2, true, &gapOffsetChoice, bIterator); + switch (gapOffsetChoice) + { + case 0: + measConfig->measGapConfig.gapOffsetChoice = LteRrcSap::MeasGapConfig::gp0; + bIterator = DeserializeInteger (&n, 0, 39, bIterator); + measConfig->measGapConfig.gapOffsetValue = n; + break; + case 1: + default: + measConfig->measGapConfig.gapOffsetChoice = LteRrcSap::MeasGapConfig::gp1; + bIterator = DeserializeInteger (&n, 0, 79, bIterator); + measConfig->measGapConfig.gapOffsetValue = n; + } + } + } + + measConfig->haveSmeasure = bitset11[2]; + if (measConfig->haveSmeasure) + { + // s-Measure + bIterator = DeserializeInteger (&n, 0, 97, bIterator); + measConfig->sMeasure = n; + } + + if (bitset11[1]) + { + // preRegistrationInfoHRPD + // ... + } + + measConfig->haveSpeedStatePars = bitset11[0]; + if (measConfig->haveSpeedStatePars) + { + // speedStatePars + int speedStateParsChoice; + bIterator = DeserializeChoice (2, false, &speedStateParsChoice, bIterator); + switch (speedStateParsChoice) + { + case 0: + measConfig->speedStatePars.type = LteRrcSap::SpeedStatePars::RESET; + bIterator = DeserializeNull (bIterator); + break; + case 1: + default: + measConfig->speedStatePars.type = LteRrcSap::SpeedStatePars::SETUP; + bIterator = DeserializeSequence (&bitset0, false, bIterator); + + // Deserialize mobilityStateParameters + // Deserialize t-Evaluation + bIterator = DeserializeEnum (8, &n, bIterator); + switch (n) + { + case 0: + measConfig->speedStatePars.mobilityStateParameters.tEvaluation = 30; + break; + case 1: + measConfig->speedStatePars.mobilityStateParameters.tEvaluation = 60; + break; + case 2: + measConfig->speedStatePars.mobilityStateParameters.tEvaluation = 120; + break; + case 3: + measConfig->speedStatePars.mobilityStateParameters.tEvaluation = 180; + break; + case 4: + measConfig->speedStatePars.mobilityStateParameters.tEvaluation = 240; + break; + default: + measConfig->speedStatePars.mobilityStateParameters.tEvaluation = 0; + } + // Deserialize t-HystNormal + bIterator = DeserializeEnum (8, &n, bIterator); + switch (n) + { + case 0: + measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 30; + break; + case 1: + measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 60; + break; + case 2: + measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 120; + break; + case 3: + measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 180; + break; + case 4: + measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 240; + break; + default: + measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 0; + } + + bIterator = DeserializeInteger (&n, 1, 16, bIterator); + measConfig->speedStatePars.mobilityStateParameters.nCellChangeMedium = n; + + bIterator = DeserializeInteger (&n, 1, 16, bIterator); + measConfig->speedStatePars.mobilityStateParameters.nCellChangeHigh = n; + + // Deserialize timeToTriggerSf + bIterator = DeserializeEnum (4, &n, bIterator); + measConfig->speedStatePars.timeToTriggerSf.sfMedium = (n + 1) * 25; + bIterator = DeserializeEnum (4, &n, bIterator); + measConfig->speedStatePars.timeToTriggerSf.sfHigh = (n + 1) * 25; + } + } + return bIterator; +} //////////////////// RrcConnectionRequest class //////////////////////// // Constructor @@ -2656,13 +4415,9 @@ RrcConnectionReconfigurationHeader::PreSerialize () const options.set (0,0); // No nonCriticalExtension SerializeSequence (options,false); - if (m_haveMeasConfig) { - // Serialize MeasConfig sequence - // 11 optional fields, extension marker present - std::bitset<11> measConfigOptional (0); - SerializeSequence (measConfigOptional,true); + SerializeMeasConfig (m_measConfig); } if (m_haveMobilityControlInfo) @@ -2810,55 +4565,7 @@ RrcConnectionReconfigurationHeader::Deserialize (Buffer::Iterator bIterator) m_haveMeasConfig = rrcConnRecOpts[5]; if (m_haveMeasConfig) { - std::bitset<11> bitset11; - - // measConfig - bIterator = DeserializeSequence (&bitset11,true,bIterator); - - if (bitset11[10]) - { - // measObjectToRemoveList - } - if (bitset11[9]) - { - // measObjectToAddModList - } - if (bitset11[8]) - { - // reportConfigToRemoveList - } - if (bitset11[7]) - { - // reportConfigToAddModList - } - if (bitset11[6]) - { - // measIdToRemoveList - } - if (bitset11[5]) - { - // measIdToAddModList - } - if (bitset11[4]) - { - // quantityConfig - } - if (bitset11[3]) - { - // measGapConfig - } - if (bitset11[2]) - { - // s-Measure - } - if (bitset11[1]) - { - // preRegistrationInfoHRPD - } - if (bitset11[0]) - { - // speedStatePars - } + bIterator = DeserializeMeasConfig (&m_measConfig, bIterator); } m_haveMobilityControlInfo = rrcConnRecOpts[4]; @@ -3015,6 +4722,111 @@ RrcConnectionReconfigurationHeader::Print (std::ostream &os) const { os << "rrcTransactionIdentifier: " << (int) m_rrcTransactionIdentifier << std::endl; os << "haveMeasConfig: " << m_haveMeasConfig << std::endl; + if (m_haveMobilityControlInfo) + { + if (!m_measConfig.measObjectToRemoveList.empty ()) + { + os << " measObjectToRemoveList: "; + std::list auxList = m_measConfig.measObjectToRemoveList; + std::list::iterator it = auxList.begin (); + for (; it != auxList.end (); it++) + { + os << (int) *it << ", "; + } + os << std::endl; + } + if (!m_measConfig.reportConfigToRemoveList.empty ()) + { + os << " reportConfigToRemoveList: "; + std::list auxList = m_measConfig.reportConfigToRemoveList; + std::list::iterator it = auxList.begin (); + for (; it != auxList.end (); it++) + { + os << (int) *it << ", "; + } + os << std::endl; + } + if (!m_measConfig.measIdToRemoveList.empty ()) + { + os << " measIdToRemoveList: "; + std::list auxList = m_measConfig.measIdToRemoveList; + std::list::iterator it = auxList.begin (); + for (; it != auxList.end (); it++) + { + os << (int) *it << ", "; + } + os << std::endl; + } + + if (!m_measConfig.measObjectToAddModList.empty ()) + { + os << " measObjectToAddMod: " << std::endl; + std::list auxList = m_measConfig.measObjectToAddModList; + std::list::iterator it = auxList.begin (); + for (; it != auxList.end (); it++) + { + os << " measObjectId: " << (int)it->measObjectId << std::endl; + os << " carrierFreq: " << (int)it->measObjectEutra.carrierFreq << std::endl; + os << " allowedMeasBandwidth: " << (int)it->measObjectEutra.allowedMeasBandwidth << std::endl; + os << " presenceAntennaPort1: " << it->measObjectEutra.presenceAntennaPort1 << std::endl; + os << " neighCellConfig: " << (int) it->measObjectEutra.neighCellConfig << std::endl; + os << " offsetFreq: " << (int)it->measObjectEutra.offsetFreq << std::endl; + /* os << " measObjectId: " << it->measObjectEutra.cellsToRemoveList.push_back (5); + os << " measObjectId: " << it->measObjectEutra.cellsToRemoveList.push_back (2);*/ + + if (!it->measObjectEutra.blackCellsToRemoveList.empty ()) + { + os << " blackCellsToRemoveList: "; + std::list auxList = it->measObjectEutra.blackCellsToRemoveList; + std::list::iterator it = auxList.begin (); + for (; it != auxList.end (); it++) + { + os << (int) *it << ", "; + } + os << std::endl; + } + + os << " haveCellForWhichToReportCGI: " << it->measObjectEutra.haveCellForWhichToReportCGI << std::endl; + os << " cellForWhichToReportCGI: " << (int)it->measObjectEutra.cellForWhichToReportCGI << std::endl; + os << " ------------- " << std::endl; + } + + } + + os << " haveQuantityConfig: " << m_measConfig.haveQuantityConfig << std::endl; + if (m_measConfig.haveQuantityConfig) + { + os << " filterCoefficientRSRP: " << (int)m_measConfig.quantityConfig.filterCoefficientRSRP << std::endl; + os << " filterCoefficientRSRQ:" << (int)m_measConfig.quantityConfig.filterCoefficientRSRQ << std::endl; + } + + os << " haveMeasGapConfig: " << m_measConfig.haveMeasGapConfig << std::endl; + if (m_measConfig.haveMeasGapConfig) + { + os << " measGapConfig.type: " << m_measConfig.measGapConfig.type << std::endl; + os << " measGapConfig.gap (gap0/1,value): (" << m_measConfig.measGapConfig.gapOffsetChoice + << "," << (int) m_measConfig.measGapConfig.gapOffsetValue << ")" << std::endl; + } + + os << " haveSmeasure: " << m_measConfig.haveSmeasure << std::endl; + if (m_measConfig.haveSmeasure) + { + os << " sMeasure: " << (int) m_measConfig.sMeasure << std::endl; + } + + os << " haveSpeedStatePars: " << m_measConfig.haveSpeedStatePars << std::endl; + if (m_measConfig.haveSpeedStatePars) + { + os << " speedStatePars.type: " << m_measConfig.speedStatePars.type << std::endl; + os << " speedStatePars.mobilityStateParameters.tEvaluation: " << (int)m_measConfig.speedStatePars.mobilityStateParameters.tEvaluation << std::endl; + os << " speedStatePars.mobilityStateParameters.tHystNormal: " << (int)m_measConfig.speedStatePars.mobilityStateParameters.tHystNormal << std::endl; + os << " speedStatePars.mobilityStateParameters.nCellChangeMedium: " << (int)m_measConfig.speedStatePars.mobilityStateParameters.nCellChangeMedium << std::endl; + os << " speedStatePars.mobilityStateParameters.nCellChangeHigh: " << (int)m_measConfig.speedStatePars.mobilityStateParameters.nCellChangeHigh << std::endl; + os << " speedStatePars.timeToTriggerSf.sfMedium: " << (int)m_measConfig.speedStatePars.timeToTriggerSf.sfMedium << std::endl; + os << " speedStatePars.timeToTriggerSf.sfHigh: " << (int)m_measConfig.speedStatePars.timeToTriggerSf.sfHigh << std::endl; + } + } + os << "haveMobilityControlInfo: " << m_haveMobilityControlInfo << std::endl; if (m_haveMobilityControlInfo) { @@ -3188,9 +5000,7 @@ HandoverPreparationInfoHeader::PreSerialize () const SerializeSequence (std::bitset<0> (),true); // Serialize sourceMeasConfig - // 11 optional fields, extension marker present - std::bitset<11> measConfigOptional (0); - SerializeSequence (measConfigOptional,true); + SerializeMeasConfig (m_asConfig.sourceMeasConfig); // Serialize sourceRadioResourceConfig SerializeRadioResourceConfigDedicated (m_asConfig.sourceRadioResourceConfig); @@ -3279,53 +5089,7 @@ HandoverPreparationInfoHeader::Deserialize (Buffer::Iterator bIterator) bIterator = DeserializeSequence (&bitset0,true,bIterator); // Deserialize sourceMeasConfig - std::bitset<11> bitset11; - bIterator = DeserializeSequence (&bitset11,true,bIterator); - - if (bitset11[10]) //measObjectToRemoveList - { - // ... - } - if (bitset11[9]) //measObjectToAddModList - { - // ... - } - if (bitset11[8]) //reportConfigToRemoveList - { - // ... - } - if (bitset11[7]) //reportConfigToAddModList - { - // ... - } - if (bitset11[6]) //measIdToRemoveList - { - // ... - } - if (bitset11[5]) //measIdToAddModList - { - // ... - } - if (bitset11[4]) //quantityConfig - { - // ... - } - if (bitset11[3]) //measGapConfig - { - // ... - } - if (bitset11[2]) //s-Measure - { - // ... - } - if (bitset11[1]) //preRegistrationInfoHRPD - { - // ... - } - if (bitset11[0]) //speedStatePars - { - // ... - } + bIterator = DeserializeMeasConfig (&m_asConfig.sourceMeasConfig, bIterator); // Deserialize sourceRadioResourceConfig bIterator = DeserializeRadioResourceConfigDedicated (&m_asConfig.sourceRadioResourceConfig,bIterator); diff --git a/src/lte/model/lte-rrc-header.h b/src/lte/model/lte-rrc-header.h index 5325d5934..6164c34e8 100644 --- a/src/lte/model/lte-rrc-header.h +++ b/src/lte/model/lte-rrc-header.h @@ -61,7 +61,10 @@ protected: void SerializeMeasResults (LteRrcSap::MeasResults measResults) const; void SerializePlmnIdentity (uint32_t plmnId) const; void SerializeRachConfigCommon (LteRrcSap::RachConfigCommon rachConfigCommon) const; - + void SerializeMeasConfig (LteRrcSap::MeasConfig measConfig) const; + void SerializeQoffsetRange (int8_t qOffsetRange) const; + void SerializeThresholdEutra (LteRrcSap::ThresholdEutra thresholdEutra) const; + // Deserialization functions Buffer::Iterator DeserializeDrbToAddModList (std::list *drbToAddModLis, Buffer::Iterator bIterator); Buffer::Iterator DeserializeSrbToAddModList (std::list *srbToAddModList, Buffer::Iterator bIterator); @@ -75,6 +78,9 @@ protected: Buffer::Iterator DeserializeMeasResults (LteRrcSap::MeasResults *measResults, Buffer::Iterator bIterator); Buffer::Iterator DeserializePlmnIdentity (uint32_t *plmnId, Buffer::Iterator bIterator); Buffer::Iterator DeserializeRachConfigCommon (LteRrcSap::RachConfigCommon * rachConfigCommon, Buffer::Iterator bIterator); + Buffer::Iterator DeserializeMeasConfig (LteRrcSap::MeasConfig * measConfig, Buffer::Iterator bIterator); + Buffer::Iterator DeserializeQoffsetRange (int8_t * qOffsetRange, Buffer::Iterator bIterator); + Buffer::Iterator DeserializeThresholdEutra (LteRrcSap::ThresholdEutra * thresholdEutra, Buffer::Iterator bIterator); /** * This function prints RadioResourceConfigDedicated IE, for debugging purposes. diff --git a/src/lte/model/lte-rrc-sap.h b/src/lte/model/lte-rrc-sap.h index 25cf06dc0..e63845f24 100644 --- a/src/lte/model/lte-rrc-sap.h +++ b/src/lte/model/lte-rrc-sap.h @@ -218,12 +218,13 @@ public: struct ThresholdEutra { - uint8_t thresholdRsrp; - uint8_t thresholdRsrq; + enum {thresholdRsrp, thresholdRsrq} choice; + uint8_t range; }; struct ReportConfigEutra { + enum {event,periodical} triggerType; enum {eventA1,eventA2,eventA3,eventA4,eventA5} eventId; ThresholdEutra threshold1; // used for A1, A2, A4, A5 ThresholdEutra threshold2; // used for A5 diff --git a/src/lte/test/test-asn1-encoding.cc b/src/lte/test/test-asn1-encoding.cc index 1e9ce8fe3..cdbbbcf7a 100644 --- a/src/lte/test/test-asn1-encoding.cc +++ b/src/lte/test/test-asn1-encoding.cc @@ -46,7 +46,7 @@ public: pkt->CopyData (buffer, psize); for (uint32_t i = 0; i < psize; i++) { - sprintf (&sbuffer[i*3],"%02x ",buffer[i]); + sprintf (&sbuffer[i * 3],"%02x ",buffer[i]); } return std::string (sbuffer); } @@ -95,12 +95,12 @@ public: virtual void DoRun (void) = 0; LteRrcSap::RadioResourceConfigDedicated CreateRadioResourceConfigDedicated (); void AssertEqualRadioResourceConfigDedicated (LteRrcSap::RadioResourceConfigDedicated rrcd1, LteRrcSap::RadioResourceConfigDedicated rrcd2); - + protected: Ptr packet; }; -RrcHeaderTestCase :: RrcHeaderTestCase(std::string s) : TestCase(s) +RrcHeaderTestCase :: RrcHeaderTestCase (std::string s) : TestCase (s) { } @@ -254,7 +254,7 @@ RrcConnectionRequestTestCase::RrcConnectionRequestTestCase () : RrcHeaderTestCas void RrcConnectionRequestTestCase::DoRun (void) { - packet = Create(); + packet = Create (); NS_LOG_DEBUG ("============= RrcConnectionRequestTestCase ==========="); LteRrcSap::RrcConnectionRequest msg; @@ -282,7 +282,7 @@ RrcConnectionRequestTestCase::DoRun (void) // Check that the destination and source headers contain the same values NS_TEST_ASSERT_MSG_EQ (source.GetMmec (),destination.GetMmec (), "Different m_mmec!"); NS_TEST_ASSERT_MSG_EQ (source.GetMtmsi (),destination.GetMtmsi (), "Different m_mTmsi!"); - + packet = 0; } @@ -301,7 +301,7 @@ RrcConnectionSetupTestCase::RrcConnectionSetupTestCase () : RrcHeaderTestCase (" void RrcConnectionSetupTestCase::DoRun (void) { - packet = Create(); + packet = Create (); NS_LOG_DEBUG ("============= RrcConnectionSetupTestCase ==========="); LteRrcSap::RrcConnectionSetup msg; @@ -331,7 +331,7 @@ RrcConnectionSetupTestCase::DoRun (void) NS_TEST_ASSERT_MSG_EQ (source.GetRrcTransactionIdentifier (),destination.GetRrcTransactionIdentifier (), "RrcTransactionIdentifier"); AssertEqualRadioResourceConfigDedicated (source.GetRadioResourceConfigDedicated (),destination.GetRadioResourceConfigDedicated ()); - + packet = 0; } @@ -350,7 +350,7 @@ RrcConnectionSetupCompleteTestCase::RrcConnectionSetupCompleteTestCase () : RrcH void RrcConnectionSetupCompleteTestCase::DoRun (void) { - packet = Create(); + packet = Create (); NS_LOG_DEBUG ("============= RrcConnectionSetupCompleteTestCase ==========="); LteRrcSap::RrcConnectionSetupCompleted msg; @@ -377,7 +377,7 @@ RrcConnectionSetupCompleteTestCase::DoRun (void) // Check that the destination and source headers contain the same values NS_TEST_ASSERT_MSG_EQ (source.GetRrcTransactionIdentifier (),destination.GetRrcTransactionIdentifier (), "RrcTransactionIdentifier"); - + packet = 0; } @@ -397,7 +397,7 @@ RrcConnectionReconfigurationCompleteTestCase::RrcConnectionReconfigurationComple void RrcConnectionReconfigurationCompleteTestCase::DoRun (void) { - packet = Create(); + packet = Create (); NS_LOG_DEBUG ("============= RrcConnectionReconfigurationCompleteTestCase ==========="); LteRrcSap::RrcConnectionReconfigurationCompleted msg; @@ -424,7 +424,7 @@ RrcConnectionReconfigurationCompleteTestCase::DoRun (void) // Check that the destination and source headers contain the same values NS_TEST_ASSERT_MSG_EQ (source.GetRrcTransactionIdentifier (),destination.GetRrcTransactionIdentifier (), "RrcTransactionIdentifier"); - + packet = 0; } @@ -444,13 +444,68 @@ RrcConnectionReconfigurationTestCase::RrcConnectionReconfigurationTestCase () void RrcConnectionReconfigurationTestCase::DoRun (void) { - packet = Create(); + packet = Create (); NS_LOG_DEBUG ("============= RrcConnectionReconfigurationTestCase ==========="); LteRrcSap::RrcConnectionReconfiguration msg; msg.rrcTransactionIdentifier = 2; - msg.haveMeasConfig = false; + msg.haveMeasConfig = true; + + msg.measConfig.haveQuantityConfig = true; + msg.measConfig.quantityConfig.filterCoefficientRSRP = 8; + msg.measConfig.quantityConfig.filterCoefficientRSRQ = 7; + + msg.measConfig.haveMeasGapConfig = true; + msg.measConfig.measGapConfig.type = LteRrcSap::MeasGapConfig::SETUP; + msg.measConfig.measGapConfig.gapOffsetChoice = LteRrcSap::MeasGapConfig::gp0; + msg.measConfig.measGapConfig.gapOffsetValue = 21; + + msg.measConfig.haveSmeasure = true; + msg.measConfig.sMeasure = 57; + + msg.measConfig.haveSpeedStatePars = true; + msg.measConfig.speedStatePars.type = LteRrcSap::SpeedStatePars::SETUP; + msg.measConfig.speedStatePars.mobilityStateParameters.tEvaluation = 240; + msg.measConfig.speedStatePars.mobilityStateParameters.tHystNormal = 60; + msg.measConfig.speedStatePars.mobilityStateParameters.nCellChangeMedium = 5; + msg.measConfig.speedStatePars.mobilityStateParameters.nCellChangeHigh = 13; + msg.measConfig.speedStatePars.timeToTriggerSf.sfMedium = 25; + msg.measConfig.speedStatePars.timeToTriggerSf.sfHigh = 75; + + msg.measConfig.measObjectToRemoveList.push_back (23); + msg.measConfig.measObjectToRemoveList.push_back (13); + + msg.measConfig.reportConfigToRemoveList.push_back (7); + msg.measConfig.reportConfigToRemoveList.push_back (16); + + msg.measConfig.measIdToRemoveList.push_back (4); + msg.measConfig.measIdToRemoveList.push_back (18); + + // TODO: Test the following: + LteRrcSap::MeasObjectToAddMod measObjectToAddMod; + measObjectToAddMod.measObjectId = 3; + measObjectToAddMod.measObjectEutra.carrierFreq = 21; + measObjectToAddMod.measObjectEutra.allowedMeasBandwidth = 15; + measObjectToAddMod.measObjectEutra.presenceAntennaPort1 = true; + measObjectToAddMod.measObjectEutra.neighCellConfig = 3; + measObjectToAddMod.measObjectEutra.offsetFreq = -12; + measObjectToAddMod.measObjectEutra.cellsToRemoveList.push_back (5); + measObjectToAddMod.measObjectEutra.cellsToRemoveList.push_back (2); + measObjectToAddMod.measObjectEutra.blackCellsToRemoveList.push_back (1); + measObjectToAddMod.measObjectEutra.haveCellForWhichToReportCGI = true; + measObjectToAddMod.measObjectEutra.cellForWhichToReportCGI = 250; + + +// std::list cellsToAddModList; +// std::list blackCellsToAddModList; + // std::list reportConfigToAddModList; + // std::list measIdToAddModList; + + //msg.measConfig.measObjectToAddModList.push_back (measObjectToAddMod); + + + msg.haveMobilityControlInfo = true; msg.mobilityControlInfo.targetPhysCellId = 4; msg.mobilityControlInfo.haveCarrierFreq = true; @@ -539,7 +594,7 @@ RrcConnectionReconfigurationTestCase::DoRun (void) { AssertEqualRadioResourceConfigDedicated (source.GetRadioResourceConfigDedicated (), destination.GetRadioResourceConfigDedicated ()); } - + packet = 0; } @@ -558,7 +613,7 @@ HandoverPreparationInfoTestCase::HandoverPreparationInfoTestCase () : RrcHeaderT void HandoverPreparationInfoTestCase::DoRun (void) { - packet = Create(); + packet = Create (); NS_LOG_DEBUG ("============= HandoverPreparationInfoTestCase ==========="); LteRrcSap::HandoverPreparationInfo msg; @@ -573,12 +628,17 @@ HandoverPreparationInfoTestCase::DoRun (void) msg.asConfig.sourceSystemInformationBlockType1.cellAccessRelatedInfo.csgIdentity = 4; msg.asConfig.sourceSystemInformationBlockType1.cellAccessRelatedInfo.plmnIdentityInfo.plmnIdentity = 123; - msg.asConfig.sourceSystemInformationBlockType2.freqInfo.ulBandwidth=100; - msg.asConfig.sourceSystemInformationBlockType2.freqInfo.ulCarrierFreq=10; + msg.asConfig.sourceSystemInformationBlockType2.freqInfo.ulBandwidth = 100; + msg.asConfig.sourceSystemInformationBlockType2.freqInfo.ulCarrierFreq = 10; msg.asConfig.sourceSystemInformationBlockType2.radioResourceConfigCommon.rachConfigCommon.preambleInfo.numberOfRaPreambles = 4; msg.asConfig.sourceSystemInformationBlockType2.radioResourceConfigCommon.rachConfigCommon.raSupervisionInfo.preambleTransMax = 3; msg.asConfig.sourceSystemInformationBlockType2.radioResourceConfigCommon.rachConfigCommon.raSupervisionInfo.raResponseWindowSize = 6; - + + msg.asConfig.sourceMeasConfig.haveQuantityConfig = false; + msg.asConfig.sourceMeasConfig.haveMeasGapConfig = false; + msg.asConfig.sourceMeasConfig.haveSmeasure = false; + msg.asConfig.sourceMeasConfig.haveSpeedStatePars = false; + HandoverPreparationInfoHeader source; source.SetMessage (msg); @@ -608,8 +668,8 @@ HandoverPreparationInfoTestCase::DoRun (void) NS_TEST_ASSERT_MSG_EQ (source.GetAsConfig ().sourceSystemInformationBlockType1.cellAccessRelatedInfo.cellIdentity, destination.GetAsConfig ().sourceSystemInformationBlockType1.cellAccessRelatedInfo.cellIdentity, "cellIdentity"); NS_TEST_ASSERT_MSG_EQ (source.GetAsConfig ().sourceSystemInformationBlockType1.cellAccessRelatedInfo.csgIdentity, destination.GetAsConfig ().sourceSystemInformationBlockType1.cellAccessRelatedInfo.csgIdentity, "csgIdentity"); NS_TEST_ASSERT_MSG_EQ (source.GetAsConfig ().sourceDlCarrierFreq, destination.GetAsConfig ().sourceDlCarrierFreq, "sourceDlCarrierFreq"); - - packet = 0; + + packet = 0; } // --------------------------- CLASS RrcConnectionReestablishmentRequestTestCase ----------------------------- @@ -627,7 +687,7 @@ RrcConnectionReestablishmentRequestTestCase::RrcConnectionReestablishmentRequest void RrcConnectionReestablishmentRequestTestCase::DoRun (void) { - packet = Create(); + packet = Create (); NS_LOG_DEBUG ("============= RrcConnectionReestablishmentRequestTestCase ==========="); LteRrcSap::RrcConnectionReestablishmentRequest msg; @@ -658,7 +718,7 @@ RrcConnectionReestablishmentRequestTestCase::DoRun (void) NS_TEST_ASSERT_MSG_EQ (source.GetUeIdentity ().cRnti, destination.GetUeIdentity ().cRnti, "cRnti"); NS_TEST_ASSERT_MSG_EQ (source.GetUeIdentity ().physCellId, destination.GetUeIdentity ().physCellId, "physCellId"); NS_TEST_ASSERT_MSG_EQ (source.GetReestablishmentCause (),destination.GetReestablishmentCause (), "ReestablishmentCause"); - + packet = 0; } @@ -677,7 +737,7 @@ RrcConnectionReestablishmentTestCase::RrcConnectionReestablishmentTestCase () : void RrcConnectionReestablishmentTestCase::DoRun (void) { - packet = Create(); + packet = Create (); NS_LOG_DEBUG ("============= RrcConnectionReestablishmentTestCase ==========="); LteRrcSap::RrcConnectionReestablishment msg; @@ -706,7 +766,7 @@ RrcConnectionReestablishmentTestCase::DoRun (void) // Check that the destination and source headers contain the same values NS_TEST_ASSERT_MSG_EQ (source.GetRrcTransactionIdentifier (), destination.GetRrcTransactionIdentifier (), "rrcTransactionIdentifier"); AssertEqualRadioResourceConfigDedicated (source.GetRadioResourceConfigDedicated (),destination.GetRadioResourceConfigDedicated ()); - + packet = 0; } @@ -725,7 +785,7 @@ RrcConnectionReestablishmentCompleteTestCase::RrcConnectionReestablishmentComple void RrcConnectionReestablishmentCompleteTestCase::DoRun (void) { - packet = Create(); + packet = Create (); NS_LOG_DEBUG ("============= RrcConnectionReestablishmentCompleteTestCase ==========="); LteRrcSap::RrcConnectionReestablishmentComplete msg; @@ -752,7 +812,7 @@ RrcConnectionReestablishmentCompleteTestCase::DoRun (void) // Check that the destination and source headers contain the same values NS_TEST_ASSERT_MSG_EQ (source.GetRrcTransactionIdentifier (), destination.GetRrcTransactionIdentifier (), "rrcTransactionIdentifier"); - + packet = 0; } @@ -771,7 +831,7 @@ RrcConnectionRejectTestCase::RrcConnectionRejectTestCase () : RrcHeaderTestCase void RrcConnectionRejectTestCase::DoRun (void) { - packet = Create(); + packet = Create (); NS_LOG_DEBUG ("============= RrcConnectionRejectTestCase ==========="); LteRrcSap::RrcConnectionReject msg; @@ -798,7 +858,7 @@ RrcConnectionRejectTestCase::DoRun (void) // Check that the destination and source headers contain the same values NS_TEST_ASSERT_MSG_EQ (source.GetMessage ().waitTime, destination.GetMessage ().waitTime, "Different waitTime!"); - + packet = 0; } @@ -817,7 +877,7 @@ MeasurementReportTestCase::MeasurementReportTestCase () : RrcHeaderTestCase ("Te void MeasurementReportTestCase::DoRun (void) { - packet = Create(); + packet = Create (); NS_LOG_DEBUG ("============= MeasurementReportTestCase ==========="); LteRrcSap::MeasurementReport msg; @@ -909,7 +969,7 @@ MeasurementReportTestCase::DoRun (void) } } - packet = 0; + packet = 0; } // --------------------------- CLASS Asn1EncodingSuite ----------------------------- @@ -923,17 +983,17 @@ Asn1EncodingSuite::Asn1EncodingSuite () : TestSuite ("test-asn1-encoding", UNIT) { NS_LOG_FUNCTION (this); - AddTestCase (new RrcConnectionRequestTestCase()); - AddTestCase (new RrcConnectionSetupTestCase()); - AddTestCase (new RrcConnectionSetupCompleteTestCase()); - AddTestCase (new RrcConnectionReconfigurationCompleteTestCase()); - AddTestCase (new RrcConnectionReconfigurationTestCase()); - AddTestCase (new HandoverPreparationInfoTestCase()); - AddTestCase (new RrcConnectionReestablishmentRequestTestCase()); - AddTestCase (new RrcConnectionReestablishmentTestCase()); - AddTestCase (new RrcConnectionReestablishmentCompleteTestCase()); - AddTestCase (new RrcConnectionRejectTestCase()); - AddTestCase (new MeasurementReportTestCase()); + AddTestCase (new RrcConnectionRequestTestCase ()); + AddTestCase (new RrcConnectionSetupTestCase ()); + AddTestCase (new RrcConnectionSetupCompleteTestCase ()); + AddTestCase (new RrcConnectionReconfigurationCompleteTestCase ()); + AddTestCase (new RrcConnectionReconfigurationTestCase ()); + AddTestCase (new HandoverPreparationInfoTestCase ()); + AddTestCase (new RrcConnectionReestablishmentRequestTestCase ()); + AddTestCase (new RrcConnectionReestablishmentTestCase ()); + AddTestCase (new RrcConnectionReestablishmentCompleteTestCase ()); + AddTestCase (new RrcConnectionRejectTestCase ()); + AddTestCase (new MeasurementReportTestCase ()); } Asn1EncodingSuite asn1EncodingSuite; From 5621b104a724202dab3c9106c9abb5ed370bc2aa Mon Sep 17 00:00:00 2001 From: Nicola Baldo Date: Wed, 20 Feb 2013 13:05:19 +0100 Subject: [PATCH 09/10] whitespace change in lte-design.rst --- src/lte/doc/source/lte-design.rst | 1 + 1 file changed, 1 insertion(+) diff --git a/src/lte/doc/source/lte-design.rst b/src/lte/doc/source/lte-design.rst index 032c2cea8..d9e286722 100644 --- a/src/lte/doc/source/lte-design.rst +++ b/src/lte/doc/source/lte-design.rst @@ -1756,6 +1756,7 @@ Some implementation choices have been made in the RRC regarding the setup of rad - three Logical Channel Groups (out of four available) are configured for uplink buffer status report purposes, according to the following policy: + + LCG 0 is for signaling radio bearers + LCG 1 is for GBR data radio bearers + LCG 2 is for Non-GBR data radio bearers From 7c4275b5a90045312d5e195691487004a7f7db0c Mon Sep 17 00:00:00 2001 From: Lluis Parcerisa Date: Wed, 20 Feb 2013 13:59:58 +0100 Subject: [PATCH 10/10] Finish MeasConfig test. Fix serialization/deserialization bugs. --- src/lte/model/lte-rrc-header.cc | 456 +++++++++++++++++------------ src/lte/test/test-asn1-encoding.cc | 54 +++- 2 files changed, 320 insertions(+), 190 deletions(-) diff --git a/src/lte/model/lte-rrc-header.cc b/src/lte/model/lte-rrc-header.cc index 31b68ca42..70d09a644 100644 --- a/src/lte/model/lte-rrc-header.cc +++ b/src/lte/model/lte-rrc-header.cc @@ -863,100 +863,100 @@ RrcAsn1Header::SerializeQoffsetRange (int8_t qOffsetRange) const switch (qOffsetRange) { case -24: - SerializeEnum (32,0); + SerializeEnum (31,0); break; case -22: - SerializeEnum (32,1); + SerializeEnum (31,1); break; case -20: - SerializeEnum (32,2); + SerializeEnum (31,2); break; case -18: - SerializeEnum (32,3); + SerializeEnum (31,3); break; case -16: - SerializeEnum (32,4); + SerializeEnum (31,4); break; case -14: - SerializeEnum (32,5); + SerializeEnum (31,5); break; case -12: - SerializeEnum (32,6); + SerializeEnum (31,6); break; case -10: - SerializeEnum (32,7); + SerializeEnum (31,7); break; case -8: - SerializeEnum (32,8); + SerializeEnum (31,8); break; case -6: - SerializeEnum (32,9); + SerializeEnum (31,9); break; case -5: - SerializeEnum (32,10); + SerializeEnum (31,10); break; case -4: - SerializeEnum (32,11); + SerializeEnum (31,11); break; case -3: - SerializeEnum (32,12); + SerializeEnum (31,12); break; case -2: - SerializeEnum (32,13); + SerializeEnum (31,13); break; case -1: - SerializeEnum (32,14); + SerializeEnum (31,14); break; case 0: - SerializeEnum (32,15); + SerializeEnum (31,15); break; case 1: - SerializeEnum (32,16); + SerializeEnum (31,16); break; case 2: - SerializeEnum (32,17); + SerializeEnum (31,17); break; case 3: - SerializeEnum (32,18); + SerializeEnum (31,18); break; case 4: - SerializeEnum (32,19); + SerializeEnum (31,19); break; case 5: - SerializeEnum (32,20); + SerializeEnum (31,20); break; case 6: - SerializeEnum (32,21); + SerializeEnum (31,21); break; case 8: - SerializeEnum (32,22); + SerializeEnum (31,22); break; case 10: - SerializeEnum (32,23); + SerializeEnum (31,23); break; case 12: - SerializeEnum (32,24); + SerializeEnum (31,24); break; case 14: - SerializeEnum (32,25); + SerializeEnum (31,25); break; case 16: - SerializeEnum (32,26); + SerializeEnum (31,26); break; case 18: - SerializeEnum (32,27); + SerializeEnum (31,27); break; case 20: - SerializeEnum (32,28); + SerializeEnum (31,28); break; case 22: - SerializeEnum (32,29); + SerializeEnum (31,29); break; case 24: - SerializeEnum (32,30); + SerializeEnum (31,30); break; default: - SerializeEnum (32,15); + SerializeEnum (31,15); } } @@ -966,10 +966,12 @@ RrcAsn1Header::SerializeThresholdEutra (LteRrcSap::ThresholdEutra thresholdEutra switch (thresholdEutra.choice) { case LteRrcSap::ThresholdEutra::thresholdRsrp: + SerializeChoice (2,0,false); SerializeInteger (thresholdEutra.range, 0, 97); break; case LteRrcSap::ThresholdEutra::thresholdRsrq: default: + SerializeChoice (2,1,false); SerializeInteger (thresholdEutra.range, 0, 34); } } @@ -1071,9 +1073,7 @@ RrcAsn1Header::SerializeMeasConfig (LteRrcSap::MeasConfig measConfig) const // Serialize cellIndex SerializeInteger (it2->cellIndex, 1, MAX_CELL_MEAS); - // Serialize PhysCellIdRange - // range optional and not present - SerializeSequence (std::bitset<1> (0),false); + // Serialize PhysCellId SerializeInteger (it2->physCellId,0,503); // Serialize cellIndividualOffset @@ -1203,7 +1203,7 @@ RrcAsn1Header::SerializeMeasConfig (LteRrcSap::MeasConfig measConfig) const case LteRrcSap::ReportConfigEutra::event: default: SerializeChoice (2, 0, false); - SerializeSequence (std::bitset<0> (),true); + SerializeSequence (std::bitset<0> (),false); switch (it->reportConfigEutra.eventId) { case LteRrcSap::ReportConfigEutra::eventA1: @@ -3050,12 +3050,12 @@ RrcAsn1Header::DeserializeMeasConfig (LteRrcSap::MeasConfig * measConfig, Buffer for (int i = 0; i < measObjectToAddModListElems; i++) { - LteRrcSap::MeasObjectToAddMod * elem = new LteRrcSap::MeasObjectToAddMod (); + LteRrcSap::MeasObjectToAddMod elem; bIterator = DeserializeSequence (&bitset0, false, bIterator); bIterator = DeserializeInteger (&n, 1, MAX_OBJECT_ID, bIterator); - elem->measObjectId = n; + elem.measObjectId = n; int measObjectChoice; bIterator = DeserializeChoice (4, true, &measObjectChoice, bIterator); @@ -3085,42 +3085,42 @@ RrcAsn1Header::DeserializeMeasConfig (LteRrcSap::MeasConfig * measConfig, Buffer // carrierFreq bIterator = DeserializeInteger (&n, 0, MAX_EARFCN, bIterator); - elem->measObjectEutra.carrierFreq = n; + elem.measObjectEutra.carrierFreq = n; // allowedMeasBandwidth bIterator = DeserializeEnum (6, &n, bIterator); switch (n) { case 0: - elem->measObjectEutra.allowedMeasBandwidth = 6; + elem.measObjectEutra.allowedMeasBandwidth = 6; break; case 1: - elem->measObjectEutra.allowedMeasBandwidth = 15; + elem.measObjectEutra.allowedMeasBandwidth = 15; break; case 2: - elem->measObjectEutra.allowedMeasBandwidth = 25; + elem.measObjectEutra.allowedMeasBandwidth = 25; break; case 3: - elem->measObjectEutra.allowedMeasBandwidth = 50; + elem.measObjectEutra.allowedMeasBandwidth = 50; break; case 4: - elem->measObjectEutra.allowedMeasBandwidth = 75; + elem.measObjectEutra.allowedMeasBandwidth = 75; break; case 5: default: - elem->measObjectEutra.allowedMeasBandwidth = 100; + elem.measObjectEutra.allowedMeasBandwidth = 100; break; } // presenceAntennaPort1 - bIterator = DeserializeBoolean (&elem->measObjectEutra.presenceAntennaPort1, bIterator); + bIterator = DeserializeBoolean (&elem.measObjectEutra.presenceAntennaPort1, bIterator); // neighCellConfig bIterator = DeserializeBitstring (&bitset2, bIterator); - elem->measObjectEutra.neighCellConfig = bitset2.to_ulong (); + elem.measObjectEutra.neighCellConfig = bitset2.to_ulong (); // offsetFreq - DeserializeQoffsetRange (&elem->measObjectEutra.offsetFreq, bIterator); + bIterator = DeserializeQoffsetRange (&elem.measObjectEutra.offsetFreq, bIterator); if (measObjectEutraOpts[4]) { @@ -3131,7 +3131,7 @@ RrcAsn1Header::DeserializeMeasConfig (LteRrcSap::MeasConfig * measConfig, Buffer for (int i = 0; i < numElems; i++) { bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIterator); - elem->measObjectEutra.cellsToRemoveList.push_back (n); + elem.measObjectEutra.cellsToRemoveList.push_back (n); } } @@ -3143,22 +3143,22 @@ RrcAsn1Header::DeserializeMeasConfig (LteRrcSap::MeasConfig * measConfig, Buffer for (int i = 0; i < numElems; i++) { - LteRrcSap::CellsToAddMod * cellsToAddMod = new LteRrcSap::CellsToAddMod (); + LteRrcSap::CellsToAddMod cellsToAddMod; bIterator = DeserializeSequence (&bitset0, false, bIterator); // cellIndex bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIterator); - cellsToAddMod->cellIndex = n; + cellsToAddMod.cellIndex = n; // PhysCellId bIterator = DeserializeInteger (&n, 0, 503, bIterator); - cellsToAddMod->physCellId = n; + cellsToAddMod.physCellId = n; // cellIndividualOffset - bIterator = DeserializeQoffsetRange ( &cellsToAddMod->cellIndividualOffset, bIterator); + bIterator = DeserializeQoffsetRange ( &cellsToAddMod.cellIndividualOffset, bIterator); - elem->measObjectEutra.cellsToAddModList.push_back (*cellsToAddMod); + elem.measObjectEutra.cellsToAddModList.push_back (cellsToAddMod); } } @@ -3171,7 +3171,7 @@ RrcAsn1Header::DeserializeMeasConfig (LteRrcSap::MeasConfig * measConfig, Buffer for (int i = 0; i < numElems; i++) { bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIterator); - elem->measObjectEutra.blackCellsToRemoveList.push_back (n); + elem.measObjectEutra.blackCellsToRemoveList.push_back (n); } } @@ -3184,11 +3184,11 @@ RrcAsn1Header::DeserializeMeasConfig (LteRrcSap::MeasConfig * measConfig, Buffer for (int i = 0; i < numElems; i++) { - LteRrcSap::BlackCellsToAddMod * blackCellsToAddMod = new LteRrcSap::BlackCellsToAddMod (); + LteRrcSap::BlackCellsToAddMod blackCellsToAddMod; bIterator = DeserializeSequence (&bitset0, false, bIterator); bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIterator); - blackCellsToAddMod->cellIndex = n; + blackCellsToAddMod.cellIndex = n; // PhysCellIdRange std::bitset<1> isRangePresent; @@ -3196,75 +3196,75 @@ RrcAsn1Header::DeserializeMeasConfig (LteRrcSap::MeasConfig * measConfig, Buffer // start bIterator = DeserializeInteger (&n, 0, 503, bIterator); - blackCellsToAddMod->physCellIdRange.start = n; + blackCellsToAddMod.physCellIdRange.start = n; - blackCellsToAddMod->physCellIdRange.haveRange = isRangePresent[0]; - if (blackCellsToAddMod->physCellIdRange.haveRange) + blackCellsToAddMod.physCellIdRange.haveRange = isRangePresent[0]; + if (blackCellsToAddMod.physCellIdRange.haveRange) { // range bIterator = DeserializeEnum (16, &n, bIterator); switch (n) { case 0: - blackCellsToAddMod->physCellIdRange.range = 4; + blackCellsToAddMod.physCellIdRange.range = 4; break; case 1: - blackCellsToAddMod->physCellIdRange.range = 8; + blackCellsToAddMod.physCellIdRange.range = 8; break; case 2: - blackCellsToAddMod->physCellIdRange.range = 12; + blackCellsToAddMod.physCellIdRange.range = 12; break; case 3: - blackCellsToAddMod->physCellIdRange.range = 16; + blackCellsToAddMod.physCellIdRange.range = 16; break; case 4: - blackCellsToAddMod->physCellIdRange.range = 24; + blackCellsToAddMod.physCellIdRange.range = 24; break; case 5: - blackCellsToAddMod->physCellIdRange.range = 32; + blackCellsToAddMod.physCellIdRange.range = 32; break; case 6: - blackCellsToAddMod->physCellIdRange.range = 48; + blackCellsToAddMod.physCellIdRange.range = 48; break; case 7: - blackCellsToAddMod->physCellIdRange.range = 64; + blackCellsToAddMod.physCellIdRange.range = 64; break; case 8: - blackCellsToAddMod->physCellIdRange.range = 84; + blackCellsToAddMod.physCellIdRange.range = 84; break; case 9: - blackCellsToAddMod->physCellIdRange.range = 96; + blackCellsToAddMod.physCellIdRange.range = 96; break; case 10: - blackCellsToAddMod->physCellIdRange.range = 128; + blackCellsToAddMod.physCellIdRange.range = 128; break; case 11: - blackCellsToAddMod->physCellIdRange.range = 168; + blackCellsToAddMod.physCellIdRange.range = 168; break; case 12: - blackCellsToAddMod->physCellIdRange.range = 252; + blackCellsToAddMod.physCellIdRange.range = 252; break; case 13: - blackCellsToAddMod->physCellIdRange.range = 504; + blackCellsToAddMod.physCellIdRange.range = 504; break; default: - blackCellsToAddMod->physCellIdRange.range = 0; + blackCellsToAddMod.physCellIdRange.range = 0; } } - elem->measObjectEutra.blackCellsToAddModList.push_back (*blackCellsToAddMod); + elem.measObjectEutra.blackCellsToAddModList.push_back (blackCellsToAddMod); } } - elem->measObjectEutra.haveCellForWhichToReportCGI = measObjectEutraOpts[0]; + elem.measObjectEutra.haveCellForWhichToReportCGI = measObjectEutraOpts[0]; if (measObjectEutraOpts[0]) { // cellForWhichToReportCGI bIterator = DeserializeInteger (&n, 0, 503, bIterator); - elem->measObjectEutra.cellForWhichToReportCGI = n; + elem.measObjectEutra.cellForWhichToReportCGI = n; } } - measConfig->measObjectToAddModList.push_back (*elem); + measConfig->measObjectToAddModList.push_back (elem); } } @@ -3289,11 +3289,11 @@ RrcAsn1Header::DeserializeMeasConfig (LteRrcSap::MeasConfig * measConfig, Buffer for (int i = 0; i < reportConfigToAddModListElems; i++) { - LteRrcSap::ReportConfigToAddMod * elem = new LteRrcSap::ReportConfigToAddMod (); + LteRrcSap::ReportConfigToAddMod elem; bIterator = DeserializeSequence (&bitset0, false, bIterator); bIterator = DeserializeInteger (&n, 1, MAX_REPORT_CONFIG_ID, bIterator); - elem->reportConfigId = n; + elem.reportConfigId = n; // Deserialize reportConfig int reportConfigChoice; @@ -3311,7 +3311,7 @@ RrcAsn1Header::DeserializeMeasConfig (LteRrcSap::MeasConfig * measConfig, Buffer if (triggerTypeChoice == 0) { // event - elem->reportConfigEutra.triggerType = LteRrcSap::ReportConfigEutra::event; + elem.reportConfigEutra.triggerType = LteRrcSap::ReportConfigEutra::event; bIterator = DeserializeSequence (&bitset0, false, bIterator); // eventId @@ -3321,93 +3321,93 @@ RrcAsn1Header::DeserializeMeasConfig (LteRrcSap::MeasConfig * measConfig, Buffer switch (eventIdChoice) { case 0: - elem->reportConfigEutra.eventId = LteRrcSap::ReportConfigEutra::eventA1; + elem.reportConfigEutra.eventId = LteRrcSap::ReportConfigEutra::eventA1; bIterator = DeserializeSequence (&bitset0, false, bIterator); - bIterator = DeserializeThresholdEutra (&elem->reportConfigEutra.threshold1, bIterator); + bIterator = DeserializeThresholdEutra (&elem.reportConfigEutra.threshold1, bIterator); break; case 1: - elem->reportConfigEutra.eventId = LteRrcSap::ReportConfigEutra::eventA2; + elem.reportConfigEutra.eventId = LteRrcSap::ReportConfigEutra::eventA2; bIterator = DeserializeSequence (&bitset0, false, bIterator); - bIterator = DeserializeThresholdEutra (&elem->reportConfigEutra.threshold1, bIterator); + bIterator = DeserializeThresholdEutra (&elem.reportConfigEutra.threshold1, bIterator); break; case 2: - elem->reportConfigEutra.eventId = LteRrcSap::ReportConfigEutra::eventA3; + elem.reportConfigEutra.eventId = LteRrcSap::ReportConfigEutra::eventA3; bIterator = DeserializeSequence (&bitset0, false, bIterator); bIterator = DeserializeInteger (&n, -30, 30, bIterator); - elem->reportConfigEutra.a3Offset = n; - bIterator = DeserializeBoolean (&elem->reportConfigEutra.reportOnLeave, bIterator); + elem.reportConfigEutra.a3Offset = n; + bIterator = DeserializeBoolean (&elem.reportConfigEutra.reportOnLeave, bIterator); break; case 3: - elem->reportConfigEutra.eventId = LteRrcSap::ReportConfigEutra::eventA4; + elem.reportConfigEutra.eventId = LteRrcSap::ReportConfigEutra::eventA4; bIterator = DeserializeSequence (&bitset0, false, bIterator); - bIterator = DeserializeThresholdEutra (&elem->reportConfigEutra.threshold1, bIterator); + bIterator = DeserializeThresholdEutra (&elem.reportConfigEutra.threshold1, bIterator); break; + case 4: default: - elem->reportConfigEutra.eventId = LteRrcSap::ReportConfigEutra::eventA5; + elem.reportConfigEutra.eventId = LteRrcSap::ReportConfigEutra::eventA5; bIterator = DeserializeSequence (&bitset0, false, bIterator); - bIterator = DeserializeThresholdEutra (&elem->reportConfigEutra.threshold1, bIterator); - bIterator = DeserializeThresholdEutra (&elem->reportConfigEutra.threshold2, bIterator); - break; + bIterator = DeserializeThresholdEutra (&elem.reportConfigEutra.threshold1, bIterator); + bIterator = DeserializeThresholdEutra (&elem.reportConfigEutra.threshold2, bIterator); } bIterator = DeserializeInteger (&n, 0, 30, bIterator); - elem->reportConfigEutra.hysteresis = n; + elem.reportConfigEutra.hysteresis = n; bIterator = DeserializeEnum (16, &n, bIterator); switch (n) { case 0: - elem->reportConfigEutra.timeToTrigger = 0; + elem.reportConfigEutra.timeToTrigger = 0; break; case 1: - elem->reportConfigEutra.timeToTrigger = 40; + elem.reportConfigEutra.timeToTrigger = 40; break; case 2: - elem->reportConfigEutra.timeToTrigger = 64; + elem.reportConfigEutra.timeToTrigger = 64; break; case 3: - elem->reportConfigEutra.timeToTrigger = 80; + elem.reportConfigEutra.timeToTrigger = 80; break; case 4: - elem->reportConfigEutra.timeToTrigger = 100; + elem.reportConfigEutra.timeToTrigger = 100; break; case 5: - elem->reportConfigEutra.timeToTrigger = 128; + elem.reportConfigEutra.timeToTrigger = 128; break; case 6: - elem->reportConfigEutra.timeToTrigger = 160; + elem.reportConfigEutra.timeToTrigger = 160; break; case 7: - elem->reportConfigEutra.timeToTrigger = 256; + elem.reportConfigEutra.timeToTrigger = 256; break; case 8: - elem->reportConfigEutra.timeToTrigger = 320; + elem.reportConfigEutra.timeToTrigger = 320; break; case 9: - elem->reportConfigEutra.timeToTrigger = 480; + elem.reportConfigEutra.timeToTrigger = 480; break; case 10: - elem->reportConfigEutra.timeToTrigger = 512; + elem.reportConfigEutra.timeToTrigger = 512; break; case 11: - elem->reportConfigEutra.timeToTrigger = 640; + elem.reportConfigEutra.timeToTrigger = 640; break; case 12: - elem->reportConfigEutra.timeToTrigger = 1024; + elem.reportConfigEutra.timeToTrigger = 1024; break; case 13: - elem->reportConfigEutra.timeToTrigger = 1280; + elem.reportConfigEutra.timeToTrigger = 1280; break; case 14: - elem->reportConfigEutra.timeToTrigger = 2560; + elem.reportConfigEutra.timeToTrigger = 2560; break; case 15: default: - elem->reportConfigEutra.timeToTrigger = 5120; + elem.reportConfigEutra.timeToTrigger = 5120; break; } } @@ -3415,17 +3415,17 @@ RrcAsn1Header::DeserializeMeasConfig (LteRrcSap::MeasConfig * measConfig, Buffer if (triggerTypeChoice == 1) { // periodical - elem->reportConfigEutra.triggerType = LteRrcSap::ReportConfigEutra::periodical; + elem.reportConfigEutra.triggerType = LteRrcSap::ReportConfigEutra::periodical; bIterator = DeserializeSequence (&bitset0, false, bIterator); bIterator = DeserializeEnum (2, &n, bIterator); if (n == 0) { - elem->reportConfigEutra.purpose = LteRrcSap::ReportConfigEutra::reportStrongestCells; + elem.reportConfigEutra.purpose = LteRrcSap::ReportConfigEutra::reportStrongestCells; } else { - elem->reportConfigEutra.purpose = LteRrcSap::ReportConfigEutra::reportCgi; + elem.reportConfigEutra.purpose = LteRrcSap::ReportConfigEutra::reportCgi; } } @@ -3433,80 +3433,80 @@ RrcAsn1Header::DeserializeMeasConfig (LteRrcSap::MeasConfig * measConfig, Buffer bIterator = DeserializeEnum (2, &n, bIterator); if (n == 0) { - elem->reportConfigEutra.triggerQuantity = LteRrcSap::ReportConfigEutra::rsrp; + elem.reportConfigEutra.triggerQuantity = LteRrcSap::ReportConfigEutra::rsrp; } else { - elem->reportConfigEutra.triggerQuantity = LteRrcSap::ReportConfigEutra::rsrq; + elem.reportConfigEutra.triggerQuantity = LteRrcSap::ReportConfigEutra::rsrq; } // reportQuantity bIterator = DeserializeEnum (2, &n, bIterator); if (n == 0) { - elem->reportConfigEutra.reportQuantity = LteRrcSap::ReportConfigEutra::sameAsTriggerQuantity; + elem.reportConfigEutra.reportQuantity = LteRrcSap::ReportConfigEutra::sameAsTriggerQuantity; } else { - elem->reportConfigEutra.reportQuantity = LteRrcSap::ReportConfigEutra::both; + elem.reportConfigEutra.reportQuantity = LteRrcSap::ReportConfigEutra::both; } // maxReportCells bIterator = DeserializeInteger (&n, 1, MAX_CELL_REPORT, bIterator); - elem->reportConfigEutra.maxReportCells = n; + elem.reportConfigEutra.maxReportCells = n; // reportInterval bIterator = DeserializeEnum (16, &n, bIterator); switch (n) { case 0: - elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms120; + elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms120; break; case 1: - elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms240; + elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms240; break; case 2: - elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms480; + elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms480; break; case 3: - elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms640; + elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms640; break; case 4: - elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms1024; + elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms1024; break; case 5: - elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms2048; + elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms2048; break; case 6: - elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms5120; + elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms5120; break; case 7: - elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms10240; + elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms10240; break; case 8: - elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::min1; + elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::min1; break; case 9: - elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::min6; + elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::min6; break; case 10: - elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::min12; + elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::min12; break; case 11: - elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::min30; + elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::min30; break; case 12: - elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::min60; + elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::min60; break; case 13: - elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::spare3; + elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::spare3; break; case 14: - elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::spare2; + elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::spare2; break; case 15: default: - elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::spare1; + elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::spare1; } // reportAmount @@ -3514,28 +3514,28 @@ RrcAsn1Header::DeserializeMeasConfig (LteRrcSap::MeasConfig * measConfig, Buffer switch (n) { case 0: - elem->reportConfigEutra.reportAmount = 1; + elem.reportConfigEutra.reportAmount = 1; break; case 1: - elem->reportConfigEutra.reportAmount = 2; + elem.reportConfigEutra.reportAmount = 2; break; case 2: - elem->reportConfigEutra.reportAmount = 4; + elem.reportConfigEutra.reportAmount = 4; break; case 3: - elem->reportConfigEutra.reportAmount = 8; + elem.reportConfigEutra.reportAmount = 8; break; case 4: - elem->reportConfigEutra.reportAmount = 16; + elem.reportConfigEutra.reportAmount = 16; break; case 5: - elem->reportConfigEutra.reportAmount = 32; + elem.reportConfigEutra.reportAmount = 32; break; case 6: - elem->reportConfigEutra.reportAmount = 64; + elem.reportConfigEutra.reportAmount = 64; break; default: - elem->reportConfigEutra.reportAmount = 0; + elem.reportConfigEutra.reportAmount = 0; } } @@ -3545,7 +3545,7 @@ RrcAsn1Header::DeserializeMeasConfig (LteRrcSap::MeasConfig * measConfig, Buffer // ... } - measConfig->reportConfigToAddModList.push_back (*elem); + measConfig->reportConfigToAddModList.push_back (elem); } } @@ -3570,20 +3570,20 @@ RrcAsn1Header::DeserializeMeasConfig (LteRrcSap::MeasConfig * measConfig, Buffer for (int i = 0; i < measIdToAddModListElems; i++) { - LteRrcSap::MeasIdToAddMod * elem = new LteRrcSap::MeasIdToAddMod (); + LteRrcSap::MeasIdToAddMod elem; bIterator = DeserializeSequence (&bitset0, false, bIterator); bIterator = DeserializeInteger (&n, 1, MAX_MEAS_ID, bIterator); - elem->measId = n; + elem.measId = n; bIterator = DeserializeInteger (&n, 1, MAX_OBJECT_ID, bIterator); - elem->measObjectId = n; + elem.measObjectId = n; bIterator = DeserializeInteger (&n, 1, MAX_REPORT_CONFIG_ID, bIterator); - elem->reportConfigId = n; + elem.reportConfigId = n; - measConfig->measIdToAddModList.push_back (*elem); + measConfig->measIdToAddModList.push_back (elem); } } @@ -4758,40 +4758,136 @@ RrcConnectionReconfigurationHeader::Print (std::ostream &os) const os << std::endl; } - if (!m_measConfig.measObjectToAddModList.empty ()) - { - os << " measObjectToAddMod: " << std::endl; - std::list auxList = m_measConfig.measObjectToAddModList; - std::list::iterator it = auxList.begin (); - for (; it != auxList.end (); it++) - { - os << " measObjectId: " << (int)it->measObjectId << std::endl; - os << " carrierFreq: " << (int)it->measObjectEutra.carrierFreq << std::endl; - os << " allowedMeasBandwidth: " << (int)it->measObjectEutra.allowedMeasBandwidth << std::endl; - os << " presenceAntennaPort1: " << it->measObjectEutra.presenceAntennaPort1 << std::endl; - os << " neighCellConfig: " << (int) it->measObjectEutra.neighCellConfig << std::endl; - os << " offsetFreq: " << (int)it->measObjectEutra.offsetFreq << std::endl; - /* os << " measObjectId: " << it->measObjectEutra.cellsToRemoveList.push_back (5); - os << " measObjectId: " << it->measObjectEutra.cellsToRemoveList.push_back (2);*/ - - if (!it->measObjectEutra.blackCellsToRemoveList.empty ()) + if (!m_measConfig.measObjectToAddModList.empty ()) { - os << " blackCellsToRemoveList: "; - std::list auxList = it->measObjectEutra.blackCellsToRemoveList; - std::list::iterator it = auxList.begin (); + os << " measObjectToAddMod: " << std::endl; + std::list auxList = m_measConfig.measObjectToAddModList; + std::list::iterator it = auxList.begin (); for (; it != auxList.end (); it++) { - os << (int) *it << ", "; - } - os << std::endl; - } - - os << " haveCellForWhichToReportCGI: " << it->measObjectEutra.haveCellForWhichToReportCGI << std::endl; - os << " cellForWhichToReportCGI: " << (int)it->measObjectEutra.cellForWhichToReportCGI << std::endl; - os << " ------------- " << std::endl; - } + os << " measObjectId: " << (int)it->measObjectId << std::endl; + os << " carrierFreq: " << (int)it->measObjectEutra.carrierFreq << std::endl; + os << " allowedMeasBandwidth: " << (int)it->measObjectEutra.allowedMeasBandwidth << std::endl; + os << " presenceAntennaPort1: " << it->measObjectEutra.presenceAntennaPort1 << std::endl; + os << " neighCellConfig: " << (int) it->measObjectEutra.neighCellConfig << std::endl; + os << " offsetFreq: " << (int)it->measObjectEutra.offsetFreq << std::endl; - } + + if (!it->measObjectEutra.cellsToRemoveList.empty ()) + { + os << " cellsToRemoveList: "; + std::list auxList = it->measObjectEutra.cellsToRemoveList; + std::list::iterator it = auxList.begin (); + for (; it != auxList.end (); it++) + { + os << (int) *it << ", "; + } + os << std::endl; + } + + if (!it->measObjectEutra.blackCellsToRemoveList.empty ()) + { + os << " blackCellsToRemoveList: "; + std::list auxList = it->measObjectEutra.blackCellsToRemoveList; + std::list::iterator it = auxList.begin (); + for (; it != auxList.end (); it++) + { + os << (int) *it << ", "; + } + os << std::endl; + } + + if (!it->measObjectEutra.cellsToAddModList.empty ()) + { + os << " cellsToAddModList: " << std::endl; + std::list auxList = it->measObjectEutra.cellsToAddModList; + std::list::iterator it = auxList.begin (); + for (; it != auxList.end (); it++) + { + os << " cellIndex: " << (int)it->cellIndex << std::endl; + os << " physCellId: " << (int)it->physCellId << std::endl; + os << " cellIndividualOffset: " << (int)it->cellIndividualOffset << std::endl; + os << " ------ " << std::endl; + } + } + + if (!it->measObjectEutra.blackCellsToAddModList.empty ()) + { + os << " blackCellsToAddModList: " << std::endl; + std::list auxList = it->measObjectEutra.blackCellsToAddModList; + std::list::iterator it = auxList.begin (); + for (; it != auxList.end (); it++) + { + os << " cellIndex: " << (int)it->cellIndex << std::endl; + os << " physCellIdRange.start: " << (int)it->physCellIdRange.start << std::endl; + os << " physCellIdRange.haveRange: " << it->physCellIdRange.haveRange << std::endl; + os << " physCellIdRange.range: " << (int)it->physCellIdRange.range << std::endl; + os << " ------ " << std::endl; + } + } + + os << " haveCellForWhichToReportCGI: " << it->measObjectEutra.haveCellForWhichToReportCGI << std::endl; + os << " cellForWhichToReportCGI: " << (int)it->measObjectEutra.cellForWhichToReportCGI << std::endl; + os << " ------------- " << std::endl; + } + + } + + if (!m_measConfig.reportConfigToAddModList.empty ()) + { + os << " reportConfigToAddModList: " << std::endl; + std::list auxList = m_measConfig.reportConfigToAddModList; + std::list::iterator it = auxList.begin (); + for (; it != auxList.end (); it++) + { + os << " reportConfigId: " << (int)it->reportConfigId << std::endl; + os << " reportConfigEutra.triggerType " << (int)it->reportConfigEutra.triggerType << std::endl; + if (it->reportConfigEutra.triggerType == LteRrcSap::ReportConfigEutra::event) + { + os << " reportConfigEutra.eventId " << (int)it->reportConfigEutra.eventId << std::endl; + if (it->reportConfigEutra.eventId == LteRrcSap::ReportConfigEutra::eventA3) + { + os << " reportConfigEutra.reportOnLeave " << (int)it->reportConfigEutra.reportOnLeave << std::endl; + os << " reportConfigEutra.a3Offset " << (int)it->reportConfigEutra.a3Offset << std::endl; + } + else + { + os << " reportConfigEutra.threshold1.choice " << (int)it->reportConfigEutra.threshold1.choice << std::endl; + os << " reportConfigEutra.threshold1.range " << (int)it->reportConfigEutra.threshold1.range << std::endl; + if (it->reportConfigEutra.eventId == LteRrcSap::ReportConfigEutra::eventA5) + { + os << " reportConfigEutra.threshold2.choice " << (int)it->reportConfigEutra.threshold2.choice << std::endl; + os << " reportConfigEutra.threshold2.range " << (int)it->reportConfigEutra.threshold2.range << std::endl; + } + } + os << " reportConfigEutra.hysteresis " << (int)it->reportConfigEutra.hysteresis << std::endl; + os << " reportConfigEutra.timeToTrigger " << (int)it->reportConfigEutra.timeToTrigger << std::endl; + } + else + { + os << " reportConfigEutra.purpose " << (int)it->reportConfigEutra.purpose << std::endl; + } + os << " reportConfigEutra.triggerQuantity " << (int)it->reportConfigEutra.triggerQuantity << std::endl; + os << " reportConfigEutra.reportQuantity " << (int)it->reportConfigEutra.reportQuantity << std::endl; + os << " reportConfigEutra.maxReportCells " << (int)it->reportConfigEutra.maxReportCells << std::endl; + os << " reportConfigEutra.reportInterval " << (int)it->reportConfigEutra.reportInterval << std::endl; + os << " reportConfigEutra.reportAmount " << (int)it->reportConfigEutra.reportAmount << std::endl; + } + } + + if (!m_measConfig.measIdToAddModList.empty ()) + { + os << " measIdToAddModList: " << std::endl; + std::list auxList = m_measConfig.measIdToAddModList; + std::list::iterator it = auxList.begin (); + for (; it != auxList.end (); it++) + { + os << " measId: " << (int)it->measId << std::endl; + os << " measObjectId: " << (int)it->measObjectId << std::endl; + os << " reportConfigId: " << (int)it->reportConfigId << std::endl; + os << " ------ " << std::endl; + } + } os << " haveQuantityConfig: " << m_measConfig.haveQuantityConfig << std::endl; if (m_measConfig.haveQuantityConfig) diff --git a/src/lte/test/test-asn1-encoding.cc b/src/lte/test/test-asn1-encoding.cc index cdbbbcf7a..b70314b75 100644 --- a/src/lte/test/test-asn1-encoding.cc +++ b/src/lte/test/test-asn1-encoding.cc @@ -481,8 +481,8 @@ RrcConnectionReconfigurationTestCase::DoRun (void) msg.measConfig.measIdToRemoveList.push_back (4); msg.measConfig.measIdToRemoveList.push_back (18); - - // TODO: Test the following: + + // Set measObjectToAddModList LteRrcSap::MeasObjectToAddMod measObjectToAddMod; measObjectToAddMod.measObjectId = 3; measObjectToAddMod.measObjectEutra.carrierFreq = 21; @@ -495,16 +495,50 @@ RrcConnectionReconfigurationTestCase::DoRun (void) measObjectToAddMod.measObjectEutra.blackCellsToRemoveList.push_back (1); measObjectToAddMod.measObjectEutra.haveCellForWhichToReportCGI = true; measObjectToAddMod.measObjectEutra.cellForWhichToReportCGI = 250; + LteRrcSap::CellsToAddMod cellsToAddMod; + cellsToAddMod.cellIndex = 20; + cellsToAddMod.physCellId = 14; + cellsToAddMod.cellIndividualOffset = 22; + measObjectToAddMod.measObjectEutra.cellsToAddModList.push_back (cellsToAddMod); + LteRrcSap::BlackCellsToAddMod blackCellsToAddMod; + blackCellsToAddMod.cellIndex = 18; + blackCellsToAddMod.physCellIdRange.start = 128; + blackCellsToAddMod.physCellIdRange.haveRange = true; + blackCellsToAddMod.physCellIdRange.range = 128; + measObjectToAddMod.measObjectEutra.blackCellsToAddModList.push_back (blackCellsToAddMod); + msg.measConfig.measObjectToAddModList.push_back (measObjectToAddMod); + // Set reportConfigToAddModList + LteRrcSap::ReportConfigToAddMod reportConfigToAddMod; + reportConfigToAddMod.reportConfigId = 22; + reportConfigToAddMod.reportConfigEutra.triggerType = LteRrcSap::ReportConfigEutra::event; + reportConfigToAddMod.reportConfigEutra.eventId = LteRrcSap::ReportConfigEutra::eventA2; + reportConfigToAddMod.reportConfigEutra.threshold1.choice = LteRrcSap::ThresholdEutra::thresholdRsrp; + reportConfigToAddMod.reportConfigEutra.threshold1.range = 15; + reportConfigToAddMod.reportConfigEutra.threshold2.choice = LteRrcSap::ThresholdEutra::thresholdRsrq; + reportConfigToAddMod.reportConfigEutra.threshold2.range = 10; + reportConfigToAddMod.reportConfigEutra.reportOnLeave = true; + reportConfigToAddMod.reportConfigEutra.a3Offset = -25; + reportConfigToAddMod.reportConfigEutra.hysteresis = 18; + reportConfigToAddMod.reportConfigEutra.timeToTrigger = 100; + reportConfigToAddMod.reportConfigEutra.purpose = LteRrcSap::ReportConfigEutra::reportStrongestCells; + reportConfigToAddMod.reportConfigEutra.triggerQuantity = LteRrcSap::ReportConfigEutra::rsrq; + reportConfigToAddMod.reportConfigEutra.reportQuantity = LteRrcSap::ReportConfigEutra::sameAsTriggerQuantity; + reportConfigToAddMod.reportConfigEutra.maxReportCells = 5; + reportConfigToAddMod.reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::min60; + reportConfigToAddMod.reportConfigEutra.reportAmount = 16; + msg.measConfig.reportConfigToAddModList.push_back (reportConfigToAddMod); -// std::list cellsToAddModList; -// std::list blackCellsToAddModList; - // std::list reportConfigToAddModList; - // std::list measIdToAddModList; - - //msg.measConfig.measObjectToAddModList.push_back (measObjectToAddMod); - - + // Set measIdToAddModList + LteRrcSap::MeasIdToAddMod measIdToAddMod,measIdToAddMod2; + measIdToAddMod.measId = 7; + measIdToAddMod.measObjectId = 6; + measIdToAddMod.reportConfigId = 5; + measIdToAddMod2.measId = 4; + measIdToAddMod2.measObjectId = 8; + measIdToAddMod2.reportConfigId = 12; + msg.measConfig.measIdToAddModList.push_back (measIdToAddMod); + msg.measConfig.measIdToAddModList.push_back (measIdToAddMod2); msg.haveMobilityControlInfo = true; msg.mobilityControlInfo.targetPhysCellId = 4;