--- a/src/lte/model/lte-rrc-header.cc Fri Apr 05 16:39:16 2013 +0200
+++ b/src/lte/model/lte-rrc-header.cc Fri Apr 05 16:50:37 2013 +0200
@@ -856,6 +856,932 @@
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<uint8_t>::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<LteRrcSap::MeasObjectToAddMod>::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<uint8_t>::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<LteRrcSap::CellsToAddMod>::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<uint8_t>::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<LteRrcSap::BlackCellsToAddMod>::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<uint8_t>::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<LteRrcSap::ReportConfigToAddMod>::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<uint8_t>::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<LteRrcSap::MeasIdToAddMod>::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)
{
@@ -1152,11 +2078,11 @@
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;
}
@@ -2091,6 +3017,839 @@
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
@@ -2655,13 +4414,9 @@
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)
@@ -2809,55 +4564,7 @@
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];
@@ -3014,6 +4721,76 @@
{
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<uint8_t> auxList = m_measConfig.measObjectToRemoveList;
+ std::list<uint8_t>::iterator it = auxList.begin ();
+ for (; it != auxList.end (); it++)
+ {
+ os << (int) *it << ", ";
+ }
+ os << std::endl;
+ }
+ if (!m_measConfig.reportConfigToRemoveList.empty ())
+ {
+ os << " reportConfigToRemoveList: ";
+ std::list<uint8_t> auxList = m_measConfig.reportConfigToRemoveList;
+ std::list<uint8_t>::iterator it = auxList.begin ();
+ for (; it != auxList.end (); it++)
+ {
+ os << (int) *it << ", ";
+ }
+ os << std::endl;
+ }
+ if (!m_measConfig.measIdToRemoveList.empty ())
+ {
+ os << " measIdToRemoveList: ";
+ std::list<uint8_t> auxList = m_measConfig.measIdToRemoveList;
+ std::list<uint8_t>::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)
{
@@ -3187,9 +4964,7 @@
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);
@@ -3278,53 +5053,7 @@
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);