A Discrete-Event Network Simulator
API
Loading...
Searching...
No Matches
lte-rrc-header.cc
Go to the documentation of this file.
1/*
2 * Copyright (c) 2012 Centre Tecnologic de Telecomunicacions de Catalunya (CTTC)
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 as
6 * published by the Free Software Foundation;
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License
14 * along with this program; if not, write to the Free Software
15 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16 *
17 * Author: Lluis Parcerisa <lparcerisa@cttc.cat>
18 * Modified by:
19 * Danilo Abrignani <danilo.abrignani@unibo.it> (Carrier Aggregation - GSoC 2015)
20 * Biljana Bojovic <biljana.bojovic@cttc.es> (Carrier Aggregation)
21 */
22
23#include "lte-rrc-header.h"
24
25#include "ns3/log.h"
26
27#include <sstream>
28#include <stdio.h>
29
30#define MAX_DRB 11 // According to section 6.4 3GPP TS 36.331
31#define MAX_EARFCN 262143
32#define MAX_RAT_CAPABILITIES 8
33#define MAX_SI_MESSAGE 32
34#define MAX_SIB 32
35
36#define MAX_REPORT_CONFIG_ID 32
37#define MAX_OBJECT_ID 32
38#define MAX_MEAS_ID 32
39#define MAX_CELL_MEAS 32
40#define MAX_CELL_REPORT 8
41
42#define MAX_SCELL_REPORT 5
43#define MAX_SCELL_CONF 5
44
45namespace ns3
46{
47
48NS_LOG_COMPONENT_DEFINE("RrcHeader");
49
50//////////////////// RrcAsn1Header class ///////////////////////////////
52{
53}
54
57{
58 static TypeId tid = TypeId("ns3::RrcAsn1Header").SetParent<Header>().SetGroupName("Lte");
59 return tid;
60}
61
64{
65 return GetTypeId();
66}
67
68int
70{
71 return m_messageType;
72}
73
74int
75RrcAsn1Header::BandwidthToEnum(uint16_t bandwidth) const
76{
77 int n;
78 switch (bandwidth)
79 {
80 case 6:
81 n = 0;
82 break;
83 case 15:
84 n = 1;
85 break;
86 case 25:
87 n = 2;
88 break;
89 case 50:
90 n = 3;
91 break;
92 case 75:
93 n = 4;
94 break;
95 case 100:
96 n = 5;
97 break;
98 default:
99 NS_FATAL_ERROR("Wrong bandwidth: " << bandwidth);
100 }
101 return n;
102}
103
104uint16_t
106{
107 uint16_t bw;
108 switch (n)
109 {
110 case 0:
111 bw = 6;
112 break;
113 case 1:
114 bw = 15;
115 break;
116 case 2:
117 bw = 25;
118 break;
119 case 3:
120 bw = 50;
121 break;
122 case 4:
123 bw = 75;
124 break;
125 case 5:
126 bw = 100;
127 break;
128 default:
129 NS_FATAL_ERROR("Wrong enum value for bandwidth: " << n);
130 }
131 return bw;
132}
133
134void
135RrcAsn1Header::SerializeDrbToAddModList(std::list<LteRrcSap::DrbToAddMod> drbToAddModList) const
136{
137 // Serialize DRB-ToAddModList sequence-of
138 SerializeSequenceOf(drbToAddModList.size(), MAX_DRB, 1);
139
140 // Serialize the elements in the sequence-of list
141 auto it = drbToAddModList.begin();
142 for (; it != drbToAddModList.end(); it++)
143 {
144 // Serialize DRB-ToAddMod sequence
145 // 5 optional fields. Extension marker is present.
146 std::bitset<5> drbToAddModListOptionalFieldsPresent = std::bitset<5>();
147 drbToAddModListOptionalFieldsPresent.set(4, true); // eps-BearerIdentity present
148 drbToAddModListOptionalFieldsPresent.set(3, false); // pdcp-Config not present
149 drbToAddModListOptionalFieldsPresent.set(2, true); // rlc-Config present
150 drbToAddModListOptionalFieldsPresent.set(1, true); // logicalChannelIdentity present
151 drbToAddModListOptionalFieldsPresent.set(0, true); // logicalChannelConfig present
152 SerializeSequence(drbToAddModListOptionalFieldsPresent, true);
153
154 // Serialize eps-BearerIdentity::=INTEGER (0..15)
155 SerializeInteger(it->epsBearerIdentity, 0, 15);
156
157 // Serialize drb-Identity ::= INTEGER (1..32)
158 SerializeInteger(it->drbIdentity, 1, 32);
159
160 switch (it->rlcConfig.choice)
161 {
163 // Serialize rlc-Config choice
164 SerializeChoice(4, 1, true);
165
166 // Serialize UL-UM-RLC
167 SerializeSequence(std::bitset<0>(), false);
168 SerializeEnum(2, 0); // sn-FieldLength
169
170 // Serialize DL-UM-RLC
171 SerializeSequence(std::bitset<0>(), false);
172 SerializeEnum(2, 0); // sn-FieldLength
173 SerializeEnum(32, 0); // t-Reordering
174 break;
175
177 // Serialize rlc-Config choice
178 SerializeChoice(4, 2, true);
179
180 // Serialize UL-UM-RLC
181 SerializeSequence(std::bitset<0>(), false);
182 SerializeEnum(2, 0); // sn-FieldLength
183 break;
184
186 // Serialize rlc-Config choice
187 SerializeChoice(4, 3, true);
188
189 // Serialize DL-UM-RLC
190 SerializeSequence(std::bitset<0>(), false);
191 SerializeEnum(2, 0); // sn-FieldLength
192 SerializeEnum(32, 0); // t-Reordering
193 break;
194
196 default:
197 // Serialize rlc-Config choice
198 SerializeChoice(4, 0, true);
199
200 // Serialize UL-AM-RLC
201 SerializeSequence(std::bitset<0>(), false);
202 SerializeEnum(64, 0); // t-PollRetransmit
203 SerializeEnum(8, 0); // pollPDU
204 SerializeEnum(16, 0); // pollByte
205 SerializeEnum(8, 0); // maxRetxThreshold
206
207 // Serialize DL-AM-RLC
208 SerializeSequence(std::bitset<0>(), false);
209 SerializeEnum(32, 0); // t-Reordering
210 SerializeEnum(64, 0); // t-StatusProhibit
211 break;
212 }
213
214 // Serialize logicalChannelIdentity ::=INTEGER (3..10)
215 SerializeInteger(it->logicalChannelIdentity, 3, 10);
216
217 // Serialize logicalChannelConfig
218 SerializeLogicalChannelConfig(it->logicalChannelConfig);
219 }
220}
221
222void
223RrcAsn1Header::SerializeSrbToAddModList(std::list<LteRrcSap::SrbToAddMod> srbToAddModList) const
224{
225 // Serialize SRB-ToAddModList ::= SEQUENCE (SIZE (1..2)) OF SRB-ToAddMod
226 SerializeSequenceOf(srbToAddModList.size(), 2, 1);
227
228 // Serialize the elements in the sequence-of list
229 auto it = srbToAddModList.begin();
230 for (; it != srbToAddModList.end(); it++)
231 {
232 // Serialize SRB-ToAddMod sequence
233 // 2 optional fields. Extension marker is present.
234 std::bitset<2> srbToAddModListOptionalFieldsPresent = std::bitset<2>();
235 srbToAddModListOptionalFieldsPresent.set(1, false); // rlc-Config not present
236 srbToAddModListOptionalFieldsPresent.set(0, true); // logicalChannelConfig present
237 SerializeSequence(srbToAddModListOptionalFieldsPresent, true);
238
239 // Serialize srb-Identity ::= INTEGER (1..2)
240 SerializeInteger(it->srbIdentity, 1, 2);
241
242 // Serialize logicalChannelConfig choice
243 // 2 options, selected option 0 (var "explicitValue", of type LogicalChannelConfig)
244 SerializeChoice(2, 0, false);
245
246 // Serialize LogicalChannelConfig
247 SerializeLogicalChannelConfig(it->logicalChannelConfig);
248 }
249}
250
251void
253 LteRrcSap::LogicalChannelConfig logicalChannelConfig) const
254{
255 // Serialize LogicalChannelConfig sequence
256 // 1 optional field (ul-SpecificParameters), which is present. Extension marker present.
257 SerializeSequence(std::bitset<1>(1), true);
258
259 // Serialize ul-SpecificParameters sequence
260 // 1 optional field (logicalChannelGroup), which is present. No extension marker.
261 SerializeSequence(std::bitset<1>(1), false);
262
263 // Serialize priority ::= INTEGER (1..16)
264 SerializeInteger(logicalChannelConfig.priority, 1, 16);
265
266 // Serialize prioritisedBitRate
267 int prioritizedBitRate;
268 switch (logicalChannelConfig.prioritizedBitRateKbps)
269 {
270 case 0:
271 prioritizedBitRate = 0;
272 break;
273 case 8:
274 prioritizedBitRate = 1;
275 break;
276 case 16:
277 prioritizedBitRate = 2;
278 break;
279 case 32:
280 prioritizedBitRate = 3;
281 break;
282 case 64:
283 prioritizedBitRate = 4;
284 break;
285 case 128:
286 prioritizedBitRate = 5;
287 break;
288 case 256:
289 prioritizedBitRate = 6;
290 break;
291 default:
292 prioritizedBitRate = 7; // Infinity
293 }
294 SerializeEnum(16, prioritizedBitRate);
295
296 // Serialize bucketSizeDuration
297 int bucketSizeDuration;
298 switch (logicalChannelConfig.bucketSizeDurationMs)
299 {
300 case 50:
301 bucketSizeDuration = 0;
302 break;
303 case 100:
304 bucketSizeDuration = 1;
305 break;
306 case 150:
307 bucketSizeDuration = 2;
308 break;
309 case 300:
310 bucketSizeDuration = 3;
311 break;
312 case 500:
313 bucketSizeDuration = 4;
314 break;
315 case 1000:
316 bucketSizeDuration = 5;
317 break;
318 default:
319 bucketSizeDuration = 5;
320 }
321 SerializeEnum(8, bucketSizeDuration);
322
323 // Serialize logicalChannelGroup ::= INTEGER (0..3)
324 SerializeInteger(logicalChannelConfig.logicalChannelGroup, 0, 3);
325}
326
327void
329 LteRrcSap::PhysicalConfigDedicated physicalConfigDedicated) const
330{
331 // Serialize PhysicalConfigDedicated Sequence
332 std::bitset<10> optionalFieldsPhysicalConfigDedicated;
333 optionalFieldsPhysicalConfigDedicated.set(
334 9,
335 physicalConfigDedicated.havePdschConfigDedicated); // pdsch-ConfigDedicated
336 optionalFieldsPhysicalConfigDedicated.set(8, false); // pucch-ConfigDedicated not present
337 optionalFieldsPhysicalConfigDedicated.set(7, false); // pusch-ConfigDedicated not present
338 optionalFieldsPhysicalConfigDedicated.set(6, false); // uplinkPowerControlDedicated not present
339 optionalFieldsPhysicalConfigDedicated.set(5, false); // tpc-PDCCH-ConfigPUCCH not present
340 optionalFieldsPhysicalConfigDedicated.set(4, false); // tpc-PDCCH-ConfigPUSCH not present
341 optionalFieldsPhysicalConfigDedicated.set(3, false); // cqi-ReportConfig not present
342 optionalFieldsPhysicalConfigDedicated.set(
343 2,
344 physicalConfigDedicated.haveSoundingRsUlConfigDedicated); // soundingRS-UL-ConfigDedicated
345 optionalFieldsPhysicalConfigDedicated.set(
346 1,
347 physicalConfigDedicated.haveAntennaInfoDedicated); // antennaInfo
348 optionalFieldsPhysicalConfigDedicated.set(0, false); // schedulingRequestConfig not present
349 SerializeSequence(optionalFieldsPhysicalConfigDedicated, true);
350
351 if (physicalConfigDedicated.havePdschConfigDedicated)
352 {
353 // Serialize Pdsch-ConfigDedicated Sequence:
354 // 0 optional / default fields, no extension marker.
355 SerializeSequence(std::bitset<0>(), false);
356
357 // Serialize p-a
358 // Assuming the value in the struct is the enum index
359 SerializeEnum(8, physicalConfigDedicated.pdschConfigDedicated.pa);
360
361 // Serialize release
363 }
364
365 if (physicalConfigDedicated.haveSoundingRsUlConfigDedicated)
366 {
367 // Serialize SoundingRS-UL-ConfigDedicated choice:
368 switch (physicalConfigDedicated.soundingRsUlConfigDedicated.type)
369 {
371 SerializeChoice(2, 0, false);
373 break;
374
376 default:
377 // 2 options, selected: 1 (setup)
378 SerializeChoice(2, 1, false);
379
380 // Serialize setup sequence
381 // 0 optional / default fields, no extension marker.
382 SerializeSequence(std::bitset<0>(), false);
383
384 // Serialize srs-Bandwidth
385 SerializeEnum(4, physicalConfigDedicated.soundingRsUlConfigDedicated.srsBandwidth);
386
387 // Serialize srs-HoppingBandwidth
388 SerializeEnum(4, 0);
389
390 // Serialize freqDomainPosition
391 SerializeInteger(0, 0, 23);
392
393 // Serialize duration
394 SerializeBoolean(false);
395
396 // Serialize srs-ConfigIndex
398 0,
399 1023);
400
401 // Serialize transmissionComb
402 SerializeInteger(0, 0, 1);
403
404 // Serialize cyclicShift
405 SerializeEnum(8, 0);
406
407 break;
408 }
409 }
410
411 if (physicalConfigDedicated.haveAntennaInfoDedicated)
412 {
413 // Serialize antennaInfo choice
414 // 2 options. Selected: 0 ("explicitValue" of type "AntennaInfoDedicated")
415 SerializeChoice(2, 0, false);
416
417 // Serialize AntennaInfoDedicated sequence
418 // 1 optional parameter, not present. No extension marker.
419 SerializeSequence(std::bitset<1>(0), false);
420
421 // Serialize transmissionMode
422 // Assuming the value in the struct is the enum index
423 SerializeEnum(8, physicalConfigDedicated.antennaInfo.transmissionMode);
424
425 // Serialize ue-TransmitAntennaSelection choice
426 SerializeChoice(2, 0, false);
427
428 // Serialize release
430 }
431}
432
433void
435 LteRrcSap::RadioResourceConfigDedicated radioResourceConfigDedicated) const
436{
437 bool isSrbToAddModListPresent = !radioResourceConfigDedicated.srbToAddModList.empty();
438 bool isDrbToAddModListPresent = !radioResourceConfigDedicated.drbToAddModList.empty();
439 bool isDrbToReleaseListPresent = !radioResourceConfigDedicated.drbToReleaseList.empty();
440
441 // 6 optional fields. Extension marker is present.
442 std::bitset<6> optionalFieldsPresent = std::bitset<6>();
443 optionalFieldsPresent.set(5, isSrbToAddModListPresent); // srb-ToAddModList present
444 optionalFieldsPresent.set(4, isDrbToAddModListPresent); // drb-ToAddModList present
445 optionalFieldsPresent.set(3, isDrbToReleaseListPresent); // drb-ToReleaseList present
446 optionalFieldsPresent.set(2, false); // mac-MainConfig not present
447 optionalFieldsPresent.set(1, false); // sps-Config not present
448 optionalFieldsPresent.set(0, radioResourceConfigDedicated.havePhysicalConfigDedicated);
449 SerializeSequence(optionalFieldsPresent, true);
450
451 // Serialize srbToAddModList
452 if (isSrbToAddModListPresent)
453 {
454 SerializeSrbToAddModList(radioResourceConfigDedicated.srbToAddModList);
455 }
456
457 // Serialize drbToAddModList
458 if (isDrbToAddModListPresent)
459 {
460 SerializeDrbToAddModList(radioResourceConfigDedicated.drbToAddModList);
461 }
462
463 // Serialize drbToReleaseList
464 if (isDrbToReleaseListPresent)
465 {
466 SerializeSequenceOf(radioResourceConfigDedicated.drbToReleaseList.size(), MAX_DRB, 1);
467 auto it = radioResourceConfigDedicated.drbToReleaseList.begin();
468 for (; it != radioResourceConfigDedicated.drbToReleaseList.end(); it++)
469 {
470 // DRB-Identity ::= INTEGER (1..32)
471 SerializeInteger(*it, 1, 32);
472 }
473 }
474
475 if (radioResourceConfigDedicated.havePhysicalConfigDedicated)
476 {
477 SerializePhysicalConfigDedicated(radioResourceConfigDedicated.physicalConfigDedicated);
478 }
479}
480
481void
483 LteRrcSap::SystemInformationBlockType1 systemInformationBlockType1) const
484{
485 // 3 optional fields, no extension marker.
486 std::bitset<3> sysInfoBlk1Opts;
487 sysInfoBlk1Opts.set(2, false); // p-Max absent
488 sysInfoBlk1Opts.set(1, false); // tdd-Config absent
489 sysInfoBlk1Opts.set(0, false); // nonCriticalExtension absent
490 SerializeSequence(sysInfoBlk1Opts, false);
491
492 // Serialize cellAccessRelatedInfo
493 // 1 optional field (csgIdentity) which is present, no extension marker.
494 SerializeSequence(std::bitset<1>(1), false);
495
496 // Serialize plmn-IdentityList
497 SerializeSequenceOf(1, 6, 1);
498
499 // PLMN-IdentityInfo
500 SerializeSequence(std::bitset<0>(), false);
501
503 systemInformationBlockType1.cellAccessRelatedInfo.plmnIdentityInfo.plmnIdentity);
504
505 // Serialize trackingAreaCode
506 SerializeBitstring(std::bitset<16>(0));
507 // Serialize cellIdentity
509 std::bitset<28>(systemInformationBlockType1.cellAccessRelatedInfo.cellIdentity));
510 // Serialize cellBarred
511 SerializeEnum(2, 0);
512 // Serialize intraFreqReselection
513 SerializeEnum(2, 0);
514 // Serialize csg-Indication
515 SerializeBoolean(systemInformationBlockType1.cellAccessRelatedInfo.csgIndication);
516 // Serialize csg-Identity
518 std::bitset<27>(systemInformationBlockType1.cellAccessRelatedInfo.csgIdentity));
519
520 // Serialize cellSelectionInfo
521 SerializeSequence(std::bitset<1>(0), false);
522 // Serialize q-RxLevMin
523 SerializeInteger(-50, -70, -22);
524
525 // Serialize freqBandIndicator
526 SerializeInteger(1, 1, 64);
527
528 // Serialize schedulingInfoList
530 // SchedulingInfo
531 SerializeSequence(std::bitset<0>(), false);
532 // si-Periodicity
533 SerializeEnum(7, 0);
534 // sib-MappingInfo
535 SerializeSequenceOf(0, MAX_SIB - 1, 0);
536
537 // Serialize si-WindowLength
538 SerializeEnum(7, 0);
539
540 // Serialize systemInfoValueTag
541 SerializeInteger(0, 0, 31);
542}
543
544void
546 LteRrcSap::RadioResourceConfigCommon radioResourceConfigCommon) const
547{
548 // 9 optional fields. Extension marker yes.
549 std::bitset<9> rrCfgCmmOpts;
550 rrCfgCmmOpts.set(8, true); // rach-ConfigCommon is present
551 rrCfgCmmOpts.set(7, false); // pdsch-ConfigCommon not present
552 rrCfgCmmOpts.set(6, false); // phich-Config not present
553 rrCfgCmmOpts.set(5, false); // pucch-ConfigCommon not present
554 rrCfgCmmOpts.set(4, false); // soundingRS-UL-ConfigCommon not present
555 rrCfgCmmOpts.set(3, false); // uplinkPowerControlCommon not present
556 rrCfgCmmOpts.set(2, false); // antennaInfoCommon not present
557 rrCfgCmmOpts.set(1, false); // p-Max not present
558 rrCfgCmmOpts.set(0, false); // tdd-Config not present
559
560 SerializeSequence(rrCfgCmmOpts, true);
561
562 if (rrCfgCmmOpts[8])
563 {
564 // Serialize RACH-ConfigCommon
565 SerializeRachConfigCommon(radioResourceConfigCommon.rachConfigCommon);
566 }
567
568 // Serialize PRACH-Config
569 // 1 optional, 0 extension marker.
570 SerializeSequence(std::bitset<1>(0), false);
571
572 // Serialize PRACH-Config rootSequenceIndex
573 SerializeInteger(0, 0, 1023);
574
575 // Serialize PUSCH-ConfigCommon
576 SerializeSequence(std::bitset<0>(), false);
577
578 // Serialize pusch-ConfigBasic
579 SerializeSequence(std::bitset<0>(), false);
580 SerializeInteger(1, 1, 4);
581 SerializeEnum(2, 0);
582 SerializeInteger(0, 0, 98);
583 SerializeBoolean(false);
584
585 // Serialize UL-ReferenceSignalsPUSCH
586 SerializeSequence(std::bitset<0>(), false);
587 SerializeBoolean(false);
588 SerializeInteger(0, 0, 29);
589 SerializeBoolean(false);
590 SerializeInteger(4, 0, 7);
591
592 // Serialize UL-CyclicPrefixLength
593 SerializeEnum(2, 0);
594}
595
596void
598 LteRrcSap::RadioResourceConfigCommonSib radioResourceConfigCommonSib) const
599{
600 SerializeSequence(std::bitset<0>(0), true);
601
602 // rach-ConfigCommon
603 SerializeRachConfigCommon(radioResourceConfigCommonSib.rachConfigCommon);
604
605 // bcch-Config
606 SerializeSequence(std::bitset<0>(0), false);
607 SerializeEnum(4, 0); // modificationPeriodCoeff
608 // pcch-Config
609 SerializeSequence(std::bitset<0>(0), false);
610 SerializeEnum(4, 0); // defaultPagingCycle
611 SerializeEnum(8, 0); // nB
612 // prach-Config
613 SerializeSequence(std::bitset<1>(0), false);
614 SerializeInteger(0, 0, 1023); // rootSequenceIndex
615 // pdsch-ConfigCommon
616 SerializeSequence(std::bitset<0>(0), false);
617 SerializeInteger(0, -60, 50); // referenceSignalPower
618 SerializeInteger(0, 0, 3); // p-b
619 // pusch-ConfigCommon
620 SerializeSequence(std::bitset<0>(0), false);
621 SerializeSequence(std::bitset<0>(0), false); // pusch-ConfigBasic
622 SerializeInteger(1, 1, 4); // n-SB
623 SerializeEnum(2, 0); // hoppingMode
624 SerializeInteger(0, 0, 98); // pusch-HoppingOffset
625 SerializeBoolean(false); // enable64QAM
626 SerializeSequence(std::bitset<0>(0), false); // UL-ReferenceSignalsPUSCH
627 SerializeBoolean(false); // groupHoppingEnabled
628 SerializeInteger(0, 0, 29); // groupAssignmentPUSCH
629 SerializeBoolean(false); // sequenceHoppingEnabled
630 SerializeInteger(0, 0, 7); // cyclicShift
631 // pucch-ConfigCommon
632 SerializeSequence(std::bitset<0>(0), false);
633 SerializeEnum(3, 0); // deltaPUCCH-Shift
634 SerializeInteger(0, 0, 98); // nRB-CQI
635 SerializeInteger(0, 0, 7); // nCS-AN
636 SerializeInteger(0, 0, 2047); // n1PUCCH-AN
637 // soundingRS-UL-ConfigCommon
638 SerializeChoice(2, 0, false);
639 SerializeNull(); // release
640 // uplinkPowerControlCommon
641 SerializeSequence(std::bitset<0>(0), false);
642 SerializeInteger(0, -126, 24); // p0-NominalPUSCH
643 SerializeEnum(8, 0); // alpha
644 SerializeInteger(-110, -127, -96); // p0-NominalPUCCH
645 SerializeSequence(std::bitset<0>(0), false); // deltaFList-PUCCH
646 SerializeEnum(3, 0); // deltaF-PUCCH-Format1
647 SerializeEnum(3, 0); // deltaF-PUCCH-Format1b
648 SerializeEnum(4, 0); // deltaF-PUCCH-Format2
649 SerializeEnum(3, 0); // deltaF-PUCCH-Format2a
650 SerializeEnum(3, 0); // deltaF-PUCCH-Format2b
651 SerializeInteger(0, -1, 6);
652 // ul-CyclicPrefixLength
653 SerializeEnum(2, 0);
654}
655
656void
658 LteRrcSap::SystemInformationBlockType2 systemInformationBlockType2) const
659{
660 SerializeSequence(std::bitset<2>(0), true);
661
662 // RadioResourceConfigCommonSib
664
665 // ue-TimersAndConstants
666 SerializeSequence(std::bitset<0>(0), true);
667 SerializeEnum(8, 0); // t300
668 SerializeEnum(8, 0); // t301
669 SerializeEnum(7, 0); // t310
670 SerializeEnum(8, 0); // n310
671 SerializeEnum(7, 0); // t311
672 SerializeEnum(8, 0); // n311
673
674 // freqInfo
675 SerializeSequence(std::bitset<2>(3), false);
676 SerializeInteger((int)systemInformationBlockType2.freqInfo.ulCarrierFreq, 0, MAX_EARFCN);
677 SerializeEnum(6, BandwidthToEnum(systemInformationBlockType2.freqInfo.ulBandwidth));
678
679 SerializeInteger(29, 1, 32); // additionalSpectrumEmission
680 // timeAlignmentTimerCommon
681 SerializeEnum(8, 0);
682}
683
684void
686{
687 // Watchdog: if list has 0 elements, set boolean to false
688 if (measResults.measResultListEutra.empty())
689 {
690 measResults.haveMeasResultNeighCells = false;
691 }
692
693 std::bitset<4> measResultOptional;
694 measResultOptional.set(3, measResults.haveMeasResultServFreqList);
695 measResultOptional.set(2, false); // LocationInfo-r10
696 measResultOptional.set(1, false); // MeasResultForECID-r9
697 measResultOptional.set(0, measResults.haveMeasResultNeighCells);
698 SerializeSequence(measResultOptional, true);
699
700 // Serialize measId
701 SerializeInteger(measResults.measId, 1, MAX_MEAS_ID);
702
703 // Serialize measResultPCell sequence
704 SerializeSequence(std::bitset<0>(0), false);
705
706 // Serialize rsrpResult
707 SerializeInteger(measResults.measResultPCell.rsrpResult, 0, 97);
708
709 // Serialize rsrqResult
710 SerializeInteger(measResults.measResultPCell.rsrqResult, 0, 34);
711
712 if (measResults.haveMeasResultNeighCells)
713 {
714 // Serialize Choice = 0 (MeasResultListEUTRA)
715 SerializeChoice(4, 0, false);
716
717 // Serialize measResultNeighCells
719
720 // serialize MeasResultEutra elements in the list
721 for (auto it = measResults.measResultListEutra.begin();
722 it != measResults.measResultListEutra.end();
723 it++)
724 {
725 SerializeSequence(std::bitset<1>(it->haveCgiInfo), false);
726
727 // Serialize PhysCellId
728 SerializeInteger(it->physCellId, 0, 503);
729
730 // Serialize CgiInfo
731 if (it->haveCgiInfo)
732 {
733 SerializeSequence(std::bitset<1>(it->cgiInfo.plmnIdentityList.size()), false);
734
735 // Serialize cellGlobalId
736 SerializeSequence(std::bitset<0>(0), false);
737 SerializePlmnIdentity(it->cgiInfo.plmnIdentity);
738 SerializeBitstring(std::bitset<28>(it->cgiInfo.cellIdentity));
739
740 // Serialize trackingAreaCode
741 SerializeBitstring(std::bitset<16>(it->cgiInfo.trackingAreaCode));
742
743 // Serialize plmn-IdentityList
744 if (!it->cgiInfo.plmnIdentityList.empty())
745 {
746 SerializeSequenceOf(it->cgiInfo.plmnIdentityList.size(), 5, 1);
747 for (auto it2 = it->cgiInfo.plmnIdentityList.begin();
748 it2 != it->cgiInfo.plmnIdentityList.end();
749 it2++)
750 {
752 }
753 }
754 }
755
756 // Serialize measResult
757 std::bitset<2> measResultFieldsPresent;
758 measResultFieldsPresent[1] = it->haveRsrpResult;
759 measResultFieldsPresent[0] = it->haveRsrqResult;
760 SerializeSequence(measResultFieldsPresent, true);
761
762 if (it->haveRsrpResult)
763 {
764 SerializeInteger(it->rsrpResult, 0, 97);
765 }
766
767 if (it->haveRsrqResult)
768 {
769 SerializeInteger(it->rsrqResult, 0, 34);
770 }
771 }
772 }
773
774 // measResultServFreqList-r10 serialization
775 if (measResults.haveMeasResultServFreqList)
776 {
777 // Serialize measResultServFreqList-r10
779 // serialize MeasResultServFreqList-r10 elements in the list
780 for (const auto& it : measResults.measResultServFreqList)
781 {
782 // Serialize MeasResultServFreq-r10
783 std::bitset<2> measResultServFreqPresent;
784 measResultServFreqPresent[0] = it.haveMeasResultSCell;
785 measResultServFreqPresent[1] = it.haveMeasResultBestNeighCell;
786 SerializeSequence(measResultServFreqPresent, true);
787
788 // Serialize servFreqId-r10
789 SerializeInteger(it.servFreqId, 0, 7);
790
791 if (it.haveMeasResultSCell)
792 {
793 // Serialize rsrpResultSCell-r10
794 SerializeInteger(it.measResultSCell.rsrpResult, 0, 97);
795
796 // Serialize rsrqResultSCell-r10
797 SerializeInteger(it.measResultSCell.rsrqResult, 0, 34);
798 }
799
800 if (it.haveMeasResultBestNeighCell)
801 {
802 // Serialize physCellId-r10
803 SerializeInteger(it.measResultBestNeighCell.physCellId, 0, 503);
804
805 // Serialize rsrpResultNCell-r10
806 SerializeInteger(it.measResultBestNeighCell.rsrpResult, 0, 97);
807
808 // Serialize rsrqResultNCell-r10
809 SerializeInteger(it.measResultBestNeighCell.rsrqResult, 0, 34);
810 }
811
812 NS_ASSERT(!it.haveMeasResultBestNeighCell); // Not implemented
813 }
814 }
815}
816
817void
819{
820 // plmn-Identity sequence, mcc is optional, no extension marker
821 SerializeSequence(std::bitset<1>(0), false);
822
823 // Serialize mnc
824 int nDig = (plmnId > 99) ? 3 : 2;
825
826 SerializeSequenceOf(nDig, 3, 2);
827 for (int i = nDig - 1; i >= 0; i--)
828 {
829 int n = floor(plmnId / pow(10, i));
830 SerializeInteger(n, 0, 9);
831 plmnId -= n * pow(10, i);
832 }
833
834 // cellReservedForOperatorUse
835 SerializeEnum(2, 0);
836}
837
838void
840{
841 // rach-ConfigCommon
842 SerializeSequence(std::bitset<0>(0), true);
843
844 // preambleInfo
845 SerializeSequence(std::bitset<1>(0), false);
846
847 // numberOfRA-Preambles
848 switch (rachConfigCommon.preambleInfo.numberOfRaPreambles)
849 {
850 case 4:
851 SerializeEnum(16, 0);
852 break;
853 case 8:
854 SerializeEnum(16, 1);
855 break;
856 case 12:
857 SerializeEnum(16, 2);
858 break;
859 case 16:
860 SerializeEnum(16, 3);
861 break;
862 case 20:
863 SerializeEnum(16, 4);
864 break;
865 case 24:
866 SerializeEnum(16, 5);
867 break;
868 case 28:
869 SerializeEnum(16, 6);
870 break;
871 case 32:
872 SerializeEnum(16, 7);
873 break;
874 case 36:
875 SerializeEnum(16, 8);
876 break;
877 case 40:
878 SerializeEnum(16, 9);
879 break;
880 case 44:
881 SerializeEnum(16, 10);
882 break;
883 case 48:
884 SerializeEnum(16, 11);
885 break;
886 case 52:
887 SerializeEnum(16, 12);
888 break;
889 case 56:
890 SerializeEnum(16, 13);
891 break;
892 case 60:
893 SerializeEnum(16, 14);
894 break;
895 case 64:
896 SerializeEnum(16, 15);
897 break;
898 default:
899 NS_FATAL_ERROR("Wrong numberOfRA-Preambles value");
900 }
901
902 SerializeSequence(std::bitset<0>(0), false); // powerRampingParameters
903 SerializeEnum(4, 0); // powerRampingStep
904 SerializeEnum(16, 0); // preambleInitialReceivedTargetPower
905 SerializeSequence(std::bitset<0>(0), false); // ra-SupervisionInfo
906
907 // preambleTransMax
908 switch (rachConfigCommon.raSupervisionInfo.preambleTransMax)
909 {
910 case 3:
911 SerializeEnum(11, 0);
912 break;
913 case 4:
914 SerializeEnum(11, 1);
915 break;
916 case 5:
917 SerializeEnum(11, 2);
918 break;
919 case 6:
920 SerializeEnum(11, 3);
921 break;
922 case 7:
923 SerializeEnum(11, 4);
924 break;
925 case 8:
926 SerializeEnum(11, 5);
927 break;
928 case 10:
929 SerializeEnum(11, 6);
930 break;
931 case 20:
932 SerializeEnum(11, 7);
933 break;
934 case 50:
935 SerializeEnum(11, 8);
936 break;
937 case 100:
938 SerializeEnum(11, 9);
939 break;
940 case 200:
941 SerializeEnum(11, 10);
942 break;
943 default:
944 SerializeEnum(11, 0);
945 }
946
947 // ra-ResponseWindowSize
948 switch (rachConfigCommon.raSupervisionInfo.raResponseWindowSize)
949 {
950 case 2:
951 SerializeEnum(8, 0);
952 break;
953 case 3:
954 SerializeEnum(8, 1);
955 break;
956 case 4:
957 SerializeEnum(8, 2);
958 break;
959 case 5:
960 SerializeEnum(8, 3);
961 break;
962 case 6:
963 SerializeEnum(8, 4);
964 break;
965 case 7:
966 SerializeEnum(8, 5);
967 break;
968 case 8:
969 SerializeEnum(8, 6);
970 break;
971 case 10:
972 SerializeEnum(8, 7);
973 break;
974 default:
975 SerializeEnum(8, 0);
976 }
977
978 SerializeEnum(8, 0); // mac-ContentionResolutionTimer
979 SerializeInteger(1, 1, 8); // maxHARQ-Msg3Tx
980
981 // connEstFailCount
982 switch (rachConfigCommon.txFailParam.connEstFailCount)
983 {
984 case 1:
985 SerializeEnum(8, 1);
986 break;
987 case 2:
988 SerializeEnum(8, 2);
989 break;
990 case 3:
991 SerializeEnum(8, 3);
992 break;
993 case 4:
994 SerializeEnum(8, 4);
995 break;
996 default:
997 SerializeEnum(8, 1);
998 }
999}
1000
1001void
1003{
1004 switch (qOffsetRange)
1005 {
1006 case -24:
1007 SerializeEnum(31, 0);
1008 break;
1009 case -22:
1010 SerializeEnum(31, 1);
1011 break;
1012 case -20:
1013 SerializeEnum(31, 2);
1014 break;
1015 case -18:
1016 SerializeEnum(31, 3);
1017 break;
1018 case -16:
1019 SerializeEnum(31, 4);
1020 break;
1021 case -14:
1022 SerializeEnum(31, 5);
1023 break;
1024 case -12:
1025 SerializeEnum(31, 6);
1026 break;
1027 case -10:
1028 SerializeEnum(31, 7);
1029 break;
1030 case -8:
1031 SerializeEnum(31, 8);
1032 break;
1033 case -6:
1034 SerializeEnum(31, 9);
1035 break;
1036 case -5:
1037 SerializeEnum(31, 10);
1038 break;
1039 case -4:
1040 SerializeEnum(31, 11);
1041 break;
1042 case -3:
1043 SerializeEnum(31, 12);
1044 break;
1045 case -2:
1046 SerializeEnum(31, 13);
1047 break;
1048 case -1:
1049 SerializeEnum(31, 14);
1050 break;
1051 case 0:
1052 SerializeEnum(31, 15);
1053 break;
1054 case 1:
1055 SerializeEnum(31, 16);
1056 break;
1057 case 2:
1058 SerializeEnum(31, 17);
1059 break;
1060 case 3:
1061 SerializeEnum(31, 18);
1062 break;
1063 case 4:
1064 SerializeEnum(31, 19);
1065 break;
1066 case 5:
1067 SerializeEnum(31, 20);
1068 break;
1069 case 6:
1070 SerializeEnum(31, 21);
1071 break;
1072 case 8:
1073 SerializeEnum(31, 22);
1074 break;
1075 case 10:
1076 SerializeEnum(31, 23);
1077 break;
1078 case 12:
1079 SerializeEnum(31, 24);
1080 break;
1081 case 14:
1082 SerializeEnum(31, 25);
1083 break;
1084 case 16:
1085 SerializeEnum(31, 26);
1086 break;
1087 case 18:
1088 SerializeEnum(31, 27);
1089 break;
1090 case 20:
1091 SerializeEnum(31, 28);
1092 break;
1093 case 22:
1094 SerializeEnum(31, 29);
1095 break;
1096 case 24:
1097 SerializeEnum(31, 30);
1098 break;
1099 default:
1100 SerializeEnum(31, 15);
1101 }
1102}
1103
1104void
1106{
1107 switch (thresholdEutra.choice)
1108 {
1110 SerializeChoice(2, 0, false);
1111 SerializeInteger(thresholdEutra.range, 0, 97);
1112 break;
1114 default:
1115 SerializeChoice(2, 1, false);
1116 SerializeInteger(thresholdEutra.range, 0, 34);
1117 }
1118}
1119
1120void
1122{
1123 // Serialize MeasConfig sequence
1124 // 11 optional fields, extension marker present
1125 std::bitset<11> measConfigOptional;
1126 measConfigOptional.set(10, !measConfig.measObjectToRemoveList.empty());
1127 measConfigOptional.set(9, !measConfig.measObjectToAddModList.empty());
1128 measConfigOptional.set(8, !measConfig.reportConfigToRemoveList.empty());
1129 measConfigOptional.set(7, !measConfig.reportConfigToAddModList.empty());
1130 measConfigOptional.set(6, !measConfig.measIdToRemoveList.empty());
1131 measConfigOptional.set(5, !measConfig.measIdToAddModList.empty());
1132 measConfigOptional.set(4, measConfig.haveQuantityConfig);
1133 measConfigOptional.set(3, measConfig.haveMeasGapConfig);
1134 measConfigOptional.set(2, measConfig.haveSmeasure);
1135 measConfigOptional.set(1, false); // preRegistrationInfoHRPD
1136 measConfigOptional.set(0, measConfig.haveSpeedStatePars);
1137 SerializeSequence(measConfigOptional, true);
1138
1139 if (!measConfig.measObjectToRemoveList.empty())
1140 {
1142 for (auto it = measConfig.measObjectToRemoveList.begin();
1143 it != measConfig.measObjectToRemoveList.end();
1144 it++)
1145 {
1147 }
1148 }
1149
1150 if (!measConfig.measObjectToAddModList.empty())
1151 {
1153 for (auto it = measConfig.measObjectToAddModList.begin();
1154 it != measConfig.measObjectToAddModList.end();
1155 it++)
1156 {
1157 SerializeSequence(std::bitset<0>(), false);
1158 SerializeInteger(it->measObjectId, 1, MAX_OBJECT_ID);
1159 SerializeChoice(4, 0, true); // Select MeasObjectEUTRA
1160
1161 // Serialize measObjectEutra
1162 std::bitset<5> measObjOpts;
1163 measObjOpts.set(4, !it->measObjectEutra.cellsToRemoveList.empty());
1164 measObjOpts.set(3, !it->measObjectEutra.cellsToAddModList.empty());
1165 measObjOpts.set(2, !it->measObjectEutra.blackCellsToRemoveList.empty());
1166 measObjOpts.set(1, !it->measObjectEutra.blackCellsToAddModList.empty());
1167 measObjOpts.set(0, it->measObjectEutra.haveCellForWhichToReportCGI);
1168 SerializeSequence(measObjOpts, true);
1169
1170 // Serialize carrierFreq
1171 SerializeInteger(it->measObjectEutra.carrierFreq, 0, MAX_EARFCN);
1172
1173 // Serialize allowedMeasBandwidth
1174 SerializeEnum(6, BandwidthToEnum(it->measObjectEutra.allowedMeasBandwidth));
1175
1176 SerializeBoolean(it->measObjectEutra.presenceAntennaPort1);
1177 SerializeBitstring(std::bitset<2>(it->measObjectEutra.neighCellConfig));
1178 SerializeQoffsetRange(it->measObjectEutra.offsetFreq);
1179
1180 if (!it->measObjectEutra.cellsToRemoveList.empty())
1181 {
1182 SerializeSequenceOf(it->measObjectEutra.cellsToRemoveList.size(), MAX_CELL_MEAS, 1);
1183 for (auto it2 = it->measObjectEutra.cellsToRemoveList.begin();
1184 it2 != it->measObjectEutra.cellsToRemoveList.end();
1185 it2++)
1186 {
1188 }
1189 }
1190
1191 if (!it->measObjectEutra.cellsToAddModList.empty())
1192 {
1193 SerializeSequenceOf(it->measObjectEutra.cellsToAddModList.size(), MAX_CELL_MEAS, 1);
1194 for (auto it2 = it->measObjectEutra.cellsToAddModList.begin();
1195 it2 != it->measObjectEutra.cellsToAddModList.end();
1196 it2++)
1197 {
1198 SerializeSequence(std::bitset<0>(), false);
1199
1200 // Serialize cellIndex
1201 SerializeInteger(it2->cellIndex, 1, MAX_CELL_MEAS);
1202
1203 // Serialize PhysCellId
1204 SerializeInteger(it2->physCellId, 0, 503);
1205
1206 // Serialize cellIndividualOffset
1207 SerializeQoffsetRange(it2->cellIndividualOffset);
1208 }
1209 }
1210
1211 if (!it->measObjectEutra.blackCellsToRemoveList.empty())
1212 {
1213 SerializeSequenceOf(it->measObjectEutra.blackCellsToRemoveList.size(),
1215 1);
1216 for (auto it2 = it->measObjectEutra.blackCellsToRemoveList.begin();
1217 it2 != it->measObjectEutra.blackCellsToRemoveList.end();
1218 it2++)
1219 {
1221 }
1222 }
1223
1224 if (!it->measObjectEutra.blackCellsToAddModList.empty())
1225 {
1226 SerializeSequenceOf(it->measObjectEutra.blackCellsToAddModList.size(),
1228 1);
1229 for (auto it2 = it->measObjectEutra.blackCellsToAddModList.begin();
1230 it2 != it->measObjectEutra.blackCellsToAddModList.end();
1231 it2++)
1232 {
1233 SerializeSequence(std::bitset<0>(), false);
1234 SerializeInteger(it2->cellIndex, 1, MAX_CELL_MEAS);
1235
1236 // Serialize PhysCellIdRange
1237 // range optional
1238 std::bitset<1> rangePresent(it2->physCellIdRange.haveRange);
1239 SerializeSequence(rangePresent, false);
1240 SerializeInteger(it2->physCellIdRange.start, 0, 503);
1241 if (it2->physCellIdRange.haveRange)
1242 {
1243 switch (it2->physCellIdRange.range)
1244 {
1245 case 4:
1246 SerializeEnum(16, 0);
1247 break;
1248 case 8:
1249 SerializeEnum(16, 1);
1250 break;
1251 case 12:
1252 SerializeEnum(16, 2);
1253 break;
1254 case 16:
1255 SerializeEnum(16, 3);
1256 break;
1257 case 24:
1258 SerializeEnum(16, 4);
1259 break;
1260 case 32:
1261 SerializeEnum(16, 5);
1262 break;
1263 case 48:
1264 SerializeEnum(16, 6);
1265 break;
1266 case 64:
1267 SerializeEnum(16, 7);
1268 break;
1269 case 84:
1270 SerializeEnum(16, 8);
1271 break;
1272 case 96:
1273 SerializeEnum(16, 9);
1274 break;
1275 case 128:
1276 SerializeEnum(16, 10);
1277 break;
1278 case 168:
1279 SerializeEnum(16, 11);
1280 break;
1281 case 252:
1282 SerializeEnum(16, 12);
1283 break;
1284 case 504:
1285 SerializeEnum(16, 13);
1286 break;
1287 default:
1288 SerializeEnum(16, 0);
1289 }
1290 }
1291 }
1292 }
1293
1294 if (it->measObjectEutra.haveCellForWhichToReportCGI)
1295 {
1296 SerializeInteger(it->measObjectEutra.cellForWhichToReportCGI, 0, 503);
1297 }
1298 }
1299 }
1300
1301 if (!measConfig.reportConfigToRemoveList.empty())
1302 {
1304 for (auto it = measConfig.reportConfigToRemoveList.begin();
1305 it != measConfig.reportConfigToRemoveList.end();
1306 it++)
1307 {
1309 }
1310 }
1311
1312 if (!measConfig.reportConfigToAddModList.empty())
1313 {
1315 for (auto it = measConfig.reportConfigToAddModList.begin();
1316 it != measConfig.reportConfigToAddModList.end();
1317 it++)
1318 {
1319 SerializeSequence(std::bitset<0>(), false);
1320 SerializeInteger(it->reportConfigId, 1, MAX_REPORT_CONFIG_ID);
1321 SerializeChoice(2, 0, false); // reportConfigEUTRA
1322
1323 // Serialize ReportConfigEUTRA
1324 SerializeSequence(std::bitset<0>(), true);
1325 switch (it->reportConfigEutra.triggerType)
1326 {
1328 SerializeChoice(2, 1, false);
1329 SerializeSequence(std::bitset<0>(), false);
1330 switch (it->reportConfigEutra.purpose)
1331 {
1333 SerializeEnum(2, 1);
1334 break;
1336 default:
1337 SerializeEnum(2, 0);
1338 }
1339 break;
1341 default:
1342 SerializeChoice(2, 0, false);
1343 SerializeSequence(std::bitset<0>(), false);
1344 switch (it->reportConfigEutra.eventId)
1345 {
1347 SerializeChoice(5, 0, true);
1348 SerializeSequence(std::bitset<0>(), false);
1349 SerializeThresholdEutra(it->reportConfigEutra.threshold1);
1350 break;
1352 SerializeChoice(5, 1, true);
1353 SerializeSequence(std::bitset<0>(), false);
1354 SerializeThresholdEutra(it->reportConfigEutra.threshold1);
1355 break;
1357 SerializeChoice(5, 2, true);
1358 SerializeSequence(std::bitset<0>(), false);
1359 SerializeInteger(it->reportConfigEutra.a3Offset, -30, 30);
1360 SerializeBoolean(it->reportConfigEutra.reportOnLeave);
1361 break;
1363 SerializeChoice(5, 3, true);
1364 SerializeSequence(std::bitset<0>(), false);
1365 SerializeThresholdEutra(it->reportConfigEutra.threshold1);
1366 break;
1368 default:
1369 SerializeChoice(5, 4, true);
1370 SerializeSequence(std::bitset<0>(), false);
1371 SerializeThresholdEutra(it->reportConfigEutra.threshold1);
1372 SerializeThresholdEutra(it->reportConfigEutra.threshold2);
1373 }
1374
1375 SerializeInteger(it->reportConfigEutra.hysteresis, 0, 30);
1376
1377 switch (it->reportConfigEutra.timeToTrigger)
1378 {
1379 case 0:
1380 SerializeEnum(16, 0);
1381 break;
1382 case 40:
1383 SerializeEnum(16, 1);
1384 break;
1385 case 64:
1386 SerializeEnum(16, 2);
1387 break;
1388 case 80:
1389 SerializeEnum(16, 3);
1390 break;
1391 case 100:
1392 SerializeEnum(16, 4);
1393 break;
1394 case 128:
1395 SerializeEnum(16, 5);
1396 break;
1397 case 160:
1398 SerializeEnum(16, 6);
1399 break;
1400 case 256:
1401 SerializeEnum(16, 7);
1402 break;
1403 case 320:
1404 SerializeEnum(16, 8);
1405 break;
1406 case 480:
1407 SerializeEnum(16, 9);
1408 break;
1409 case 512:
1410 SerializeEnum(16, 10);
1411 break;
1412 case 640:
1413 SerializeEnum(16, 11);
1414 break;
1415 case 1024:
1416 SerializeEnum(16, 12);
1417 break;
1418 case 1280:
1419 SerializeEnum(16, 13);
1420 break;
1421 case 2560:
1422 SerializeEnum(16, 14);
1423 break;
1424 case 5120:
1425 default:
1426 SerializeEnum(16, 15);
1427 }
1428 } // end trigger type
1429
1430 // Serialize triggerQuantity
1431 if (it->reportConfigEutra.triggerQuantity == LteRrcSap::ReportConfigEutra::RSRP)
1432 {
1433 SerializeEnum(2, 0);
1434 }
1435 else
1436 {
1437 SerializeEnum(2, 1);
1438 }
1439
1440 // Serialize reportQuantity
1441 if (it->reportConfigEutra.reportQuantity ==
1443 {
1444 SerializeEnum(2, 0);
1445 }
1446 else
1447 {
1448 SerializeEnum(2, 1);
1449 }
1450
1451 // Serialize maxReportCells
1452 SerializeInteger(it->reportConfigEutra.maxReportCells, 1, MAX_CELL_REPORT);
1453
1454 // Serialize reportInterval
1455 switch (it->reportConfigEutra.reportInterval)
1456 {
1458 SerializeEnum(16, 0);
1459 break;
1461 SerializeEnum(16, 1);
1462 break;
1464 SerializeEnum(16, 2);
1465 break;
1467 SerializeEnum(16, 3);
1468 break;
1470 SerializeEnum(16, 4);
1471 break;
1473 SerializeEnum(16, 5);
1474 break;
1476 SerializeEnum(16, 6);
1477 break;
1479 SerializeEnum(16, 7);
1480 break;
1482 SerializeEnum(16, 8);
1483 break;
1485 SerializeEnum(16, 9);
1486 break;
1488 SerializeEnum(16, 10);
1489 break;
1491 SerializeEnum(16, 11);
1492 break;
1494 SerializeEnum(16, 12);
1495 break;
1497 SerializeEnum(16, 13);
1498 break;
1500 SerializeEnum(16, 14);
1501 break;
1503 default:
1504 SerializeEnum(16, 15);
1505 }
1506
1507 // Serialize reportAmount
1508 switch (it->reportConfigEutra.reportAmount)
1509 {
1510 case 1:
1511 SerializeEnum(8, 0);
1512 break;
1513 case 2:
1514 SerializeEnum(8, 1);
1515 break;
1516 case 4:
1517 SerializeEnum(8, 2);
1518 break;
1519 case 8:
1520 SerializeEnum(8, 3);
1521 break;
1522 case 16:
1523 SerializeEnum(8, 4);
1524 break;
1525 case 32:
1526 SerializeEnum(8, 5);
1527 break;
1528 case 64:
1529 SerializeEnum(8, 6);
1530 break;
1531 default:
1532 SerializeEnum(8, 7);
1533 }
1534 }
1535 }
1536
1537 if (!measConfig.measIdToRemoveList.empty())
1538 {
1539 SerializeSequenceOf(measConfig.measIdToRemoveList.size(), MAX_MEAS_ID, 1);
1540 for (auto it = measConfig.measIdToRemoveList.begin();
1541 it != measConfig.measIdToRemoveList.end();
1542 it++)
1543 {
1545 }
1546 }
1547
1548 if (!measConfig.measIdToAddModList.empty())
1549 {
1550 SerializeSequenceOf(measConfig.measIdToAddModList.size(), MAX_MEAS_ID, 1);
1551 for (auto it = measConfig.measIdToAddModList.begin();
1552 it != measConfig.measIdToAddModList.end();
1553 it++)
1554 {
1555 SerializeInteger(it->measId, 1, MAX_MEAS_ID);
1556 SerializeInteger(it->measObjectId, 1, MAX_OBJECT_ID);
1557 SerializeInteger(it->reportConfigId, 1, MAX_REPORT_CONFIG_ID);
1558 }
1559 }
1560
1561 if (measConfig.haveQuantityConfig)
1562 {
1563 // QuantityConfig sequence
1564 // 4 optional fields, only first (EUTRA) present. Extension marker yes.
1565 std::bitset<4> quantityConfigOpts(0);
1566 quantityConfigOpts.set(3, true);
1567 SerializeSequence(quantityConfigOpts, true);
1568 SerializeSequence(std::bitset<0>(), false);
1569
1570 switch (measConfig.quantityConfig.filterCoefficientRSRP)
1571 {
1572 case 0:
1573 SerializeEnum(16, 0);
1574 break;
1575 case 1:
1576 SerializeEnum(16, 1);
1577 break;
1578 case 2:
1579 SerializeEnum(16, 2);
1580 break;
1581 case 3:
1582 SerializeEnum(16, 3);
1583 break;
1584 case 4:
1585 SerializeEnum(16, 4);
1586 break;
1587 case 5:
1588 SerializeEnum(16, 5);
1589 break;
1590 case 6:
1591 SerializeEnum(16, 6);
1592 break;
1593 case 7:
1594 SerializeEnum(16, 7);
1595 break;
1596 case 8:
1597 SerializeEnum(16, 8);
1598 break;
1599 case 9:
1600 SerializeEnum(16, 9);
1601 break;
1602 case 11:
1603 SerializeEnum(16, 10);
1604 break;
1605 case 13:
1606 SerializeEnum(16, 11);
1607 break;
1608 case 15:
1609 SerializeEnum(16, 12);
1610 break;
1611 case 17:
1612 SerializeEnum(16, 13);
1613 break;
1614 case 19:
1615 SerializeEnum(16, 14);
1616 break;
1617 default:
1618 SerializeEnum(16, 4);
1619 }
1620
1621 switch (measConfig.quantityConfig.filterCoefficientRSRQ)
1622 {
1623 case 0:
1624 SerializeEnum(16, 0);
1625 break;
1626 case 1:
1627 SerializeEnum(16, 1);
1628 break;
1629 case 2:
1630 SerializeEnum(16, 2);
1631 break;
1632 case 3:
1633 SerializeEnum(16, 3);
1634 break;
1635 case 4:
1636 SerializeEnum(16, 4);
1637 break;
1638 case 5:
1639 SerializeEnum(16, 5);
1640 break;
1641 case 6:
1642 SerializeEnum(16, 6);
1643 break;
1644 case 7:
1645 SerializeEnum(16, 7);
1646 break;
1647 case 8:
1648 SerializeEnum(16, 8);
1649 break;
1650 case 9:
1651 SerializeEnum(16, 9);
1652 break;
1653 case 11:
1654 SerializeEnum(16, 10);
1655 break;
1656 case 13:
1657 SerializeEnum(16, 11);
1658 break;
1659 case 15:
1660 SerializeEnum(16, 12);
1661 break;
1662 case 17:
1663 SerializeEnum(16, 13);
1664 break;
1665 case 19:
1666 SerializeEnum(16, 14);
1667 break;
1668 default:
1669 SerializeEnum(16, 4);
1670 }
1671 }
1672
1673 if (measConfig.haveMeasGapConfig)
1674 {
1675 switch (measConfig.measGapConfig.type)
1676 {
1678 SerializeChoice(2, 0, false);
1679 SerializeNull();
1680 break;
1682 default:
1683 SerializeChoice(2, 1, false);
1684 SerializeSequence(std::bitset<0>(), false);
1685 switch (measConfig.measGapConfig.gapOffsetChoice)
1686 {
1688 SerializeChoice(2, 0, true);
1690 break;
1692 default:
1693 SerializeChoice(2, 1, true);
1695 }
1696 }
1697 }
1698
1699 if (measConfig.haveSmeasure)
1700 {
1701 SerializeInteger(measConfig.sMeasure, 0, 97);
1702 }
1703
1704 // ...Here preRegistrationInfoHRPD would be serialized
1705
1706 if (measConfig.haveSpeedStatePars)
1707 {
1708 switch (measConfig.speedStatePars.type)
1709 {
1711 SerializeChoice(2, 0, false);
1712 SerializeNull();
1713 break;
1715 default:
1716 SerializeChoice(2, 1, false);
1717 SerializeSequence(std::bitset<0>(), false);
1719 {
1720 case 30:
1721 SerializeEnum(8, 0);
1722 break;
1723 case 60:
1724 SerializeEnum(8, 1);
1725 break;
1726 case 120:
1727 SerializeEnum(8, 2);
1728 break;
1729 case 180:
1730 SerializeEnum(8, 3);
1731 break;
1732 case 240:
1733 SerializeEnum(8, 4);
1734 break;
1735 default:
1736 SerializeEnum(8, 5);
1737 break;
1738 }
1739
1741 {
1742 case 30:
1743 SerializeEnum(8, 0);
1744 break;
1745 case 60:
1746 SerializeEnum(8, 1);
1747 break;
1748 case 120:
1749 SerializeEnum(8, 2);
1750 break;
1751 case 180:
1752 SerializeEnum(8, 3);
1753 break;
1754 case 240:
1755 SerializeEnum(8, 4);
1756 break;
1757 default:
1758 SerializeEnum(8, 5);
1759 break;
1760 }
1761
1763 1,
1764 16);
1766 1,
1767 16);
1768
1769 SerializeSequence(std::bitset<0>(), false);
1770 switch (measConfig.speedStatePars.timeToTriggerSf.sfMedium)
1771 {
1772 case 25:
1773 SerializeEnum(4, 0);
1774 break;
1775 case 50:
1776 SerializeEnum(4, 1);
1777 break;
1778 case 75:
1779 SerializeEnum(4, 2);
1780 break;
1781 case 100:
1782 default:
1783 SerializeEnum(4, 3);
1784 }
1785
1786 switch (measConfig.speedStatePars.timeToTriggerSf.sfHigh)
1787 {
1788 case 25:
1789 SerializeEnum(4, 0);
1790 break;
1791 case 50:
1792 SerializeEnum(4, 1);
1793 break;
1794 case 75:
1795 SerializeEnum(4, 2);
1796 break;
1797 case 100:
1798 default:
1799 SerializeEnum(4, 3);
1800 }
1801 }
1802 }
1803}
1804
1805void
1807 LteRrcSap::NonCriticalExtensionConfiguration nonCriticalExtension) const
1808{
1809 // 3 optional fields. Extension marker not present.
1810 std::bitset<3> noncriticalExtension_v1020;
1811 noncriticalExtension_v1020.set(
1812 2,
1813 !nonCriticalExtension.sCellToReleaseList.empty()); // sCellToReleaseList-r10
1814 noncriticalExtension_v1020.set(
1815 1,
1816 !nonCriticalExtension.sCellToAddModList.empty()); // sCellToAddModList-r10
1817 noncriticalExtension_v1020.set(
1818 0,
1819 false); // No nonCriticalExtension RRCConnectionReconfiguration-v1130-IEs
1820 SerializeSequence(noncriticalExtension_v1020, false);
1821
1822 if (!nonCriticalExtension.sCellToReleaseList.empty())
1823 {
1824 SerializeSequenceOf(nonCriticalExtension.sCellToReleaseList.size(), MAX_OBJECT_ID, 1);
1825 for (uint8_t sCellIndex : nonCriticalExtension.sCellToReleaseList)
1826 {
1827 SerializeInteger(sCellIndex, 1, 7); // sCellIndex-r10
1828 }
1829 }
1830
1831 if (!nonCriticalExtension.sCellToAddModList.empty())
1832 {
1833 SerializeSequenceOf(nonCriticalExtension.sCellToAddModList.size(), MAX_OBJECT_ID, 1);
1834 for (auto& it : nonCriticalExtension.sCellToAddModList)
1835 {
1836 std::bitset<4> sCellToAddMod_r10;
1837 sCellToAddMod_r10.set(3, true); // sCellIndex
1838 sCellToAddMod_r10.set(2, true); // CellIdentification
1839 sCellToAddMod_r10.set(1, true); // RadioResourceConfigCommonSCell
1840 sCellToAddMod_r10.set(
1841 0,
1842 it.haveRadioResourceConfigDedicatedSCell); // No nonCriticalExtension RRC
1843 SerializeSequence(sCellToAddMod_r10, false);
1844 SerializeInteger(it.sCellIndex, 1, 7); // sCellIndex-r10
1845
1846 // Serialize CellIdentification
1847 std::bitset<2> cellIdentification_r10;
1848 cellIdentification_r10.set(1, true); // phyCellId-r10
1849 cellIdentification_r10.set(0, true); // dl-CarrierFreq-r10
1850 SerializeSequence(cellIdentification_r10, false);
1851
1852 SerializeInteger(it.cellIdentification.physCellId, 1, 65536);
1853 SerializeInteger(it.cellIdentification.dlCarrierFreq, 1, MAX_EARFCN);
1854
1855 // Serialize RadioResourceConfigCommonSCell
1856 SerializeRadioResourceConfigCommonSCell(it.radioResourceConfigCommonSCell);
1857
1858 if (it.haveRadioResourceConfigDedicatedSCell)
1859 {
1860 // Serialize RadioResourceConfigDedicatedSCell
1861 SerializeRadioResourceDedicatedSCell(it.radioResourceConfigDedicatedSCell);
1862 }
1863 }
1864 }
1865}
1866
1867void
1870{
1871 // 2 optional fields. Extension marker not present.
1872 std::bitset<2> radioResourceConfigCommonSCell_r10;
1873 radioResourceConfigCommonSCell_r10.set(1, rrccsc.haveNonUlConfiguration); // NonUlConfiguration
1874 radioResourceConfigCommonSCell_r10.set(0, rrccsc.haveUlConfiguration); // UlConfiguration
1875 SerializeSequence(radioResourceConfigCommonSCell_r10, false);
1876
1877 if (rrccsc.haveNonUlConfiguration)
1878 {
1879 // 5 optional fields. Extension marker not present.
1880 std::bitset<5> nonUlConfiguration_r10;
1881 nonUlConfiguration_r10.set(4, true); // Dl- bandwidth --> convert in enum
1882 nonUlConfiguration_r10.set(3, true); // AntennaInfoCommon-r10
1883 nonUlConfiguration_r10.set(2, false); // phich-Config-r10 Not Implemented
1884 nonUlConfiguration_r10.set(1, true); // pdschConfigCommon
1885 nonUlConfiguration_r10.set(0, false); // Tdd-Config-r10 Not Implemented
1886 SerializeSequence(nonUlConfiguration_r10, false);
1887
1889
1890 std::bitset<1> antennaInfoCommon_r10;
1891 antennaInfoCommon_r10.set(0, true);
1892 SerializeSequence(antennaInfoCommon_r10, false);
1894
1895 std::bitset<2> pdschConfigCommon_r10;
1896 pdschConfigCommon_r10.set(1, true);
1897 pdschConfigCommon_r10.set(0, true);
1898 SerializeSequence(pdschConfigCommon_r10, false);
1899
1902 }
1903 if (rrccsc.haveUlConfiguration)
1904 {
1905 // Serialize Ul Configuration
1906 // 7 optional fields. Extension marker present.
1907 std::bitset<7> UlConfiguration_r10;
1908 UlConfiguration_r10.set(6, true); // ul-Configuration-r10
1909 UlConfiguration_r10.set(5, false); // p-Max-r10 Not Implemented
1910 UlConfiguration_r10.set(4, true); // uplinkPowerControlCommonSCell-r10
1911 UlConfiguration_r10.set(3, false); // soundingRS-UL-ConfigCommon-r10
1912 UlConfiguration_r10.set(2, false); // ul-CyclicPrefixLength-r10
1913 UlConfiguration_r10.set(1, true); // prach-ConfigSCell-r10
1914 UlConfiguration_r10.set(0, false); // pusch-ConfigCommon-r10 Not Implemented
1915 SerializeSequence(UlConfiguration_r10, true);
1916
1917 // Serialize ulFreqInfo
1918 std::bitset<3> FreqInfo_r10;
1919 FreqInfo_r10.set(2, true); // ulCarrierFreq
1920 FreqInfo_r10.set(1, true); // UlBandwidth
1921 FreqInfo_r10.set(0, false); // additionalSpectrumEmissionSCell-r10 Not Implemented
1922 SerializeSequence(FreqInfo_r10, false);
1923
1926
1927 // Serialize UlPowerControlCommonSCell
1928 std::bitset<2> UlPowerControlCommonSCell_r10;
1929 UlPowerControlCommonSCell_r10.set(1, false); // p0-NominalPUSCH-r10 Not Implemented
1930 UlPowerControlCommonSCell_r10.set(0, true); // alpha
1931 SerializeSequence(UlPowerControlCommonSCell_r10, false);
1932
1934
1935 // Serialize soundingRs-UlConfigCommon
1936 // Not Implemented
1937
1938 // Serialize PrachConfigSCell
1939 std::bitset<1> prachConfigSCell_r10;
1940 prachConfigSCell_r10.set(0, true);
1941 SerializeSequence(prachConfigSCell_r10, false);
1943 }
1944}
1945
1946void
1949{
1950 // Serialize RadioResourceConfigDedicatedSCell
1951 std::bitset<1> RadioResourceConfigDedicatedSCell_r10;
1952 RadioResourceConfigDedicatedSCell_r10.set(0, true);
1953 SerializeSequence(RadioResourceConfigDedicatedSCell_r10, false);
1954
1957}
1958
1959void
1962{
1963 std::bitset<2> pcdscOpt;
1964 pcdscOpt.set(1, pcdsc.haveNonUlConfiguration);
1965 pcdscOpt.set(0, pcdsc.haveUlConfiguration);
1966 SerializeSequence(pcdscOpt, true);
1967
1968 if (pcdsc.haveNonUlConfiguration)
1969 {
1970 // Serialize NonUl configuration
1971 std::bitset<4> nulOpt;
1972 nulOpt.set(3, pcdsc.haveAntennaInfoDedicated);
1973 nulOpt.set(2, false); // crossCarrierSchedulingConfig-r10 Not Implemented
1974 nulOpt.set(1, false); // csi-RS-Config-r10 Not Implemented
1975 nulOpt.set(0, pcdsc.havePdschConfigDedicated); // pdsch-ConfigDedicated-r10
1976 SerializeSequence(nulOpt, false);
1977
1978 if (pcdsc.haveAntennaInfoDedicated)
1979 {
1980 // Serialize antennaInfo choice
1981 // 2 options. Selected: 0 ("explicitValue" of type "AntennaInfoDedicated")
1982 SerializeChoice(2, 0, false);
1983
1984 // Serialize AntennaInfoDedicated sequence
1985 // 1 optional parameter, not present. No extension marker.
1986 SerializeSequence(std::bitset<1>(0), false);
1987
1988 // Serialize transmissionMode
1989 // Assuming the value in the struct is the enum index
1991
1992 // Serialize ue-TransmitAntennaSelection choice
1993 SerializeChoice(2, 0, false);
1994
1995 // Serialize release
1996 SerializeNull();
1997 }
1998 if (pcdsc.havePdschConfigDedicated)
1999 {
2000 // Serialize Pdsch-ConfigDedicated Sequence:
2001 // 0 optional / default fields, no extension marker.
2002 SerializeSequence(std::bitset<0>(), false);
2003
2004 // Serialize p-a
2005 // Assuming the value in the struct is the enum index
2007
2008 // Serialize release
2009 SerializeNull();
2010 }
2011 }
2012 if (pcdsc.haveUlConfiguration)
2013 {
2014 // Serialize Ul Configuration
2015 std::bitset<7> ulOpt;
2016 ulOpt.set(6, pcdsc.haveAntennaInfoUlDedicated); // antennaInfoUL-r10
2017 ulOpt.set(5, false); // pusch-ConfigDedicatedSCell-r10 not present
2018 ulOpt.set(4, false); // uplinkPowerControlDedicatedSCell-r10 not present
2019 ulOpt.set(3, false); // cqi-ReportConfigSCell-r10 not present
2020 ulOpt.set(2, pcdsc.haveSoundingRsUlConfigDedicated); // soundingRS-UL-ConfigDedicated-r10
2021 ulOpt.set(1, false); // soundingRS-UL-ConfigDedicated-v1020 not present
2022 ulOpt.set(0, false); // soundingRS-UL-ConfigDedicatedAperiodic-r10 not present
2023 SerializeSequence(ulOpt, false);
2024
2026 {
2027 // Serialize antennaInfo choice
2028 // 2 options. Selected: 0 ("explicitValue" of type "AntennaInfoDedicated")
2029 SerializeChoice(2, 0, false);
2030
2031 // Serialize AntennaInfoDedicated sequence
2032 // 1 optional parameter, not present. No extension marker.
2033 SerializeSequence(std::bitset<1>(0), false);
2034
2035 // Serialize transmissionMode
2036 // Assuming the value in the struct is the enum index
2038
2039 // Serialize ue-TransmitAntennaSelection choice
2040 SerializeChoice(2, 0, false);
2041
2042 // Serialize release
2043 SerializeNull();
2044 }
2046 {
2047 // Serialize SoundingRS-UL-ConfigDedicated choice:
2048 switch (pcdsc.soundingRsUlConfigDedicated.type)
2049 {
2051 SerializeChoice(2, 0, false);
2052 SerializeNull();
2053 break;
2054
2056 default:
2057 // 2 options, selected: 1 (setup)
2058 SerializeChoice(2, 1, false);
2059
2060 // Serialize setup sequence
2061 // 0 optional / default fields, no extension marker.
2062 SerializeSequence(std::bitset<0>(), false);
2063
2064 // Serialize srs-Bandwidth
2066
2067 // Serialize srs-HoppingBandwidth
2068 SerializeEnum(4, 0);
2069
2070 // Serialize freqDomainPosition
2071 SerializeInteger(0, 0, 23);
2072
2073 // Serialize duration
2074 SerializeBoolean(false);
2075
2076 // Serialize srs-ConfigIndex
2078
2079 // Serialize transmissionComb
2080 SerializeInteger(0, 0, 1);
2081
2082 // Serialize cyclicShift
2083 SerializeEnum(8, 0);
2084
2085 break;
2086 }
2087 }
2088 }
2089}
2090
2093 Buffer::Iterator bIterator)
2094{
2095 int thresholdEutraChoice;
2096 int range;
2097 bIterator = DeserializeChoice(2, false, &thresholdEutraChoice, bIterator);
2098
2099 switch (thresholdEutraChoice)
2100 {
2101 case 0:
2103 bIterator = DeserializeInteger(&range, 0, 97, bIterator);
2104 thresholdEutra->range = range;
2105 break;
2106 case 1:
2107 default:
2109 bIterator = DeserializeInteger(&range, 0, 34, bIterator);
2110 thresholdEutra->range = range;
2111 }
2112
2113 return bIterator;
2114}
2115
2118{
2119 int n;
2120 bIterator = DeserializeEnum(31, &n, bIterator);
2121 switch (n)
2122 {
2123 case 0:
2124 *qOffsetRange = -24;
2125 break;
2126 case 1:
2127 *qOffsetRange = -22;
2128 break;
2129 case 2:
2130 *qOffsetRange = -20;
2131 break;
2132 case 3:
2133 *qOffsetRange = -18;
2134 break;
2135 case 4:
2136 *qOffsetRange = -16;
2137 break;
2138 case 5:
2139 *qOffsetRange = -14;
2140 break;
2141 case 6:
2142 *qOffsetRange = -12;
2143 break;
2144 case 7:
2145 *qOffsetRange = -10;
2146 break;
2147 case 8:
2148 *qOffsetRange = -8;
2149 break;
2150 case 9:
2151 *qOffsetRange = -6;
2152 break;
2153 case 10:
2154 *qOffsetRange = -5;
2155 break;
2156 case 11:
2157 *qOffsetRange = -4;
2158 break;
2159 case 12:
2160 *qOffsetRange = -3;
2161 break;
2162 case 13:
2163 *qOffsetRange = -2;
2164 break;
2165 case 14:
2166 *qOffsetRange = -1;
2167 break;
2168 case 15:
2169 *qOffsetRange = 0;
2170 break;
2171 case 16:
2172 *qOffsetRange = 1;
2173 break;
2174 case 17:
2175 *qOffsetRange = 2;
2176 break;
2177 case 18:
2178 *qOffsetRange = 3;
2179 break;
2180 case 19:
2181 *qOffsetRange = 4;
2182 break;
2183 case 20:
2184 *qOffsetRange = 5;
2185 break;
2186 case 21:
2187 *qOffsetRange = 6;
2188 break;
2189 case 22:
2190 *qOffsetRange = 8;
2191 break;
2192 case 23:
2193 *qOffsetRange = 10;
2194 break;
2195 case 24:
2196 *qOffsetRange = 12;
2197 break;
2198 case 25:
2199 *qOffsetRange = 14;
2200 break;
2201 case 26:
2202 *qOffsetRange = 16;
2203 break;
2204 case 27:
2205 *qOffsetRange = 18;
2206 break;
2207 case 28:
2208 *qOffsetRange = 20;
2209 break;
2210 case 29:
2211 *qOffsetRange = 22;
2212 break;
2213 case 30:
2214 default:
2215 *qOffsetRange = 24;
2216 }
2217 return bIterator;
2218}
2219
2222 LteRrcSap::RadioResourceConfigDedicated* radioResourceConfigDedicated,
2223 Buffer::Iterator bIterator)
2224{
2225 // Deserialize RadioResourceConfigDedicated sequence
2226 std::bitset<6> optionalFieldsPresent = std::bitset<6>();
2227 bIterator = DeserializeSequence(&optionalFieldsPresent, true, bIterator);
2228
2229 if (optionalFieldsPresent[5])
2230 {
2231 // Deserialize srb-ToAddModList
2232 bIterator =
2233 DeserializeSrbToAddModList(&(radioResourceConfigDedicated->srbToAddModList), bIterator);
2234 }
2235
2236 if (optionalFieldsPresent[4])
2237 {
2238 // Deserialize drb-ToAddModList
2239 bIterator =
2240 DeserializeDrbToAddModList(&(radioResourceConfigDedicated->drbToAddModList), bIterator);
2241 }
2242
2243 if (optionalFieldsPresent[3])
2244 {
2245 // Deserialize drb-ToReleaseList
2246 int n;
2247 int val;
2248 bIterator = DeserializeSequenceOf(&n, MAX_DRB, 1, bIterator);
2249 for (int i = 0; i < n; i++)
2250 {
2251 bIterator = DeserializeInteger(&val, 1, 32, bIterator);
2252 radioResourceConfigDedicated->drbToReleaseList.push_back(val);
2253 }
2254 }
2255
2256 if (optionalFieldsPresent[2])
2257 {
2258 // Deserialize mac-MainConfig
2259 // ...
2260 }
2261
2262 if (optionalFieldsPresent[1])
2263 {
2264 // Deserialize sps-Config
2265 // ...
2266 }
2267
2268 radioResourceConfigDedicated->havePhysicalConfigDedicated = optionalFieldsPresent[0];
2269 if (optionalFieldsPresent[0])
2270 {
2271 // Deserialize physicalConfigDedicated
2273 &radioResourceConfigDedicated->physicalConfigDedicated,
2274 bIterator);
2275 }
2276
2277 return bIterator;
2278}
2279
2281RrcAsn1Header::DeserializeSrbToAddModList(std::list<LteRrcSap::SrbToAddMod>* srbToAddModList,
2282 Buffer::Iterator bIterator)
2283{
2284 int numElems;
2285 bIterator = DeserializeSequenceOf(&numElems, 2, 1, bIterator);
2286
2287 srbToAddModList->clear();
2288
2289 // Deserialize SRB-ToAddMod elements
2290 for (int i = 0; i < numElems; i++)
2291 {
2292 LteRrcSap::SrbToAddMod srbToAddMod;
2293 // Deserialize SRB-ToAddMod sequence
2294 // 2 optional fields, extension marker present
2295 std::bitset<2> optionalFields;
2296 bIterator = DeserializeSequence(&optionalFields, true, bIterator);
2297
2298 // Deserialize srbIdentity
2299 int n;
2300 bIterator = DeserializeInteger(&n, 1, 2, bIterator);
2301 srbToAddMod.srbIdentity = n;
2302
2303 if (optionalFields[1])
2304 {
2305 // Deserialize rlcConfig choice
2306 // ...
2307 }
2308
2309 if (optionalFields[0])
2310 {
2311 // Deserialize logicalChannelConfig choice
2312 int sel;
2313 bIterator = DeserializeChoice(2, false, &sel, bIterator);
2314
2315 // Deserialize logicalChannelConfig defaultValue
2316 if (sel == 1)
2317 {
2318 bIterator = DeserializeNull(bIterator);
2319 }
2320
2321 // Deserialize logicalChannelConfig explicitValue
2322 else if (sel == 0)
2323 {
2324 bIterator =
2326 }
2327 }
2328 srbToAddModList->insert(srbToAddModList->end(), srbToAddMod);
2329 }
2330
2331 return bIterator;
2332}
2333
2335RrcAsn1Header::DeserializeDrbToAddModList(std::list<LteRrcSap::DrbToAddMod>* drbToAddModList,
2336 Buffer::Iterator bIterator)
2337{
2338 int n;
2339 int val;
2340 bIterator = DeserializeSequenceOf(&n, MAX_DRB, 1, bIterator);
2341
2342 drbToAddModList->clear();
2343
2344 for (int i = 0; i < n; i++)
2345 {
2346 LteRrcSap::DrbToAddMod drbToAddMod;
2347
2348 std::bitset<5> optionalFields;
2349 bIterator = DeserializeSequence(&optionalFields, true, bIterator);
2350
2351 if (optionalFields[4])
2352 {
2353 // Deserialize epsBearerIdentity
2354 bIterator = DeserializeInteger(&val, 0, 15, bIterator);
2355 drbToAddMod.epsBearerIdentity = val;
2356 }
2357
2358 bIterator = DeserializeInteger(&val, 1, 32, bIterator);
2359 drbToAddMod.drbIdentity = val;
2360
2361 if (optionalFields[3])
2362 {
2363 // Deserialize pdcp-Config
2364 // ...
2365 }
2366
2367 if (optionalFields[2])
2368 {
2369 // Deserialize RLC-Config
2370 int chosen;
2371 bIterator = DeserializeChoice(4, true, &chosen, bIterator);
2372
2373 int sel;
2374 std::bitset<0> bitset0;
2375 switch (chosen)
2376 {
2377 case 0:
2379
2380 // Deserialize UL-AM-RLC
2381 bIterator = DeserializeSequence(&bitset0, false, bIterator);
2382 bIterator = DeserializeEnum(64, &sel, bIterator); // t-PollRetransmit
2383 bIterator = DeserializeEnum(8, &sel, bIterator); // pollPDU
2384 bIterator = DeserializeEnum(16, &sel, bIterator); // pollByte
2385 bIterator = DeserializeEnum(8, &sel, bIterator); // maxRetxThreshold
2386
2387 // Deserialize DL-AM-RLC
2388 bIterator = DeserializeSequence(&bitset0, false, bIterator);
2389 bIterator = DeserializeEnum(32, &sel, bIterator); // t-Reordering
2390 bIterator = DeserializeEnum(64, &sel, bIterator); // t-StatusProhibit
2391 break;
2392
2393 case 1:
2395
2396 // Deserialize UL-UM-RLC
2397 bIterator = DeserializeSequence(&bitset0, false, bIterator);
2398 bIterator = DeserializeEnum(2, &sel, bIterator); // sn-FieldLength
2399
2400 // Deserialize DL-UM-RLC
2401 bIterator = DeserializeSequence(&bitset0, false, bIterator);
2402 bIterator = DeserializeEnum(2, &sel, bIterator); // sn-FieldLength
2403 bIterator = DeserializeEnum(32, &sel, bIterator); // t-Reordering
2404 break;
2405
2406 case 2:
2408
2409 // Deserialize UL-UM-RLC
2410 bIterator = DeserializeSequence(&bitset0, false, bIterator);
2411 bIterator = DeserializeEnum(2, &sel, bIterator); // sn-FieldLength
2412 break;
2413
2414 case 3:
2416
2417 // Deserialize DL-UM-RLC
2418 bIterator = DeserializeSequence(&bitset0, false, bIterator);
2419 bIterator = DeserializeEnum(2, &sel, bIterator); // sn-FieldLength
2420 bIterator = DeserializeEnum(32, &sel, bIterator); // t-Reordering
2421 break;
2422 }
2423 }
2424
2425 if (optionalFields[1])
2426 {
2427 bIterator = DeserializeInteger(&val, 3, 10, bIterator);
2428 drbToAddMod.logicalChannelIdentity = val;
2429 }
2430
2431 if (optionalFields[0])
2432 {
2433 bIterator =
2435 }
2436
2437 drbToAddModList->insert(drbToAddModList->end(), drbToAddMod);
2438 }
2439 return bIterator;
2440}
2441
2444 LteRrcSap::LogicalChannelConfig* logicalChannelConfig,
2445 Buffer::Iterator bIterator)
2446{
2447 int n;
2448
2449 // Deserialize LogicalChannelConfig sequence
2450 // 1 optional field, extension marker is present.
2451 std::bitset<1> bitset1;
2452 bIterator = DeserializeSequence(&bitset1, true, bIterator);
2453
2454 if (bitset1[0])
2455 {
2456 // Deserialize ul-SpecificParameters sequence
2457 bIterator = DeserializeSequence(&bitset1, false, bIterator);
2458
2459 // Deserialize priority
2460 bIterator = DeserializeInteger(&n, 1, 16, bIterator);
2461 logicalChannelConfig->priority = n;
2462
2463 // Deserialize prioritisedBitRate
2464 bIterator = DeserializeEnum(16, &n, bIterator);
2465 uint16_t prioritizedBitRateKbps;
2466
2467 switch (n)
2468 {
2469 case 0:
2470 prioritizedBitRateKbps = 0;
2471 break;
2472 case 1:
2473 prioritizedBitRateKbps = 8;
2474 break;
2475 case 2:
2476 prioritizedBitRateKbps = 16;
2477 break;
2478 case 3:
2479 prioritizedBitRateKbps = 32;
2480 break;
2481 case 4:
2482 prioritizedBitRateKbps = 64;
2483 break;
2484 case 5:
2485 prioritizedBitRateKbps = 128;
2486 break;
2487 case 6:
2488 prioritizedBitRateKbps = 256;
2489 break;
2490 case 7:
2491 prioritizedBitRateKbps = 10000;
2492 break;
2493 default:
2494 prioritizedBitRateKbps = 10000;
2495 }
2496 logicalChannelConfig->prioritizedBitRateKbps = prioritizedBitRateKbps;
2497
2498 // Deserialize bucketSizeDuration
2499 bIterator = DeserializeEnum(8, &n, bIterator);
2500 uint16_t bucketSizeDurationMs;
2501 switch (n)
2502 {
2503 case 0:
2504 bucketSizeDurationMs = 50;
2505 break;
2506 case 1:
2507 bucketSizeDurationMs = 100;
2508 break;
2509 case 2:
2510 bucketSizeDurationMs = 150;
2511 break;
2512 case 3:
2513 bucketSizeDurationMs = 300;
2514 break;
2515 case 4:
2516 bucketSizeDurationMs = 500;
2517 break;
2518 case 5:
2519 bucketSizeDurationMs = 1000;
2520 break;
2521 default:
2522 bucketSizeDurationMs = 1000;
2523 }
2524 logicalChannelConfig->bucketSizeDurationMs = bucketSizeDurationMs;
2525
2526 if (bitset1[0])
2527 {
2528 // Deserialize logicalChannelGroup
2529 bIterator = DeserializeInteger(&n, 0, 3, bIterator);
2530 logicalChannelConfig->logicalChannelGroup = n;
2531 }
2532 }
2533 return bIterator;
2534}
2535
2538 LteRrcSap::PhysicalConfigDedicated* physicalConfigDedicated,
2539 Buffer::Iterator bIterator)
2540{
2541 std::bitset<10> optionalFieldPresent;
2542 bIterator = DeserializeSequence(&optionalFieldPresent, true, bIterator);
2543
2544 physicalConfigDedicated->havePdschConfigDedicated = optionalFieldPresent[9];
2545 if (optionalFieldPresent[9])
2546 {
2547 // Deserialize pdsch-ConfigDedicated
2548 std::bitset<0> bitset0;
2549 bIterator = DeserializeSequence(&bitset0, false, bIterator);
2550
2551 int slct;
2552
2553 // Deserialize p-a
2554 bIterator = DeserializeEnum(8, &slct, bIterator);
2555 physicalConfigDedicated->pdschConfigDedicated.pa = slct;
2556
2557 bIterator = DeserializeNull(bIterator);
2558 }
2559 if (optionalFieldPresent[8])
2560 {
2561 // Deserialize pucch-ConfigDedicated
2562 // ...
2563 }
2564 if (optionalFieldPresent[7])
2565 {
2566 // Deserialize pusch-ConfigDedicated
2567 // ...
2568 }
2569 if (optionalFieldPresent[6])
2570 {
2571 // Deserialize uplinkPowerControlDedicated
2572 // ...
2573 }
2574 if (optionalFieldPresent[5])
2575 {
2576 // Deserialize tpc-PDCCH-ConfigPUCCH
2577 // ...
2578 }
2579 if (optionalFieldPresent[4])
2580 {
2581 // Deserialize tpc-PDCCH-ConfigPUSCH
2582 // ...
2583 }
2584 if (optionalFieldPresent[3])
2585 {
2586 // Deserialize cqi-ReportConfig
2587 // ...
2588 }
2589 physicalConfigDedicated->haveSoundingRsUlConfigDedicated = optionalFieldPresent[2];
2590 if (optionalFieldPresent[2])
2591 {
2592 // Deserialize soundingRS-UL-ConfigDedicated
2593 int sel;
2594 bIterator = DeserializeChoice(2, false, &sel, bIterator);
2595
2596 if (sel == 0)
2597 {
2598 physicalConfigDedicated->soundingRsUlConfigDedicated.type =
2600
2601 bIterator = DeserializeNull(bIterator);
2602 }
2603
2604 else if (sel == 1)
2605 {
2606 physicalConfigDedicated->soundingRsUlConfigDedicated.type =
2608
2609 std::bitset<0> bitset0;
2610 bIterator = DeserializeSequence(&bitset0, false, bIterator);
2611
2612 int slct;
2613
2614 // Deserialize srs-Bandwidth
2615 bIterator = DeserializeEnum(4, &slct, bIterator);
2616 physicalConfigDedicated->soundingRsUlConfigDedicated.srsBandwidth = slct;
2617
2618 // Deserialize srs-HoppingBandwidth
2619 bIterator = DeserializeEnum(4, &slct, bIterator);
2620
2621 // Deserialize freqDomainPosition
2622 bIterator = DeserializeInteger(&slct, 0, 23, bIterator);
2623
2624 // Deserialize duration
2625 bool duration;
2626 bIterator = DeserializeBoolean(&duration, bIterator);
2627
2628 // Deserialize srs-ConfigIndex
2629 bIterator = DeserializeInteger(&slct, 0, 1023, bIterator);
2630 physicalConfigDedicated->soundingRsUlConfigDedicated.srsConfigIndex = slct;
2631
2632 // Deserialize transmissionComb
2633 bIterator = DeserializeInteger(&slct, 0, 1, bIterator);
2634
2635 // Deserialize cyclicShift
2636 bIterator = DeserializeEnum(8, &slct, bIterator);
2637 }
2638 }
2639 physicalConfigDedicated->haveAntennaInfoDedicated = optionalFieldPresent[1];
2640 if (optionalFieldPresent[1])
2641 {
2642 // Deserialize antennaInfo
2643 int sel;
2644 bIterator = DeserializeChoice(2, false, &sel, bIterator);
2645 if (sel == 1)
2646 {
2647 bIterator = DeserializeNull(bIterator);
2648 }
2649 else if (sel == 0)
2650 {
2651 std::bitset<1> codebookSubsetRestrictionPresent;
2652 bIterator = DeserializeSequence(&codebookSubsetRestrictionPresent, false, bIterator);
2653
2654 int txmode;
2655 bIterator = DeserializeEnum(8, &txmode, bIterator);
2656 physicalConfigDedicated->antennaInfo.transmissionMode = txmode;
2657
2658 if (codebookSubsetRestrictionPresent[0])
2659 {
2660 // Deserialize codebookSubsetRestriction
2661 // ...
2662 }
2663
2664 int txantennaselchosen;
2665 bIterator = DeserializeChoice(2, false, &txantennaselchosen, bIterator);
2666 if (txantennaselchosen == 0)
2667 {
2668 // Deserialize ue-TransmitAntennaSelection release
2669 bIterator = DeserializeNull(bIterator);
2670 }
2671 else if (txantennaselchosen == 1)
2672 {
2673 // Deserialize ue-TransmitAntennaSelection setup
2674 // ...
2675 }
2676 }
2677 }
2678 if (optionalFieldPresent[0])
2679 {
2680 // Deserialize schedulingRequestConfig
2681 // ...
2682 }
2683 return bIterator;
2684}
2685
2686void
2687RrcAsn1Header::Print(std::ostream& os) const
2688{
2689 NS_LOG_FUNCTION(this << &os);
2690 NS_FATAL_ERROR("RrcAsn1Header Print() function must also specify "
2691 "LteRrcSap::RadioResourceConfigDedicated as a second argument");
2692}
2693
2697 Buffer::Iterator bIterator)
2698{
2699 NS_LOG_FUNCTION(this);
2700 std::bitset<2> nonCriticalExtension_v890;
2701 bIterator = DeserializeSequence(&nonCriticalExtension_v890, false, bIterator);
2702
2703 if (nonCriticalExtension_v890[0])
2704 {
2705 // Continue to analyze future Release optional fields
2706 std::bitset<3> nonCriticalExtension_v920;
2707 bIterator = DeserializeSequence(&nonCriticalExtension_v920, false, bIterator);
2708 if (nonCriticalExtension_v920[0])
2709 {
2710 // Continue to deserialize future Release optional fields
2711 std::bitset<3> nonCriticalExtension_v1020;
2712 bIterator = DeserializeSequence(&nonCriticalExtension_v1020, false, bIterator);
2713
2714 if (nonCriticalExtension_v1020[2])
2715 {
2716 // sCellToReleaseList-r10
2717 int numElems;
2718
2719 bIterator = DeserializeSequenceOf(&numElems, MAX_OBJECT_ID, 1, bIterator);
2720 nonCriticalExtension->sCellToReleaseList.clear();
2721
2722 for (int i = 0; i < numElems; i++)
2723 {
2724 // Deserialize SCellIndex-r10
2725 int sCellIndex;
2726 bIterator = DeserializeInteger(&sCellIndex, 1, 7, bIterator);
2727 nonCriticalExtension->sCellToReleaseList.push_back(sCellIndex);
2728 }
2729 }
2730
2731 if (nonCriticalExtension_v1020[1])
2732 {
2733 // sCellToAddModList-r10
2734
2735 int numElems;
2736 bIterator = DeserializeSequenceOf(&numElems, MAX_OBJECT_ID, 1, bIterator);
2737 nonCriticalExtension->sCellToAddModList.clear();
2738 // Deserialize SCellToAddMod
2739 for (int i = 0; i < numElems; i++)
2740 {
2741 std::bitset<4> sCellToAddMod_r10;
2742 bIterator = DeserializeSequence(&sCellToAddMod_r10, false, bIterator);
2743
2745 // Deserialize sCellIndex
2746 NS_ASSERT(sCellToAddMod_r10[3]); // sCellIndex
2747 int n;
2748 bIterator = DeserializeInteger(&n, 1, 7, bIterator);
2749 sctam.sCellIndex = n;
2750 // Deserialize CellIdentification
2751 NS_ASSERT(sCellToAddMod_r10[2]); // CellIdentification
2752 bIterator = DeserializeCellIdentification(&sctam.cellIdentification, bIterator);
2753
2754 // Deserialize RadioResourceConfigCommonSCell
2755 NS_ASSERT(sCellToAddMod_r10[1]);
2758 bIterator);
2759 if (sCellToAddMod_r10[0])
2760 {
2762 // Deserialize RadioResourceConfigDedicatedSCell
2765 bIterator);
2766 }
2767 else
2768 {
2770 }
2771
2772 nonCriticalExtension->sCellToAddModList.push_back(sctam);
2773 }
2774 }
2775
2776 NS_ASSERT(!nonCriticalExtension_v1020[0]); // No nonCriticalExtension
2777 // RRCConnectionReconfiguration-v1130-IEs
2778 }
2779 }
2780
2781 return bIterator;
2782}
2783
2786 Buffer::Iterator bIterator)
2787{
2788 NS_LOG_FUNCTION(this);
2789 std::bitset<2> cellIdentification_r10;
2790 bIterator = DeserializeSequence(&cellIdentification_r10, false, bIterator);
2791 NS_ASSERT(cellIdentification_r10[1]); // phyCellId-r10
2792 int n1;
2793 bIterator = DeserializeInteger(&n1, 1, 65536, bIterator);
2794 ci->physCellId = n1;
2795 int n2;
2796 NS_ASSERT(cellIdentification_r10[0]); // dl-CarrierFreq-r10
2797 bIterator = DeserializeInteger(&n2, 1, MAX_EARFCN, bIterator);
2798 ci->dlCarrierFreq = n2;
2799
2800 return bIterator;
2801}
2802
2806 Buffer::Iterator bIterator)
2807{
2808 NS_LOG_FUNCTION(this);
2809 std::bitset<2> radioResourceConfigCommonSCell_r10;
2810 bIterator = DeserializeSequence(&radioResourceConfigCommonSCell_r10, false, bIterator);
2811 rrccsc->haveNonUlConfiguration = radioResourceConfigCommonSCell_r10[1];
2812 rrccsc->haveUlConfiguration = radioResourceConfigCommonSCell_r10[0];
2813 if (rrccsc->haveNonUlConfiguration)
2814 {
2815 std::bitset<5> nonUlConfiguration_r10;
2816 bIterator = DeserializeSequence(&nonUlConfiguration_r10, false, bIterator);
2817 int n;
2818 bIterator = DeserializeInteger(&n, 6, 100, bIterator);
2819 rrccsc->nonUlConfiguration.dlBandwidth = n;
2820
2821 std::bitset<1> antennaInfoCommon_r10;
2822 bIterator = DeserializeSequence(&antennaInfoCommon_r10, false, bIterator);
2823 bIterator = DeserializeInteger(&n, 0, 65536, bIterator);
2825
2826 std::bitset<2> pdschConfigCommon_r10;
2827 bIterator = DeserializeSequence(&pdschConfigCommon_r10, false, bIterator);
2828 bIterator = DeserializeInteger(&n, -60, 50, bIterator);
2830 bIterator = DeserializeInteger(&n, 0, 3, bIterator);
2832 }
2833 if (rrccsc->haveUlConfiguration)
2834 {
2835 std::bitset<7> UlConfiguration_r10;
2836 bIterator = DeserializeSequence(&UlConfiguration_r10, true, bIterator);
2837
2838 std::bitset<3> FreqInfo_r10;
2839 bIterator = DeserializeSequence(&FreqInfo_r10, false, bIterator);
2840 int n;
2841 bIterator = DeserializeInteger(&n, 0, MAX_EARFCN, bIterator);
2843 bIterator = DeserializeInteger(&n, 6, 100, bIterator);
2845
2846 std::bitset<2> UlPowerControlCommonSCell_r10;
2847 bIterator = DeserializeSequence(&UlPowerControlCommonSCell_r10, false, bIterator);
2848 bIterator = DeserializeInteger(&n, 0, 65536, bIterator);
2850
2851 std::bitset<1> prachConfigSCell_r10;
2852 bIterator = DeserializeSequence(&prachConfigSCell_r10, false, bIterator);
2853 bIterator = DeserializeInteger(&n, 0, 256, bIterator);
2855 }
2856
2857 return bIterator;
2858}
2859
2863 Buffer::Iterator bIterator)
2864{
2865 NS_LOG_FUNCTION(this);
2866 std::bitset<1> RadioResourceConfigDedicatedSCell_r10;
2867 bIterator = DeserializeSequence(&RadioResourceConfigDedicatedSCell_r10, false, bIterator);
2868 bIterator =
2870
2871 return bIterator;
2872}
2873
2877 Buffer::Iterator bIterator)
2878{
2879 NS_LOG_FUNCTION(this);
2880 std::bitset<2> pcdscOpt;
2881 bIterator = DeserializeSequence(&pcdscOpt, true, bIterator);
2882 pcdsc->haveNonUlConfiguration = pcdscOpt[1];
2883 pcdsc->haveUlConfiguration = pcdscOpt[0];
2884 if (pcdsc->haveNonUlConfiguration)
2885 {
2886 std::bitset<4> nulOpt;
2887 bIterator = DeserializeSequence(&nulOpt, false, bIterator);
2888 pcdsc->haveAntennaInfoDedicated = nulOpt[3];
2889 NS_ASSERT(!nulOpt[2]); // crossCarrierSchedulingConfig-r10 Not Implemented
2890 NS_ASSERT(!nulOpt[1]); // csi-RS-Config-r10 Not Implemented
2891 pcdsc->havePdschConfigDedicated = nulOpt[0];
2892
2893 if (pcdsc->haveAntennaInfoDedicated)
2894 {
2895 // Deserialize antennaInfo
2896 int sel;
2897 bIterator = DeserializeChoice(2, false, &sel, bIterator);
2898 if (sel == 1)
2899 {
2900 bIterator = DeserializeNull(bIterator);
2901 }
2902 else if (sel == 0)
2903 {
2904 std::bitset<1> codebookSubsetRestrictionPresent;
2905 bIterator =
2906 DeserializeSequence(&codebookSubsetRestrictionPresent, false, bIterator);
2907
2908 int txmode;
2909 bIterator = DeserializeEnum(8, &txmode, bIterator);
2910 pcdsc->antennaInfo.transmissionMode = txmode;
2911
2912 if (codebookSubsetRestrictionPresent[0])
2913 {
2914 // Deserialize codebookSubsetRestriction
2915 NS_FATAL_ERROR("Not implemented yet");
2916 // ...
2917 }
2918
2919 int txantennaselchosen;
2920 bIterator = DeserializeChoice(2, false, &txantennaselchosen, bIterator);
2921 if (txantennaselchosen == 0)
2922 {
2923 // Deserialize ue-TransmitAntennaSelection release
2924 bIterator = DeserializeNull(bIterator);
2925 }
2926 else if (txantennaselchosen == 1)
2927 {
2928 // Deserialize ue-TransmitAntennaSelection setup
2929 NS_FATAL_ERROR("Not implemented yet");
2930 // ...
2931 }
2932 }
2933 }
2934 if (pcdsc->havePdschConfigDedicated)
2935 {
2936 // Deserialize pdsch-ConfigDedicated
2937 std::bitset<0> bitset0;
2938 bIterator = DeserializeSequence(&bitset0, false, bIterator);
2939
2940 int slct;
2941
2942 // Deserialize p-a
2943 bIterator = DeserializeEnum(8, &slct, bIterator);
2944 pcdsc->pdschConfigDedicated.pa = slct;
2945
2946 bIterator = DeserializeNull(bIterator);
2947 }
2948 }
2949 if (pcdsc->haveUlConfiguration)
2950 {
2951 std::bitset<7> ulOpt;
2952 bIterator = DeserializeSequence(&ulOpt, false, bIterator);
2953 pcdsc->haveAntennaInfoUlDedicated = ulOpt[6];
2954 NS_ASSERT(!ulOpt[5]); // pusch-ConfigDedicatedSCell-r10 not present
2955 NS_ASSERT(!ulOpt[4]); // uplinkPowerControlDedicatedSCell-r10 not present
2956 NS_ASSERT(!ulOpt[3]); // cqi-ReportConfigSCell-r10 not present
2957 pcdsc->haveSoundingRsUlConfigDedicated = ulOpt[2];
2958 NS_ASSERT(!ulOpt[1]); // soundingRS-UL-ConfigDedicated-v1020 not present
2959 NS_ASSERT(!ulOpt[0]); // soundingRS-UL-ConfigDedicatedAperiodic-r10 not present
2960
2961 if (pcdsc->haveAntennaInfoUlDedicated)
2962 {
2963 // Deserialize antennaInfo
2964 int sel;
2965 bIterator = DeserializeChoice(2, false, &sel, bIterator);
2966 if (sel == 1)
2967 {
2968 bIterator = DeserializeNull(bIterator);
2969 }
2970 else if (sel == 0)
2971 {
2972 std::bitset<1> codebookSubsetRestrictionPresent;
2973 bIterator =
2974 DeserializeSequence(&codebookSubsetRestrictionPresent, false, bIterator);
2975
2976 int txmode;
2977 bIterator = DeserializeEnum(8, &txmode, bIterator);
2978 pcdsc->antennaInfoUl.transmissionMode = txmode;
2979
2980 if (codebookSubsetRestrictionPresent[0])
2981 {
2982 // Deserialize codebookSubsetRestriction
2983 NS_FATAL_ERROR("Not implemented yet");
2984 // ...
2985 }
2986
2987 int txantennaselchosen;
2988 bIterator = DeserializeChoice(2, false, &txantennaselchosen, bIterator);
2989 if (txantennaselchosen == 0)
2990 {
2991 // Deserialize ue-TransmitAntennaSelection release
2992 bIterator = DeserializeNull(bIterator);
2993 }
2994 else if (txantennaselchosen == 1)
2995 {
2996 // Deserialize ue-TransmitAntennaSelection setup
2997 NS_FATAL_ERROR("Not implemented yet");
2998 // ...
2999 }
3000 }
3001 }
3003 {
3004 // Deserialize soundingRS-UL-ConfigDedicated
3005 int sel;
3006 bIterator = DeserializeChoice(2, false, &sel, bIterator);
3007
3008 if (sel == 0)
3009 {
3012
3013 bIterator = DeserializeNull(bIterator);
3014 }
3015
3016 else if (sel == 1)
3017 {
3020
3021 std::bitset<0> bitset0;
3022 bIterator = DeserializeSequence(&bitset0, false, bIterator);
3023
3024 int slct;
3025
3026 // Deserialize srs-Bandwidth
3027 bIterator = DeserializeEnum(4, &slct, bIterator);
3029
3030 // Deserialize srs-HoppingBandwidth
3031 bIterator = DeserializeEnum(4, &slct, bIterator);
3032
3033 // Deserialize freqDomainPosition
3034 bIterator = DeserializeInteger(&slct, 0, 23, bIterator);
3035
3036 // Deserialize duration
3037 bool duration;
3038 bIterator = DeserializeBoolean(&duration, bIterator);
3039
3040 // Deserialize srs-ConfigIndex
3041 bIterator = DeserializeInteger(&slct, 0, 1023, bIterator);
3043
3044 // Deserialize transmissionComb
3045 bIterator = DeserializeInteger(&slct, 0, 1, bIterator);
3046
3047 // Deserialize cyclicShift
3048 bIterator = DeserializeEnum(8, &slct, bIterator);
3049 }
3050 }
3051 }
3052
3053 return bIterator;
3054}
3055
3056void
3057RrcAsn1Header::Print(std::ostream& os,
3058 LteRrcSap::RadioResourceConfigDedicated radioResourceConfigDedicated) const
3059{
3060 os << " srbToAddModList: " << std::endl;
3061 auto it = radioResourceConfigDedicated.srbToAddModList.begin();
3062 for (; it != radioResourceConfigDedicated.srbToAddModList.end(); it++)
3063 {
3064 os << " srbIdentity: " << (int)it->srbIdentity << std::endl;
3065 os << " logicalChannelConfig: " << std::endl;
3066 os << " priority: " << (int)it->logicalChannelConfig.priority << std::endl;
3067 os << " prioritizedBitRateKbps: "
3068 << (int)it->logicalChannelConfig.prioritizedBitRateKbps << std::endl;
3069 os << " bucketSizeDurationMs: "
3070 << (int)it->logicalChannelConfig.bucketSizeDurationMs << std::endl;
3071 os << " logicalChannelGroup: " << (int)it->logicalChannelConfig.logicalChannelGroup
3072 << std::endl;
3073 }
3074 os << std::endl;
3075
3076 os << " drbToAddModList: " << std::endl;
3077 auto it2 = radioResourceConfigDedicated.drbToAddModList.begin();
3078 for (; it2 != radioResourceConfigDedicated.drbToAddModList.end(); it2++)
3079 {
3080 os << " epsBearerIdentity: " << (int)it2->epsBearerIdentity << std::endl;
3081 os << " drbIdentity: " << (int)it2->drbIdentity << std::endl;
3082 os << " rlcConfig: " << it2->rlcConfig.choice << std::endl;
3083 os << " logicalChannelIdentity: " << (int)it2->logicalChannelIdentity << std::endl;
3084 os << " logicalChannelConfig: " << std::endl;
3085 os << " priority: " << (int)it2->logicalChannelConfig.priority << std::endl;
3086 os << " prioritizedBitRateKbps: "
3087 << (int)it2->logicalChannelConfig.prioritizedBitRateKbps << std::endl;
3088 os << " bucketSizeDurationMs: "
3089 << (int)it2->logicalChannelConfig.bucketSizeDurationMs << std::endl;
3090 os << " logicalChannelGroup: " << (int)it2->logicalChannelConfig.logicalChannelGroup
3091 << std::endl;
3092 }
3093 os << std::endl;
3094
3095 os << " drbToReleaseList: ";
3096 auto it3 = radioResourceConfigDedicated.drbToReleaseList.begin();
3097 for (; it3 != radioResourceConfigDedicated.drbToReleaseList.end(); it3++)
3098 {
3099 os << (int)*it3 << ", ";
3100 }
3101 os << std::endl;
3102
3103 os << " havePhysicalConfigDedicated: "
3104 << radioResourceConfigDedicated.havePhysicalConfigDedicated << std::endl;
3105
3106 if (radioResourceConfigDedicated.havePhysicalConfigDedicated)
3107 {
3108 os << " physicalConfigDedicated: " << std::endl;
3109
3110 os << " haveSoundingRsUlConfigDedicated: "
3111 << radioResourceConfigDedicated.physicalConfigDedicated.haveSoundingRsUlConfigDedicated
3112 << std::endl;
3113 if (radioResourceConfigDedicated.physicalConfigDedicated.haveSoundingRsUlConfigDedicated)
3114 {
3115 os << " soundingRsUlConfigDedicated: " << std::endl;
3116 os << " type: "
3117 << radioResourceConfigDedicated.physicalConfigDedicated.soundingRsUlConfigDedicated
3118 .type
3119 << std::endl;
3120 os << " srsBandwidth: "
3121 << (int)radioResourceConfigDedicated.physicalConfigDedicated
3123 << std::endl;
3124 os << " srsConfigIndex: "
3125 << (int)radioResourceConfigDedicated.physicalConfigDedicated
3127 << std::endl;
3128 }
3129
3130 os << " haveAntennaInfoDedicated: "
3131 << radioResourceConfigDedicated.physicalConfigDedicated.haveAntennaInfoDedicated
3132 << std::endl;
3133 if (radioResourceConfigDedicated.physicalConfigDedicated.haveAntennaInfoDedicated)
3134 {
3135 os << " antennaInfo Tx mode: "
3136 << (int)radioResourceConfigDedicated.physicalConfigDedicated.antennaInfo
3138 << std::endl;
3139 }
3140 }
3141}
3142
3145 LteRrcSap::SystemInformationBlockType1* systemInformationBlockType1,
3146 Buffer::Iterator bIterator)
3147{
3148 std::bitset<0> bitset0;
3149 int n;
3150
3151 std::bitset<3> sysInfoBlkT1Opts;
3152 bIterator = DeserializeSequence(&sysInfoBlkT1Opts, false, bIterator);
3153
3154 // Deserialize cellAccessRelatedInfo
3155 std::bitset<1> cellAccessRelatedInfoOpts;
3156 bIterator = DeserializeSequence(&cellAccessRelatedInfoOpts, false, bIterator);
3157
3158 // Deserialize plmn-IdentityList
3159 int numPlmnIdentityInfoElements;
3160 bIterator = DeserializeSequenceOf(&numPlmnIdentityInfoElements, 6, 1, bIterator);
3161 for (int i = 0; i < numPlmnIdentityInfoElements; i++)
3162 {
3163 bIterator = DeserializeSequence(&bitset0, false, bIterator);
3164
3165 // plmn-Identity
3166 bIterator = DeserializePlmnIdentity(
3167 &systemInformationBlockType1->cellAccessRelatedInfo.plmnIdentityInfo.plmnIdentity,
3168 bIterator);
3169 }
3170
3171 // Deserialize trackingAreaCode
3172 std::bitset<16> trackingAreaCode;
3173 bIterator = DeserializeBitstring(&trackingAreaCode, bIterator);
3174
3175 // Deserialize cellIdentity
3176 std::bitset<28> cellIdentity;
3177 bIterator = DeserializeBitstring(&cellIdentity, bIterator);
3178 systemInformationBlockType1->cellAccessRelatedInfo.cellIdentity = cellIdentity.to_ulong();
3179
3180 // Deserialize cellBarred
3181 bIterator = DeserializeEnum(2, &n, bIterator);
3182
3183 // Deserialize intraFreqReselection
3184 bIterator = DeserializeEnum(2, &n, bIterator);
3185
3186 // Deserialize csg-Indication
3187 bIterator =
3188 DeserializeBoolean(&systemInformationBlockType1->cellAccessRelatedInfo.csgIndication,
3189 bIterator);
3190
3191 if (cellAccessRelatedInfoOpts[0])
3192 {
3193 // Deserialize csg-Identity
3194 std::bitset<27> csgIdentity;
3195 bIterator = DeserializeBitstring(&csgIdentity, bIterator);
3196 systemInformationBlockType1->cellAccessRelatedInfo.csgIdentity = csgIdentity.to_ulong();
3197 }
3198
3199 // Deserialize cellSelectionInfo
3200 std::bitset<1> qRxLevMinOffsetPresent;
3201 bIterator = DeserializeSequence(&qRxLevMinOffsetPresent, false, bIterator);
3202 bIterator = DeserializeInteger(&n, -70, -22, bIterator); // q-RxLevMin
3203 if (qRxLevMinOffsetPresent[0])
3204 {
3205 // Deserialize qRxLevMinOffset
3206 // ...
3207 }
3208
3209 if (sysInfoBlkT1Opts[2])
3210 {
3211 // Deserialize p-Max
3212 // ...
3213 }
3214
3215 // freqBandIndicator
3216 bIterator = DeserializeInteger(&n, 1, 64, bIterator);
3217
3218 // schedulingInfoList
3219 int numSchedulingInfo;
3220 bIterator = DeserializeSequenceOf(&numSchedulingInfo, MAX_SI_MESSAGE, 1, bIterator);
3221 for (int i = 0; i < numSchedulingInfo; i++)
3222 {
3223 bIterator = DeserializeSequence(&bitset0, false, bIterator);
3224 bIterator = DeserializeEnum(7, &n, bIterator); // si-Periodicity
3225 int numSibType;
3226 bIterator =
3227 DeserializeSequenceOf(&numSibType, MAX_SIB - 1, 0, bIterator); // sib-MappingInfo
3228 for (int j = 0; j < numSibType; j++)
3229 {
3230 bIterator = DeserializeEnum(16, &n, bIterator); // SIB-Type
3231 }
3232 }
3233
3234 if (sysInfoBlkT1Opts[1])
3235 {
3236 // tdd-Config
3237 // ...
3238 }
3239
3240 // si-WindowLength
3241 bIterator = DeserializeEnum(7, &n, bIterator);
3242
3243 // systemInfoValueTag
3244 bIterator = DeserializeInteger(&n, 0, 31, bIterator);
3245
3246 if (sysInfoBlkT1Opts[0])
3247 {
3248 // Deserialize nonCriticalExtension
3249 // ...
3250 }
3251 return bIterator;
3252}
3253
3256 LteRrcSap::SystemInformationBlockType2* systemInformationBlockType2,
3257 Buffer::Iterator bIterator)
3258{
3259 std::bitset<0> bitset0;
3260 int n;
3261
3262 std::bitset<2> sysInfoBlkT2Opts;
3263 bIterator = DeserializeSequence(&sysInfoBlkT2Opts, true, bIterator);
3264 if (sysInfoBlkT2Opts[1])
3265 {
3266 // Deserialize ac-BarringInfo
3267 // ...
3268 }
3269
3270 // Deserialize radioResourceConfigCommon
3272 &systemInformationBlockType2->radioResourceConfigCommon,
3273 bIterator);
3274
3275 // Deserialize ue-TimersAndConstants
3276 bIterator = DeserializeSequence(&bitset0, true, bIterator);
3277 bIterator = DeserializeEnum(8, &n, bIterator); // t300
3278 bIterator = DeserializeEnum(8, &n, bIterator); // t301
3279 bIterator = DeserializeEnum(7, &n, bIterator); // t310
3280 bIterator = DeserializeEnum(8, &n, bIterator); // n310
3281 bIterator = DeserializeEnum(7, &n, bIterator); // t311
3282 bIterator = DeserializeEnum(8, &n, bIterator); // n311
3283
3284 // Deserialize freqInfo
3285 std::bitset<2> freqInfoOpts;
3286 bIterator = DeserializeSequence(&freqInfoOpts, false, bIterator);
3287 if (freqInfoOpts[1])
3288 {
3289 // Deserialize ul-CarrierFreq
3290 bIterator = DeserializeInteger(&n, 0, MAX_EARFCN, bIterator);
3291 systemInformationBlockType2->freqInfo.ulCarrierFreq = n;
3292 }
3293 if (freqInfoOpts[0])
3294 {
3295 // Deserialize ul-Bandwidth
3296 bIterator = DeserializeEnum(6, &n, bIterator);
3297 systemInformationBlockType2->freqInfo.ulBandwidth = EnumToBandwidth(n);
3298 }
3299
3300 // additionalSpectrumEmission
3301 bIterator = DeserializeInteger(&n, 1, 32, bIterator);
3302
3303 if (sysInfoBlkT2Opts[0])
3304 {
3305 // Deserialize mbsfn-SubframeConfigList
3306 // ...
3307 }
3308
3309 // Deserialize timeAlignmentTimerCommon
3310 bIterator = DeserializeEnum(8, &n, bIterator);
3311
3312 return bIterator;
3313}
3314
3317 LteRrcSap::RadioResourceConfigCommon* radioResourceConfigCommon,
3318 Buffer::Iterator bIterator)
3319{
3320 std::bitset<0> bitset0;
3321 int n;
3322
3323 std::bitset<9> rrCfgCommOptions;
3324 bIterator = DeserializeSequence(&rrCfgCommOptions, true, bIterator);
3325
3326 // rach-ConfigCommon
3327 if (rrCfgCommOptions[8])
3328 {
3329 bIterator =
3330 DeserializeRachConfigCommon(&radioResourceConfigCommon->rachConfigCommon, bIterator);
3331 }
3332
3333 // prach-Config
3334 std::bitset<1> prachConfigInfoPresent;
3335 bIterator = DeserializeSequence(&prachConfigInfoPresent, false, bIterator);
3336
3337 // prach-Config -> rootSequenceIndex
3338 bIterator = DeserializeInteger(&n, 0, 1023, bIterator);
3339
3340 // prach-Config -> prach-ConfigInfo
3341 if (prachConfigInfoPresent[0])
3342 {
3343 // ...
3344 }
3345
3346 // pdsch-ConfigCommon
3347 if (rrCfgCommOptions[7])
3348 {
3349 // ...
3350 }
3351
3352 // pusch-ConfigCommon
3353 bIterator = DeserializeSequence(&bitset0, false, bIterator);
3354
3355 // pusch-ConfigCommon -> pusch-ConfigBasic
3356 bIterator = DeserializeSequence(&bitset0, false, bIterator);
3357
3358 // pusch-ConfigCommon -> pusch-ConfigBasic -> n-SB
3359 bIterator = DeserializeInteger(&n, 1, 4, bIterator);
3360
3361 // pusch-ConfigCommon -> pusch-ConfigBasic -> hoppingMode
3362 bIterator = DeserializeEnum(2, &n, bIterator);
3363
3364 // pusch-ConfigCommon -> pusch-ConfigBasic -> pusch-HoppingOffset
3365 bIterator = DeserializeInteger(&n, 0, 98, bIterator);
3366
3367 // pusch-ConfigCommon -> pusch-ConfigBasic -> enable64QAM
3368 bool enable64QAM;
3369 bIterator = DeserializeBoolean(&enable64QAM, bIterator);
3370
3371 // ul-ReferenceSignalsPUSCH
3372 bIterator = DeserializeSequence(&bitset0, false, bIterator);
3373
3374 // groupHoppingEnabled
3375 bool dummyBool;
3376 bIterator = DeserializeBoolean(&dummyBool, bIterator);
3377
3378 // groupAssignmentPUSCH
3379 bIterator = DeserializeInteger(&n, 0, 29, bIterator);
3380
3381 // sequenceHoppingEnabled
3382 bIterator = DeserializeBoolean(&dummyBool, bIterator);
3383
3384 // cyclicShift
3385 bIterator = DeserializeInteger(&n, 0, 7, bIterator);
3386
3387 // phich-Config
3388 if (rrCfgCommOptions[6])
3389 {
3390 // ...
3391 }
3392
3393 // pucch-ConfigCommon
3394 if (rrCfgCommOptions[5])
3395 {
3396 // ...
3397 }
3398
3399 // soundingRS-UL-ConfigCommon
3400 if (rrCfgCommOptions[4])
3401 {
3402 // ...
3403 }
3404
3405 // uplinkPowerControlCommon
3406 if (rrCfgCommOptions[3])
3407 {
3408 // ...
3409 }
3410
3411 // antennaInfoCommon
3412 if (rrCfgCommOptions[2])
3413 {
3414 // ...
3415 }
3416
3417 // p-Max
3418 if (rrCfgCommOptions[1])
3419 {
3420 // ...
3421 }
3422
3423 // tdd-Config
3424 if (rrCfgCommOptions[0])
3425 {
3426 // ...
3427 }
3428
3429 // ul-CyclicPrefixLength
3430 bIterator = DeserializeEnum(2, &n, bIterator);
3431
3432 return bIterator;
3433}
3434
3437 Buffer::Iterator bIterator)
3438{
3439 std::bitset<0> bitset0;
3440 int n;
3441
3442 bIterator = DeserializeSequence(&bitset0, true, bIterator);
3443
3444 // preambleInfo
3445 std::bitset<1> preamblesGroupAConfigPresent;
3446 bIterator = DeserializeSequence(&preamblesGroupAConfigPresent, false, bIterator);
3447
3448 // numberOfRA-Preambles
3449 bIterator = DeserializeEnum(16, &n, bIterator);
3450 switch (n)
3451 {
3452 case 0:
3453 rachConfigCommon->preambleInfo.numberOfRaPreambles = 4;
3454 break;
3455 case 1:
3456 rachConfigCommon->preambleInfo.numberOfRaPreambles = 8;
3457 break;
3458 case 2:
3459 rachConfigCommon->preambleInfo.numberOfRaPreambles = 12;
3460 break;
3461 case 3:
3462 rachConfigCommon->preambleInfo.numberOfRaPreambles = 16;
3463 break;
3464 case 4:
3465 rachConfigCommon->preambleInfo.numberOfRaPreambles = 20;
3466 break;
3467 case 5:
3468 rachConfigCommon->preambleInfo.numberOfRaPreambles = 24;
3469 break;
3470 case 6:
3471 rachConfigCommon->preambleInfo.numberOfRaPreambles = 28;
3472 break;
3473 case 7:
3474 rachConfigCommon->preambleInfo.numberOfRaPreambles = 32;
3475 break;
3476 case 8:
3477 rachConfigCommon->preambleInfo.numberOfRaPreambles = 36;
3478 break;
3479 case 9:
3480 rachConfigCommon->preambleInfo.numberOfRaPreambles = 40;
3481 break;
3482 case 10:
3483 rachConfigCommon->preambleInfo.numberOfRaPreambles = 44;
3484 break;
3485 case 11:
3486 rachConfigCommon->preambleInfo.numberOfRaPreambles = 48;
3487 break;
3488 case 12:
3489 rachConfigCommon->preambleInfo.numberOfRaPreambles = 52;
3490 break;
3491 case 13:
3492 rachConfigCommon->preambleInfo.numberOfRaPreambles = 56;
3493 break;
3494 case 14:
3495 rachConfigCommon->preambleInfo.numberOfRaPreambles = 60;
3496 break;
3497 case 15:
3498 rachConfigCommon->preambleInfo.numberOfRaPreambles = 64;
3499 break;
3500 default:
3501 rachConfigCommon->preambleInfo.numberOfRaPreambles = 4;
3502 }
3503
3504 if (preamblesGroupAConfigPresent[0])
3505 {
3506 // Deserialize preamblesGroupAConfig
3507 // ...
3508 }
3509
3510 // powerRampingParameters
3511 bIterator = DeserializeSequence(&bitset0, false, bIterator);
3512 bIterator = DeserializeEnum(4, &n, bIterator); // powerRampingStep
3513 bIterator = DeserializeEnum(16, &n, bIterator); // preambleInitialReceivedTargetPower
3514
3515 // ra-SupervisionInfo
3516 bIterator = DeserializeSequence(&bitset0, false, bIterator);
3517 bIterator = DeserializeEnum(11, &n, bIterator); // preambleTransMax
3518 switch (n)
3519 {
3520 case 0:
3521 rachConfigCommon->raSupervisionInfo.preambleTransMax = 3;
3522 break;
3523 case 1:
3524 rachConfigCommon->raSupervisionInfo.preambleTransMax = 4;
3525 break;
3526 case 2:
3527 rachConfigCommon->raSupervisionInfo.preambleTransMax = 5;
3528 break;
3529 case 3:
3530 rachConfigCommon->raSupervisionInfo.preambleTransMax = 6;
3531 break;
3532 case 4:
3533 rachConfigCommon->raSupervisionInfo.preambleTransMax = 7;
3534 break;
3535 case 5:
3536 rachConfigCommon->raSupervisionInfo.preambleTransMax = 8;
3537 break;
3538 case 6:
3539 rachConfigCommon->raSupervisionInfo.preambleTransMax = 10;
3540 break;
3541 case 7:
3542 rachConfigCommon->raSupervisionInfo.preambleTransMax = 20;
3543 break;
3544 case 8:
3545 rachConfigCommon->raSupervisionInfo.preambleTransMax = 50;
3546 break;
3547 case 9:
3548 rachConfigCommon->raSupervisionInfo.preambleTransMax = 100;
3549 break;
3550 case 10:
3551 rachConfigCommon->raSupervisionInfo.preambleTransMax = 200;
3552 break;
3553 default:
3554 rachConfigCommon->raSupervisionInfo.preambleTransMax = 0;
3555 }
3556
3557 // ra-ResponseWindowSize
3558 bIterator = DeserializeEnum(8, &n, bIterator);
3559 switch (n)
3560 {
3561 case 0:
3562 rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 2;
3563 break;
3564 case 1:
3565 rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 3;
3566 break;
3567 case 2:
3568 rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 4;
3569 break;
3570 case 3:
3571 rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 5;
3572 break;
3573 case 4:
3574 rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 6;
3575 break;
3576 case 5:
3577 rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 7;
3578 break;
3579 case 6:
3580 rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 8;
3581 break;
3582 case 7:
3583 rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 10;
3584 break;
3585 default:
3586 rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 0;
3587 }
3588
3589 bIterator = DeserializeEnum(8, &n, bIterator); // mac-ContentionResolutionTimer
3590 bIterator = DeserializeInteger(&n, 1, 8, bIterator); // maxHARQ-Msg3Tx
3591
3592 // connEstFailCount
3593 bIterator = DeserializeEnum(8, &n, bIterator);
3594 switch (n)
3595 {
3596 case 1:
3597 rachConfigCommon->txFailParam.connEstFailCount = 1;
3598 break;
3599 case 2:
3600 rachConfigCommon->txFailParam.connEstFailCount = 2;
3601 break;
3602 case 3:
3603 rachConfigCommon->txFailParam.connEstFailCount = 3;
3604 break;
3605 case 4:
3606 rachConfigCommon->txFailParam.connEstFailCount = 4;
3607 break;
3608 default:
3609 rachConfigCommon->txFailParam.connEstFailCount = 1;
3610 }
3611 return bIterator;
3612}
3613
3616 LteRrcSap::RadioResourceConfigCommonSib* radioResourceConfigCommonSib,
3617 Buffer::Iterator bIterator)
3618{
3619 std::bitset<0> bitset0;
3620 int n;
3621
3622 bIterator = DeserializeSequence(&bitset0, true, bIterator);
3623
3624 // rach-ConfigCommon
3625 bIterator =
3626 DeserializeRachConfigCommon(&radioResourceConfigCommonSib->rachConfigCommon, bIterator);
3627
3628 // bcch-Config
3629 bIterator = DeserializeSequence(&bitset0, false, bIterator);
3630 bIterator = DeserializeEnum(4, &n, bIterator); // modificationPeriodCoeff
3631
3632 // pcch-Config
3633 bIterator = DeserializeSequence(&bitset0, false, bIterator);
3634 bIterator = DeserializeEnum(4, &n, bIterator); // defaultPagingCycle
3635 bIterator = DeserializeEnum(8, &n, bIterator); // nB
3636
3637 // prach-Config
3638 std::bitset<1> prachConfigInfoPresent;
3639 bIterator = DeserializeSequence(&prachConfigInfoPresent, false, bIterator);
3640 // prach-Config -> rootSequenceIndex
3641 bIterator = DeserializeInteger(&n, 0, 1023, bIterator);
3642 // prach-Config -> prach-ConfigInfo
3643 if (prachConfigInfoPresent[0])
3644 {
3645 // ...
3646 }
3647
3648 // pdsch-ConfigCommon
3649 bIterator = DeserializeSequence(&bitset0, false, bIterator);
3650 bIterator = DeserializeInteger(&n, -60, 50, bIterator); // referenceSignalPower
3651 bIterator = DeserializeInteger(&n, 0, 3, bIterator); // p-b
3652
3653 // pusch-ConfigCommon
3654 bIterator = DeserializeSequence(&bitset0, false, bIterator);
3655
3656 // pusch-ConfigCommon -> pusch-ConfigBasic
3657 bIterator = DeserializeSequence(&bitset0, false, bIterator);
3658
3659 // pusch-ConfigCommon -> pusch-ConfigBasic -> n-SB
3660 bIterator = DeserializeInteger(&n, 1, 4, bIterator);
3661
3662 // pusch-ConfigCommon -> pusch-ConfigBasic -> hoppingMode
3663 bIterator = DeserializeEnum(2, &n, bIterator);
3664
3665 // pusch-ConfigCommon -> pusch-ConfigBasic -> pusch-HoppingOffset
3666 bIterator = DeserializeInteger(&n, 0, 98, bIterator);
3667
3668 // pusch-ConfigCommon -> pusch-ConfigBasic -> enable64QAM
3669 bool dummyBoolean;
3670 bIterator = DeserializeBoolean(&dummyBoolean, bIterator);
3671
3672 // ul-ReferenceSignalsPUSCH
3673 bIterator = DeserializeSequence(&bitset0, false, bIterator);
3674
3675 // groupHoppingEnabled
3676 bIterator = DeserializeBoolean(&dummyBoolean, bIterator);
3677
3678 // groupAssignmentPUSCH
3679 bIterator = DeserializeInteger(&n, 0, 29, bIterator);
3680
3681 // sequenceHoppingEnabled
3682 bIterator = DeserializeBoolean(&dummyBoolean, bIterator);
3683
3684 // cyclicShift
3685 bIterator = DeserializeInteger(&n, 0, 7, bIterator);
3686
3687 // pucch-ConfigCommon
3688 bIterator = DeserializeEnum(3, &n, bIterator); // deltaPUCCH-Shift
3689 bIterator = DeserializeInteger(&n, 0, 98, bIterator); // nRB-CQI
3690 bIterator = DeserializeInteger(&n, 0, 7, bIterator); // nCS-AN
3691 bIterator = DeserializeInteger(&n, 0, 2047, bIterator); // n1PUCCH-AN
3692
3693 // soundingRS-UL-ConfigCommon
3694 int choice;
3695 bIterator = DeserializeChoice(2, false, &choice, bIterator);
3696 if (choice == 0)
3697 {
3698 bIterator = DeserializeNull(bIterator); // release
3699 }
3700 if (choice == 1)
3701 {
3702 // setup
3703 // ...
3704 }
3705
3706 // uplinkPowerControlCommon
3707 bIterator = DeserializeSequence(&bitset0, false, bIterator);
3708 bIterator = DeserializeInteger(&n, -126, 24, bIterator); // p0-NominalPUSCH
3709 bIterator = DeserializeEnum(8, &n, bIterator); // alpha
3710 bIterator = DeserializeInteger(&n, -127, -96, bIterator); // p0-NominalPUCCH
3711 // deltaFList-PUCCH
3712 bIterator = DeserializeSequence(&bitset0, false, bIterator);
3713 bIterator = DeserializeEnum(3, &n, bIterator); // deltaF-PUCCH-Format1
3714 bIterator = DeserializeEnum(3, &n, bIterator); // deltaF-PUCCH-Format1b
3715 bIterator = DeserializeEnum(4, &n, bIterator); // deltaF-PUCCH-Format2
3716 bIterator = DeserializeEnum(3, &n, bIterator); // deltaF-PUCCH-Format2a
3717 bIterator = DeserializeEnum(3, &n, bIterator); // deltaF-PUCCH-Format2b
3718 bIterator = DeserializeInteger(&n, -1, 6, bIterator); // deltaPreambleMsg3
3719
3720 // ul-CyclicPrefixLength
3721 bIterator = DeserializeEnum(2, &n, bIterator);
3722
3723 return bIterator;
3724}
3725
3728 Buffer::Iterator bIterator)
3729{
3730 int n;
3731 std::bitset<0> b0;
3732 std::bitset<4> measResultOptionalPresent;
3733 // bIterator = DeserializeSequence (&measResultNeighCellsPresent,true,bIterator);
3734 bIterator = DeserializeSequence(&measResultOptionalPresent, true, bIterator);
3735
3736 // Deserialize measId
3737 bIterator = DeserializeInteger(&n, 1, MAX_MEAS_ID, bIterator);
3738 measResults->measId = n;
3739
3740 // Deserialize measResultServCell
3741 bIterator = DeserializeSequence(&b0, false, bIterator);
3742
3743 // Deserialize rsrpResult
3744 bIterator = DeserializeInteger(&n, 0, 97, bIterator);
3745 measResults->measResultPCell.rsrpResult = n;
3746
3747 // Deserialize rsrqResult
3748 bIterator = DeserializeInteger(&n, 0, 34, bIterator);
3749 measResults->measResultPCell.rsrqResult = n;
3750
3751 measResults->haveMeasResultNeighCells = measResultOptionalPresent[0];
3752 measResults->haveMeasResultServFreqList = measResultOptionalPresent[3];
3753 if (measResults->haveMeasResultNeighCells)
3754 {
3755 int measResultNeighCellsChoice;
3756
3757 // Deserialize measResultNeighCells
3758 bIterator = DeserializeChoice(4, false, &measResultNeighCellsChoice, bIterator);
3759
3760 if (measResultNeighCellsChoice == 0)
3761 {
3762 // Deserialize measResultListEUTRA
3763 int numElems;
3764 bIterator = DeserializeSequenceOf(&numElems, MAX_CELL_REPORT, 1, bIterator);
3765
3766 for (int i = 0; i < numElems; i++)
3767 {
3768 LteRrcSap::MeasResultEutra measResultEutra;
3769
3770 std::bitset<1> isCgiInfoPresent;
3771 bIterator = DeserializeSequence(&isCgiInfoPresent, false, bIterator);
3772
3773 // PhysCellId
3774 bIterator = DeserializeInteger(&n, 0, 503, bIterator);
3775 measResultEutra.physCellId = n;
3776
3777 measResultEutra.haveCgiInfo = isCgiInfoPresent[0];
3778 if (isCgiInfoPresent[0])
3779 {
3780 std::bitset<1> havePlmnIdentityList;
3781 bIterator = DeserializeSequence(&havePlmnIdentityList, false, bIterator);
3782
3783 // Deserialize cellGlobalId
3784 bIterator = DeserializeSequence(&b0, false, bIterator);
3785
3786 // Deserialize plmn-Identity
3787 bIterator =
3788 DeserializePlmnIdentity(&measResultEutra.cgiInfo.plmnIdentity, bIterator);
3789
3790 // Deserialize CellIdentity
3791 std::bitset<28> cellId;
3792 bIterator = DeserializeBitstring(&cellId, bIterator);
3793 measResultEutra.cgiInfo.cellIdentity = cellId.to_ulong();
3794
3795 // Deserialize trackingAreaCode
3796 std::bitset<16> trArCo;
3797 bIterator = DeserializeBitstring(&trArCo, bIterator);
3798 measResultEutra.cgiInfo.trackingAreaCode = trArCo.to_ulong();
3799
3800 // Deserialize plmn-IdentityList
3801 if (havePlmnIdentityList[0])
3802 {
3803 int numPlmnElems;
3804 bIterator = DeserializeSequenceOf(&numPlmnElems, 5, 1, bIterator);
3805
3806 for (int j = 0; j < numPlmnElems; j++)
3807 {
3808 uint32_t plmnId;
3809 bIterator = DeserializePlmnIdentity(&plmnId, bIterator);
3810 measResultEutra.cgiInfo.plmnIdentityList.push_back(plmnId);
3811 }
3812 }
3813 }
3814
3815 // Deserialize measResult
3816 std::bitset<2> measResultOpts;
3817 bIterator = DeserializeSequence(&measResultOpts, true, bIterator);
3818
3819 measResultEutra.haveRsrpResult = measResultOpts[1];
3820 if (measResultOpts[1])
3821 {
3822 // Deserialize rsrpResult
3823 bIterator = DeserializeInteger(&n, 0, 97, bIterator);
3824 measResultEutra.rsrpResult = n;
3825 }
3826
3827 measResultEutra.haveRsrqResult = measResultOpts[0];
3828 if (measResultOpts[0])
3829 {
3830 // Deserialize rsrqResult
3831 bIterator = DeserializeInteger(&n, 0, 34, bIterator);
3832 measResultEutra.rsrqResult = n;
3833 }
3834
3835 measResults->measResultListEutra.push_back(measResultEutra);
3836 }
3837 }
3838
3839 if (measResultNeighCellsChoice == 1)
3840 {
3841 // Deserialize measResultListUTRA
3842 // ...
3843 }
3844
3845 if (measResultNeighCellsChoice == 2)
3846 {
3847 // Deserialize measResultListGERAN
3848 // ...
3849 }
3850 if (measResultNeighCellsChoice == 3)
3851 {
3852 // Deserialize measResultsCDMA2000
3853 // ...
3854 }
3855 }
3856 if (measResults->haveMeasResultServFreqList)
3857 {
3858 int numElems;
3859 bIterator = DeserializeSequenceOf(&numElems, MAX_SCELL_REPORT, 1, bIterator);
3860 for (int i = 0; i < numElems; i++)
3861 {
3862 LteRrcSap::MeasResultServFreq measResultServFreq;
3863
3864 // Deserialize MeasResultServFreq-r10
3865 std::bitset<2> measResultScellPresent;
3866 bIterator = DeserializeSequence(&measResultScellPresent, true, bIterator);
3867 measResultServFreq.haveMeasResultSCell = measResultScellPresent[0];
3868 measResultServFreq.haveMeasResultBestNeighCell = measResultScellPresent[1];
3869
3870 // Deserialize servFreqId-r10
3871 int servFreqId;
3872 bIterator = DeserializeInteger(&servFreqId, 0, 7, bIterator);
3873 measResultServFreq.servFreqId = servFreqId;
3874
3875 if (measResultServFreq.haveMeasResultSCell)
3876 {
3877 // Deserialize rsrpResult
3878 bIterator = DeserializeInteger(&n, 0, 97, bIterator);
3879 measResultServFreq.measResultSCell.rsrpResult = n;
3880
3881 // Deserialize rsrqResult
3882 bIterator = DeserializeInteger(&n, 0, 34, bIterator);
3883 measResultServFreq.measResultSCell.rsrqResult = n;
3884 }
3885
3886 if (measResultServFreq.haveMeasResultBestNeighCell)
3887 {
3888 // Deserialize physCellId-r10
3889 bIterator = DeserializeInteger(&n, 0, 503, bIterator);
3890 measResultServFreq.measResultBestNeighCell.physCellId = n;
3891
3892 // Deserialize rsrpResultNCell-r10
3893 bIterator = DeserializeInteger(&n, 0, 97, bIterator);
3894 measResultServFreq.measResultBestNeighCell.rsrpResult = n;
3895
3896 // Deserialize rsrqResultNCell-r10
3897 bIterator = DeserializeInteger(&n, 0, 34, bIterator);
3898 measResultServFreq.measResultBestNeighCell.rsrqResult = n;
3899 }
3900 measResults->measResultServFreqList.push_back(measResultServFreq);
3901 }
3902 }
3903 return bIterator;
3904}
3905
3908{
3909 int n;
3910 std::bitset<1> isMccPresent;
3911 bIterator = DeserializeSequence(&isMccPresent, false, bIterator);
3912
3913 if (isMccPresent[0])
3914 {
3915 // Deserialize mcc
3916 // ...
3917 }
3918
3919 // Deserialize mnc
3920 int mncDigits;
3921 int mnc = 0;
3922 bIterator = DeserializeSequenceOf(&mncDigits, 3, 2, bIterator);
3923
3924 for (int j = mncDigits - 1; j >= 0; j--)
3925 {
3926 bIterator = DeserializeInteger(&n, 0, 9, bIterator);
3927 mnc += n * pow(10, j);
3928 }
3929
3930 *plmnId = mnc;
3931
3932 // cellReservedForOperatorUse
3933 bIterator = DeserializeEnum(2, &n, bIterator);
3934 return bIterator;
3935}
3936
3939{
3940 std::bitset<0> bitset0;
3941 std::bitset<2> bitset2;
3942 std::bitset<11> bitset11;
3943 int n;
3944
3945 // measConfig
3946 bIterator = DeserializeSequence(&bitset11, true, bIterator);
3947
3948 if (bitset11[10])
3949 {
3950 // measObjectToRemoveList
3951 int measObjectToRemoveListElems;
3952 bIterator =
3953 DeserializeSequenceOf(&measObjectToRemoveListElems, MAX_OBJECT_ID, 1, bIterator);
3954
3955 for (int i = 0; i < measObjectToRemoveListElems; i++)
3956 {
3957 bIterator = DeserializeInteger(&n, 1, MAX_OBJECT_ID, bIterator);
3958 measConfig->measObjectToRemoveList.push_back(n);
3959 }
3960 }
3961
3962 if (bitset11[9])
3963 {
3964 // measObjectToAddModList
3965 int measObjectToAddModListElems;
3966 bIterator =
3967 DeserializeSequenceOf(&measObjectToAddModListElems, MAX_OBJECT_ID, 1, bIterator);
3968
3969 for (int i = 0; i < measObjectToAddModListElems; i++)
3970 {
3972
3973 bIterator = DeserializeSequence(&bitset0, false, bIterator);
3974
3975 bIterator = DeserializeInteger(&n, 1, MAX_OBJECT_ID, bIterator);
3976 elem.measObjectId = n;
3977
3978 int measObjectChoice;
3979 bIterator = DeserializeChoice(4, true, &measObjectChoice, bIterator);
3980
3981 switch (measObjectChoice)
3982 {
3983 case 1:
3984 // Deserialize measObjectUTRA
3985 // ...
3986
3987 case 2:
3988 // Deserialize measObjectGERAN
3989 // ...
3990
3991 case 3:
3992 // Deserialize measObjectCDMA2000
3993 // ...
3994 break;
3995
3996 case 0:
3997 default:
3998 // Deserialize measObjectEUTRA
3999 std::bitset<5> measObjectEutraOpts;
4000 bIterator = DeserializeSequence(&measObjectEutraOpts, true, bIterator);
4001
4002 // carrierFreq
4003 bIterator = DeserializeInteger(&n, 0, MAX_EARFCN, bIterator);
4005
4006 // allowedMeasBandwidth
4007 bIterator = DeserializeEnum(6, &n, bIterator);
4009
4010 // presenceAntennaPort1
4011 bIterator =
4013
4014 // neighCellConfig
4015 bIterator = DeserializeBitstring(&bitset2, bIterator);
4016 elem.measObjectEutra.neighCellConfig = bitset2.to_ulong();
4017
4018 // offsetFreq
4019 bIterator = DeserializeQoffsetRange(&elem.measObjectEutra.offsetFreq, bIterator);
4020
4021 if (measObjectEutraOpts[4])
4022 {
4023 // cellsToRemoveList
4024 int numElems;
4025 bIterator = DeserializeSequenceOf(&numElems, MAX_CELL_MEAS, 1, bIterator);
4026
4027 for (int i = 0; i < numElems; i++)
4028 {
4029 bIterator = DeserializeInteger(&n, 1, MAX_CELL_MEAS, bIterator);
4030 elem.measObjectEutra.cellsToRemoveList.push_back(n);
4031 }
4032 }
4033
4034 if (measObjectEutraOpts[3])
4035 {
4036 // cellsToAddModList
4037 int numElems;
4038 bIterator = DeserializeSequenceOf(&numElems, MAX_CELL_MEAS, 1, bIterator);
4039
4040 for (int i = 0; i < numElems; i++)
4041 {
4042 LteRrcSap::CellsToAddMod cellsToAddMod;
4043
4044 bIterator = DeserializeSequence(&bitset0, false, bIterator);
4045
4046 // cellIndex
4047 bIterator = DeserializeInteger(&n, 1, MAX_CELL_MEAS, bIterator);
4048 cellsToAddMod.cellIndex = n;
4049
4050 // PhysCellId
4051 bIterator = DeserializeInteger(&n, 0, 503, bIterator);
4052 cellsToAddMod.physCellId = n;
4053
4054 // cellIndividualOffset
4055 bIterator =
4056 DeserializeQoffsetRange(&cellsToAddMod.cellIndividualOffset, bIterator);
4057
4058 elem.measObjectEutra.cellsToAddModList.push_back(cellsToAddMod);
4059 }
4060 }
4061
4062 if (measObjectEutraOpts[2])
4063 {
4064 // blackCellsToRemoveList
4065 int numElems;
4066 bIterator = DeserializeSequenceOf(&numElems, MAX_CELL_MEAS, 1, bIterator);
4067
4068 for (int i = 0; i < numElems; i++)
4069 {
4070 bIterator = DeserializeInteger(&n, 1, MAX_CELL_MEAS, bIterator);
4071 elem.measObjectEutra.blackCellsToRemoveList.push_back(n);
4072 }
4073 }
4074
4075 if (measObjectEutraOpts[1])
4076 {
4077 // blackCellsToAddModList
4078 int numElems;
4079 bIterator = DeserializeSequenceOf(&numElems, MAX_CELL_MEAS, 1, bIterator);
4080
4081 for (int i = 0; i < numElems; i++)
4082 {
4083 LteRrcSap::BlackCellsToAddMod blackCellsToAddMod;
4084 bIterator = DeserializeSequence(&bitset0, false, bIterator);
4085
4086 bIterator = DeserializeInteger(&n, 1, MAX_CELL_MEAS, bIterator);
4087 blackCellsToAddMod.cellIndex = n;
4088
4089 // PhysCellIdRange
4090 std::bitset<1> isRangePresent;
4091 bIterator = DeserializeSequence(&isRangePresent, false, bIterator);
4092
4093 // start
4094 bIterator = DeserializeInteger(&n, 0, 503, bIterator);
4095 blackCellsToAddMod.physCellIdRange.start = n;
4096
4097 blackCellsToAddMod.physCellIdRange.haveRange = isRangePresent[0];
4098 // initialize range to silence compiler warning
4099 blackCellsToAddMod.physCellIdRange.range = 0;
4100 if (blackCellsToAddMod.physCellIdRange.haveRange)
4101 {
4102 // range
4103 bIterator = DeserializeEnum(16, &n, bIterator);
4104 switch (n)
4105 {
4106 case 0:
4107 blackCellsToAddMod.physCellIdRange.range = 4;
4108 break;
4109 case 1:
4110 blackCellsToAddMod.physCellIdRange.range = 8;
4111 break;
4112 case 2:
4113 blackCellsToAddMod.physCellIdRange.range = 12;
4114 break;
4115 case 3:
4116 blackCellsToAddMod.physCellIdRange.range = 16;
4117 break;
4118 case 4:
4119 blackCellsToAddMod.physCellIdRange.range = 24;
4120 break;
4121 case 5:
4122 blackCellsToAddMod.physCellIdRange.range = 32;
4123 break;
4124 case 6:
4125 blackCellsToAddMod.physCellIdRange.range = 48;
4126 break;
4127 case 7:
4128 blackCellsToAddMod.physCellIdRange.range = 64;
4129 break;
4130 case 8:
4131 blackCellsToAddMod.physCellIdRange.range = 84;
4132 break;
4133 case 9:
4134 blackCellsToAddMod.physCellIdRange.range = 96;
4135 break;
4136 case 10:
4137 blackCellsToAddMod.physCellIdRange.range = 128;
4138 break;
4139 case 11:
4140 blackCellsToAddMod.physCellIdRange.range = 168;
4141 break;
4142 case 12:
4143 blackCellsToAddMod.physCellIdRange.range = 252;
4144 break;
4145 case 13:
4146 blackCellsToAddMod.physCellIdRange.range = 504;
4147 break;
4148 default:
4149 blackCellsToAddMod.physCellIdRange.range = 0;
4150 }
4151 }
4152
4153 elem.measObjectEutra.blackCellsToAddModList.push_back(blackCellsToAddMod);
4154 }
4155 }
4156
4157 elem.measObjectEutra.haveCellForWhichToReportCGI = measObjectEutraOpts[0];
4158 if (measObjectEutraOpts[0])
4159 {
4160 // cellForWhichToReportCGI
4161 bIterator = DeserializeInteger(&n, 0, 503, bIterator);
4163 }
4164 }
4165 measConfig->measObjectToAddModList.push_back(elem);
4166 }
4167 }
4168
4169 if (bitset11[8])
4170 {
4171 // reportConfigToRemoveList
4172 int reportConfigToRemoveListElems;
4173 bIterator = DeserializeSequenceOf(&reportConfigToRemoveListElems,
4175 1,
4176 bIterator);
4177
4178 for (int i = 0; i < reportConfigToRemoveListElems; i++)
4179 {
4180 bIterator = DeserializeInteger(&n, 1, MAX_REPORT_CONFIG_ID, bIterator);
4181 measConfig->reportConfigToRemoveList.push_back(n);
4182 }
4183 }
4184
4185 if (bitset11[7])
4186 {
4187 // reportConfigToAddModList
4188 int reportConfigToAddModListElems;
4189 bIterator = DeserializeSequenceOf(&reportConfigToAddModListElems,
4191 1,
4192 bIterator);
4193
4194 for (int i = 0; i < reportConfigToAddModListElems; i++)
4195 {
4197
4198 bIterator = DeserializeSequence(&bitset0, false, bIterator);
4199 bIterator = DeserializeInteger(&n, 1, MAX_REPORT_CONFIG_ID, bIterator);
4200 elem.reportConfigId = n;
4201
4202 // Deserialize reportConfig
4203 int reportConfigChoice;
4204 bIterator = DeserializeChoice(2, false, &reportConfigChoice, bIterator);
4205
4206 if (reportConfigChoice == 0)
4207 {
4208 // reportConfigEUTRA
4209 bIterator = DeserializeSequence(&bitset0, true, bIterator);
4210
4211 // triggerType
4212 int triggerTypeChoice;
4213 bIterator = DeserializeChoice(2, false, &triggerTypeChoice, bIterator);
4214
4215 if (triggerTypeChoice == 0)
4216 {
4217 // event
4219 bIterator = DeserializeSequence(&bitset0, false, bIterator);
4220
4221 // eventId
4222 int eventIdChoice;
4223 bIterator = DeserializeChoice(5, true, &eventIdChoice, bIterator);
4224
4225 switch (eventIdChoice)
4226 {
4227 case 0:
4229 bIterator = DeserializeSequence(&bitset0, false, bIterator);
4231 bIterator);
4232 break;
4233
4234 case 1:
4236 bIterator = DeserializeSequence(&bitset0, false, bIterator);
4238 bIterator);
4239 break;
4240
4241 case 2:
4243 bIterator = DeserializeSequence(&bitset0, false, bIterator);
4244 bIterator = DeserializeInteger(&n, -30, 30, bIterator);
4245 elem.reportConfigEutra.a3Offset = n;
4246 bIterator =
4248 break;
4249
4250 case 3:
4252 bIterator = DeserializeSequence(&bitset0, false, bIterator);
4254 bIterator);
4255 break;
4256
4257 case 4:
4258 default:
4260 bIterator = DeserializeSequence(&bitset0, false, bIterator);
4262 bIterator);
4264 bIterator);
4265 }
4266
4267 bIterator = DeserializeInteger(&n, 0, 30, bIterator);
4269
4270 bIterator = DeserializeEnum(16, &n, bIterator);
4271 switch (n)
4272 {
4273 case 0:
4275 break;
4276 case 1:
4278 break;
4279 case 2:
4281 break;
4282 case 3:
4284 break;
4285 case 4:
4287 break;
4288 case 5:
4290 break;
4291 case 6:
4293 break;
4294 case 7:
4296 break;
4297 case 8:
4299 break;
4300 case 9:
4302 break;
4303 case 10:
4305 break;
4306 case 11:
4308 break;
4309 case 12:
4310 elem.reportConfigEutra.timeToTrigger = 1024;
4311 break;
4312 case 13:
4313 elem.reportConfigEutra.timeToTrigger = 1280;
4314 break;
4315 case 14:
4316 elem.reportConfigEutra.timeToTrigger = 2560;
4317 break;
4318 case 15:
4319 default:
4320 elem.reportConfigEutra.timeToTrigger = 5120;
4321 break;
4322 }
4323 }
4324
4325 if (triggerTypeChoice == 1)
4326 {
4327 // periodical
4329
4330 bIterator = DeserializeSequence(&bitset0, false, bIterator);
4331 bIterator = DeserializeEnum(2, &n, bIterator);
4332 if (n == 0)
4333 {
4336 }
4337 else
4338 {
4340 }
4341 }
4342
4343 // triggerQuantity
4344 bIterator = DeserializeEnum(2, &n, bIterator);
4345 if (n == 0)
4346 {
4348 }
4349 else
4350 {
4352 }
4353
4354 // reportQuantity
4355 bIterator = DeserializeEnum(2, &n, bIterator);
4356 if (n == 0)
4357 {
4360 }
4361 else
4362 {
4364 }
4365
4366 // maxReportCells
4367 bIterator = DeserializeInteger(&n, 1, MAX_CELL_REPORT, bIterator);
4369
4370 // reportInterval
4371 bIterator = DeserializeEnum(16, &n, bIterator);
4372 switch (n)
4373 {
4374 case 0:
4376 break;
4377 case 1:
4379 break;
4380 case 2:
4382 break;
4383 case 3:
4385 break;
4386 case 4:
4388 break;
4389 case 5:
4391 break;
4392 case 6:
4394 break;
4395 case 7:
4397 break;
4398 case 8:
4400 break;
4401 case 9:
4403 break;
4404 case 10:
4406 break;
4407 case 11:
4409 break;
4410 case 12:
4412 break;
4413 case 13:
4415 break;
4416 case 14:
4418 break;
4419 case 15:
4420 default:
4422 }
4423
4424 // reportAmount
4425 bIterator = DeserializeEnum(8, &n, bIterator);
4426 switch (n)
4427 {
4428 case 0:
4430 break;
4431 case 1:
4433 break;
4434 case 2:
4436 break;
4437 case 3:
4439 break;
4440 case 4:
4442 break;
4443 case 5:
4445 break;
4446 case 6:
4448 break;
4449 default:
4451 }
4452 }
4453
4454 if (reportConfigChoice == 1)
4455 {
4456 // ReportConfigInterRAT
4457 // ...
4458 }
4459
4460 measConfig->reportConfigToAddModList.push_back(elem);
4461 }
4462 }
4463
4464 if (bitset11[6])
4465 {
4466 // measIdToRemoveList
4467 int measIdToRemoveListElems;
4468 bIterator = DeserializeSequenceOf(&measIdToRemoveListElems, MAX_MEAS_ID, 1, bIterator);
4469
4470 for (int i = 0; i < measIdToRemoveListElems; i++)
4471 {
4472 bIterator = DeserializeInteger(&n, 1, MAX_MEAS_ID, bIterator);
4473 measConfig->measIdToRemoveList.push_back(n);
4474 }
4475 }
4476
4477 if (bitset11[5])
4478 {
4479 // measIdToAddModList
4480 int measIdToAddModListElems;
4481 bIterator = DeserializeSequenceOf(&measIdToAddModListElems, MAX_MEAS_ID, 1, bIterator);
4482
4483 for (int i = 0; i < measIdToAddModListElems; i++)
4484 {
4486
4487 bIterator = DeserializeSequence(&bitset0, false, bIterator);
4488
4489 bIterator = DeserializeInteger(&n, 1, MAX_MEAS_ID, bIterator);
4490 elem.measId = n;
4491
4492 bIterator = DeserializeInteger(&n, 1, MAX_OBJECT_ID, bIterator);
4493 elem.measObjectId = n;
4494
4495 bIterator = DeserializeInteger(&n, 1, MAX_REPORT_CONFIG_ID, bIterator);
4496 elem.reportConfigId = n;
4497
4498 measConfig->measIdToAddModList.push_back(elem);
4499 }
4500 }
4501
4502 measConfig->haveQuantityConfig = bitset11[4];
4503 if (measConfig->haveQuantityConfig)
4504 {
4505 // quantityConfig
4506 std::bitset<4> quantityConfigOpts;
4507 bIterator = DeserializeSequence(&quantityConfigOpts, true, bIterator);
4508
4509 if (quantityConfigOpts[3])
4510 {
4511 // quantityConfigEUTRA
4512 bIterator = DeserializeSequence(&bitset0, false, bIterator);
4513 bIterator = DeserializeEnum(16, &n, bIterator);
4514 switch (n)
4515 {
4516 case 0:
4517 measConfig->quantityConfig.filterCoefficientRSRP = 0;
4518 break;
4519 case 1:
4520 measConfig->quantityConfig.filterCoefficientRSRP = 1;
4521 break;
4522 case 2:
4523 measConfig->quantityConfig.filterCoefficientRSRP = 2;
4524 break;
4525 case 3:
4526 measConfig->quantityConfig.filterCoefficientRSRP = 3;
4527 break;
4528 case 4:
4529 measConfig->quantityConfig.filterCoefficientRSRP = 4;
4530 break;
4531 case 5:
4532 measConfig->quantityConfig.filterCoefficientRSRP = 5;
4533 break;
4534 case 6:
4535 measConfig->quantityConfig.filterCoefficientRSRP = 6;
4536 break;
4537 case 7:
4538 measConfig->quantityConfig.filterCoefficientRSRP = 7;
4539 break;
4540 case 8:
4541 measConfig->quantityConfig.filterCoefficientRSRP = 8;
4542 break;
4543 case 9:
4544 measConfig->quantityConfig.filterCoefficientRSRP = 9;
4545 break;
4546 case 10:
4547 measConfig->quantityConfig.filterCoefficientRSRP = 11;
4548 break;
4549 case 11:
4550 measConfig->quantityConfig.filterCoefficientRSRP = 13;
4551 break;
4552 case 12:
4553 measConfig->quantityConfig.filterCoefficientRSRP = 15;
4554 break;
4555 case 13:
4556 measConfig->quantityConfig.filterCoefficientRSRP = 17;
4557 break;
4558 case 14:
4559 measConfig->quantityConfig.filterCoefficientRSRP = 19;
4560 break;
4561 case 15:
4562 measConfig->quantityConfig.filterCoefficientRSRP = 0;
4563 break;
4564 default:
4565 measConfig->quantityConfig.filterCoefficientRSRP = 4;
4566 }
4567 bIterator = DeserializeEnum(16, &n, bIterator);
4568 switch (n)
4569 {
4570 case 0:
4571 measConfig->quantityConfig.filterCoefficientRSRQ = 0;
4572 break;
4573 case 1:
4574 measConfig->quantityConfig.filterCoefficientRSRQ = 1;
4575 break;
4576 case 2:
4577 measConfig->quantityConfig.filterCoefficientRSRQ = 2;
4578 break;
4579 case 3:
4580 measConfig->quantityConfig.filterCoefficientRSRQ = 3;
4581 break;
4582 case 4:
4583 measConfig->quantityConfig.filterCoefficientRSRQ = 4;
4584 break;
4585 case 5:
4586 measConfig->quantityConfig.filterCoefficientRSRQ = 5;
4587 break;
4588 case 6:
4589 measConfig->quantityConfig.filterCoefficientRSRQ = 6;
4590 break;
4591 case 7:
4592 measConfig->quantityConfig.filterCoefficientRSRQ = 7;
4593 break;
4594 case 8:
4595 measConfig->quantityConfig.filterCoefficientRSRQ = 8;
4596 break;
4597 case 9:
4598 measConfig->quantityConfig.filterCoefficientRSRQ = 9;
4599 break;
4600 case 10:
4601 measConfig->quantityConfig.filterCoefficientRSRQ = 11;
4602 break;
4603 case 11:
4604 measConfig->quantityConfig.filterCoefficientRSRQ = 13;
4605 break;
4606 case 12:
4607 measConfig->quantityConfig.filterCoefficientRSRQ = 15;
4608 break;
4609 case 13:
4610 measConfig->quantityConfig.filterCoefficientRSRQ = 17;
4611 break;
4612 case 14:
4613 measConfig->quantityConfig.filterCoefficientRSRQ = 19;
4614 break;
4615 case 15:
4616 measConfig->quantityConfig.filterCoefficientRSRQ = 0;
4617 break;
4618 default:
4619 measConfig->quantityConfig.filterCoefficientRSRQ = 4;
4620 }
4621 }
4622 if (quantityConfigOpts[2])
4623 {
4624 // quantityConfigUTRA
4625 // ...
4626 }
4627 if (quantityConfigOpts[1])
4628 {
4629 // quantityConfigGERAN
4630 // ...
4631 }
4632 if (quantityConfigOpts[0])
4633 {
4634 // quantityConfigCDMA2000
4635 // ...
4636 }
4637 }
4638
4639 measConfig->haveMeasGapConfig = bitset11[3];
4640 if (measConfig->haveMeasGapConfig)
4641 {
4642 // measGapConfig
4643 int measGapConfigChoice;
4644 bIterator = DeserializeChoice(2, false, &measGapConfigChoice, bIterator);
4645 switch (measGapConfigChoice)
4646 {
4647 case 0:
4649 bIterator = DeserializeNull(bIterator);
4650 break;
4651 case 1:
4652 default:
4654 bIterator = DeserializeSequence(&bitset0, false, bIterator);
4655
4656 int gapOffsetChoice;
4657 bIterator = DeserializeChoice(2, true, &gapOffsetChoice, bIterator);
4658 switch (gapOffsetChoice)
4659 {
4660 case 0:
4662 bIterator = DeserializeInteger(&n, 0, 39, bIterator);
4663 measConfig->measGapConfig.gapOffsetValue = n;
4664 break;
4665 case 1:
4666 default:
4668 bIterator = DeserializeInteger(&n, 0, 79, bIterator);
4669 measConfig->measGapConfig.gapOffsetValue = n;
4670 }
4671 }
4672 }
4673
4674 measConfig->haveSmeasure = bitset11[2];
4675 if (measConfig->haveSmeasure)
4676 {
4677 // s-Measure
4678 bIterator = DeserializeInteger(&n, 0, 97, bIterator);
4679 measConfig->sMeasure = n;
4680 }
4681
4682 if (bitset11[1])
4683 {
4684 // preRegistrationInfoHRPD
4685 // ...
4686 }
4687
4688 measConfig->haveSpeedStatePars = bitset11[0];
4689 if (measConfig->haveSpeedStatePars)
4690 {
4691 // speedStatePars
4692 int speedStateParsChoice;
4693 bIterator = DeserializeChoice(2, false, &speedStateParsChoice, bIterator);
4694 switch (speedStateParsChoice)
4695 {
4696 case 0:
4698 bIterator = DeserializeNull(bIterator);
4699 break;
4700 case 1:
4701 default:
4703 bIterator = DeserializeSequence(&bitset0, false, bIterator);
4704
4705 // Deserialize mobilityStateParameters
4706 // Deserialize t-Evaluation
4707 bIterator = DeserializeEnum(8, &n, bIterator);
4708 switch (n)
4709 {
4710 case 0:
4712 break;
4713 case 1:
4715 break;
4716 case 2:
4718 break;
4719 case 3:
4721 break;
4722 case 4:
4724 break;
4725 default:
4727 }
4728 // Deserialize t-HystNormal
4729 bIterator = DeserializeEnum(8, &n, bIterator);
4730 switch (n)
4731 {
4732 case 0:
4734 break;
4735 case 1:
4737 break;
4738 case 2:
4740 break;
4741 case 3:
4743 break;
4744 case 4:
4746 break;
4747 default:
4749 }
4750
4751 bIterator = DeserializeInteger(&n, 1, 16, bIterator);
4753
4754 bIterator = DeserializeInteger(&n, 1, 16, bIterator);
4756
4757 // Deserialize timeToTriggerSf
4758 bIterator = DeserializeEnum(4, &n, bIterator);
4759 measConfig->speedStatePars.timeToTriggerSf.sfMedium = (n + 1) * 25;
4760 bIterator = DeserializeEnum(4, &n, bIterator);
4761 measConfig->speedStatePars.timeToTriggerSf.sfHigh = (n + 1) * 25;
4762 }
4763 }
4764 return bIterator;
4765}
4766
4767//////////////////// RrcConnectionRequest class ////////////////////////
4768
4769// Constructor
4772{
4773 m_mmec = std::bitset<8>(0UL);
4774 m_mTmsi = std::bitset<32>(0UL);
4776 m_spare = std::bitset<1>(0UL);
4777}
4778
4779// Destructor
4781{
4782}
4783
4784TypeId
4786{
4787 static TypeId tid =
4788 TypeId("ns3::RrcConnectionRequestHeader").SetParent<Header>().SetGroupName("Lte");
4789 return tid;
4790}
4791
4792void
4794{
4795 os << "MMEC:" << m_mmec << std::endl;
4796 os << "MTMSI:" << m_mTmsi << std::endl;
4797 os << "EstablishmentCause:" << m_establishmentCause << std::endl;
4798 os << "Spare: " << m_spare << std::endl;
4799}
4800
4801void
4803{
4805
4807
4808 // Serialize RRCConnectionRequest sequence:
4809 // no default or optional fields. Extension marker not present.
4810 SerializeSequence(std::bitset<0>(), false);
4811
4812 // Serialize criticalExtensions choice:
4813 // 2 options, selected: 0 (option: rrcConnectionRequest-r8)
4814 SerializeChoice(2, 0, false);
4815
4816 // Serialize RRCConnectionRequest-r8-IEs sequence:
4817 // no default or optional fields. Extension marker not present.
4818 SerializeSequence(std::bitset<0>(), false);
4819
4820 // Serialize InitialUE-Identity choice:
4821 // 2 options, selected: 0 (option: s-TMSI)
4822 SerializeChoice(2, 0, false);
4823
4824 // Serialize S-TMSI sequence:
4825 // no default or optional fields. Extension marker not present.
4826 SerializeSequence(std::bitset<0>(), false);
4827
4828 // Serialize mmec : MMEC ::= BIT STRING (SIZE (8))
4830
4831 // Serialize m-TMSI ::= BIT STRING (SIZE (32))
4833
4834 // Serialize establishmentCause : EstablishmentCause ::= ENUMERATED
4836
4837 // Serialize spare : BIT STRING (SIZE (1))
4838 SerializeBitstring(std::bitset<1>());
4839
4840 // Finish serialization
4842}
4843
4846{
4847 std::bitset<1> dummy;
4848 std::bitset<0> optionalOrDefaultMask;
4849 int selectedOption;
4850
4851 bIterator = DeserializeUlCcchMessage(bIterator);
4852
4853 // Deserialize RCConnectionRequest sequence
4854 bIterator = DeserializeSequence(&optionalOrDefaultMask, false, bIterator);
4855
4856 // Deserialize criticalExtensions choice:
4857 bIterator = DeserializeChoice(2, false, &selectedOption, bIterator);
4858
4859 // Deserialize RRCConnectionRequest-r8-IEs sequence
4860 bIterator = DeserializeSequence(&optionalOrDefaultMask, false, bIterator);
4861
4862 // Deserialize InitialUE-Identity choice
4863 bIterator = DeserializeChoice(2, false, &selectedOption, bIterator);
4864
4865 // Deserialize S-TMSI sequence
4866 bIterator = DeserializeSequence(&optionalOrDefaultMask, false, bIterator);
4867
4868 // Deserialize mmec
4869 bIterator = DeserializeBitstring(&m_mmec, bIterator);
4870
4871 // Deserialize m-TMSI
4872 bIterator = DeserializeBitstring(&m_mTmsi, bIterator);
4873
4874 // Deserialize establishmentCause
4875 bIterator = DeserializeEnum(8, &selectedOption, bIterator);
4876
4877 // Deserialize spare
4878 bIterator = DeserializeBitstring(&dummy, bIterator);
4879
4880 return GetSerializedSize();
4881}
4882
4883void
4885{
4886 m_mTmsi = std::bitset<32>((uint32_t)msg.ueIdentity);
4887 m_mmec = std::bitset<8>((uint32_t)(msg.ueIdentity >> 32));
4888 m_isDataSerialized = false;
4889}
4890
4893{
4895 msg.ueIdentity = (((uint64_t)m_mmec.to_ulong()) << 32) | (m_mTmsi.to_ulong());
4896
4897 return msg;
4898}
4899
4900std::bitset<8>
4902{
4903 return m_mmec;
4904}
4905
4906std::bitset<32>
4908{
4909 return m_mTmsi;
4910}
4911
4912//////////////////// RrcConnectionSetup class ////////////////////////
4914{
4915}
4916
4918{
4919}
4920
4921void
4922RrcConnectionSetupHeader::Print(std::ostream& os) const
4923{
4924 os << "rrcTransactionIdentifier: " << (int)m_rrcTransactionIdentifier << std::endl;
4925 os << "radioResourceConfigDedicated:" << std::endl;
4927}
4928
4929void
4931{
4933
4935
4936 SerializeInteger(15, 0, 15);
4937
4938 // Serialize RRCConnectionSetup sequence:
4939 // no default or optional fields. Extension marker not present.
4940 SerializeSequence(std::bitset<0>(), false);
4941
4942 // Serialize rrc-TransactionIdentifier ::=INTEGER (0..3)
4944
4945 // Serialize criticalExtensions choice:
4946 // 2 options, selected: 0 (option: c1)
4947 SerializeChoice(2, 0, false);
4948
4949 // Serialize c1 choice:
4950 // 8 options, selected: 0 (option: rrcConnectionSetup-r8)
4951 SerializeChoice(8, 0, false);
4952
4953 // Serialize rrcConnectionSetup-r8 sequence
4954 // 1 optional fields (not present). Extension marker not present.
4955 SerializeSequence(std::bitset<1>(0), false);
4956
4957 // Serialize RadioResourceConfigDedicated sequence
4959
4960 // Serialize nonCriticalExtension sequence
4961 // 2 optional fields, none present. No extension marker.
4962 SerializeSequence(std::bitset<2>(0), false);
4963
4964 // Finish serialization
4966}
4967
4970{
4971 int n;
4972
4973 std::bitset<0> bitset0;
4974 std::bitset<1> bitset1;
4975 std::bitset<2> bitset2;
4976
4977 bIterator = DeserializeDlCcchMessage(bIterator);
4978
4979 bIterator = DeserializeInteger(&n, 0, 15, bIterator);
4980
4981 // Deserialize RRCConnectionSetup sequence
4982 bIterator = DeserializeSequence(&bitset0, false, bIterator);
4983
4984 // Deserialize rrc-TransactionIdentifier ::=INTEGER (0..3)
4985 bIterator = DeserializeInteger(&n, 0, 3, bIterator);
4987
4988 // Deserialize criticalExtensions choice
4989 int criticalExtensionChoice;
4990 bIterator = DeserializeChoice(2, false, &criticalExtensionChoice, bIterator);
4991 if (criticalExtensionChoice == 1)
4992 {
4993 // Deserialize criticalExtensionsFuture
4994 bIterator = DeserializeSequence(&bitset0, false, bIterator);
4995 }
4996 else if (criticalExtensionChoice == 0)
4997 {
4998 // Deserialize c1
4999 int c1;
5000 bIterator = DeserializeChoice(8, false, &c1, bIterator);
5001
5002 if (c1 > 0)
5003 {
5004 // Deserialize spareX , X:=7..1
5005 bIterator = DeserializeNull(bIterator);
5006 }
5007 else if (c1 == 0)
5008 {
5009 // Deserialize rrcConnectionSetup-r8
5010 // 1 optional fields, no extension marker.
5011 bIterator = DeserializeSequence(&bitset1, false, bIterator);
5012
5013 // Deserialize radioResourceConfigDedicated
5014 bIterator =
5016
5017 if (bitset1[0])
5018 {
5019 // Deserialize nonCriticalExtension
5020 // 2 optional fields, no extension marker.
5021 bIterator = DeserializeSequence(&bitset2, false, bIterator);
5022
5023 // Deserialization of lateR8NonCriticalExtension and nonCriticalExtension
5024 // ...
5025 }
5026 }
5027 }
5028 return GetSerializedSize();
5029}
5030
5031void
5033{
5036 m_isDataSerialized = false;
5037}
5038
5041{
5045 return msg;
5046}
5047
5048uint8_t
5050{
5052}
5053
5054bool
5056{
5058}
5059
5060std::list<LteRrcSap::SrbToAddMod>
5062{
5064}
5065
5066std::list<LteRrcSap::DrbToAddMod>
5068{
5070}
5071
5072std::list<uint8_t>
5074{
5076}
5077
5080{
5082}
5083
5086{
5088}
5089
5090//////////////////// RrcConnectionSetupCompleteHeader class ////////////////////////
5091
5093{
5094}
5095
5097{
5098}
5099
5100void
5102{
5104
5105 // Serialize DCCH message
5107
5108 // Serialize RRCConnectionSetupComplete sequence:
5109 // no default or optional fields. Extension marker not present.
5110 SerializeSequence(std::bitset<0>(), false);
5111
5112 // Serialize rrc-TransactionIdentifier
5114
5115 // Serialize criticalExtensions choice
5116 // 2 options, selected 0 (c1)
5117 SerializeChoice(2, 0, false);
5118
5119 // Choose spare3 NULL
5120 SerializeChoice(4, 1, false);
5121
5122 // Serialize spare3 NULL
5123 SerializeNull();
5124
5125 // Finish serialization
5127}
5128
5131{
5132 std::bitset<0> bitset0;
5133
5134 bIterator = DeserializeUlDcchMessage(bIterator);
5135
5136 bIterator = DeserializeSequence(&bitset0, false, bIterator);
5137
5138 int n;
5139 bIterator = DeserializeInteger(&n, 0, 3, bIterator);
5141
5142 bIterator = DeserializeChoice(2, false, &n, bIterator);
5143
5144 if (n == 1)
5145 {
5146 // Deserialize criticalExtensionsFuture
5147 bIterator = DeserializeSequence(&bitset0, false, bIterator);
5148 }
5149 else if (n == 0)
5150 {
5151 // Deserialize c1
5152 int c1Chosen;
5153 bIterator = DeserializeChoice(4, false, &c1Chosen, bIterator);
5154
5155 if (c1Chosen == 0)
5156 {
5157 // Deserialize rrcConnectionSetupComplete-r8
5158 // ...
5159 }
5160 else
5161 {
5162 bIterator = DeserializeNull(bIterator);
5163 }
5164 }
5165
5166 return GetSerializedSize();
5167}
5168
5169void
5171{
5172 os << "rrcTransactionIdentifier: " << (int)m_rrcTransactionIdentifier << std::endl;
5173}
5174
5175void
5177{
5179 m_isDataSerialized = false;
5180}
5181
5182uint8_t
5184{
5186}
5187
5190{
5193 return msg;
5194}
5195
5196//////////////////// RrcConnectionReconfigurationCompleteHeader class ////////////////////////
5197
5199{
5200}
5201
5203{
5204}
5205
5206void
5208{
5210
5211 // Serialize DCCH message
5213
5214 // Serialize RRCConnectionSetupComplete sequence:
5215 // no default or optional fields. Extension marker not present.
5216 SerializeSequence(std::bitset<0>(), false);
5217
5218 // Serialize rrc-TransactionIdentifier
5220
5221 // Serialize criticalExtensions choice
5222 // 2 options, selected 1 (criticalExtensionsFuture)
5223 SerializeChoice(2, 1, false);
5224
5225 // Choose criticalExtensionsFuture
5226 SerializeSequence(std::bitset<0>(), false);
5227
5228 // Finish serialization
5230}
5231
5234{
5235 std::bitset<0> bitset0;
5236 int n;
5237
5238 bIterator = DeserializeUlDcchMessage(bIterator);
5239 bIterator = DeserializeSequence(&bitset0, false, bIterator);
5240
5241 bIterator = DeserializeInteger(&n, 0, 3, bIterator);
5243
5244 bIterator = DeserializeChoice(2, false, &n, bIterator);
5245
5246 if (n == 1)
5247 {
5248 // Deserialize criticalExtensionsFuture
5249 bIterator = DeserializeSequence(&bitset0, false, bIterator);
5250 }
5251 else if (n == 0)
5252 {
5253 // Deserialize rrcConnectionReconfigurationComplete-r8
5254 // ...
5255 }
5256
5257 return GetSerializedSize();
5258}
5259
5260void
5262{
5263 os << "rrcTransactionIdentifier: " << (int)m_rrcTransactionIdentifier << std::endl;
5264}
5265
5266void
5269{
5271 m_isDataSerialized = false;
5272}
5273
5276{
5279 return msg;
5280}
5281
5282uint8_t
5284{
5286}
5287
5288//////////////////// RrcConnectionReconfigurationHeader class ////////////////////////
5289
5291{
5292}
5293
5295{
5296}
5297
5298void
5300{
5302
5304
5305 // Serialize RRCConnectionSetupComplete sequence:
5306 // no default or optional fields. Extension marker not present.
5307 SerializeSequence(std::bitset<0>(), false);
5308
5309 // Serialize rrc-TransactionIdentifier
5311
5312 // Serialize criticalExtensions choice
5313 // 2 options, selected 0 (c1)
5314 SerializeChoice(2, 0, false);
5315
5316 // Serialize c1 choice
5317 // 8 options, selected 0 (rrcConnectionReconfiguration-r8)
5318 SerializeChoice(8, 0, false);
5319
5320 // Serialize RRCConnectionReconfiguration-r8-IEs sequence:
5321 // 6 optional fields. Extension marker not present.
5322 std::bitset<6> options;
5323 options.set(5, m_haveMeasConfig);
5324 options.set(4, m_haveMobilityControlInfo);
5325 options.set(3, false); // No dedicatedInfoNASList
5326 options.set(2, m_haveRadioResourceConfigDedicated);
5327 options.set(1, false); // No securityConfigHO
5328 options.set(0, m_haveNonCriticalExtension); // Implemented nonCriticalExtension because
5329 // compatibility with R10 - CA
5330 SerializeSequence(options, false);
5331
5332 if (m_haveMeasConfig)
5333 {
5335 }
5336
5338 {
5339 // Serialize MobilityControlInfo
5340
5341 // 4 optional fields, extension marker present.
5342 std::bitset<4> mobCtrlIntoOptional;
5343 mobCtrlIntoOptional.set(3, m_mobilityControlInfo.haveCarrierFreq);
5344 mobCtrlIntoOptional.set(2, m_mobilityControlInfo.haveCarrierBandwidth);
5345 mobCtrlIntoOptional.set(1, false); // No additionalSpectrumEmission
5346 mobCtrlIntoOptional.set(0, m_mobilityControlInfo.haveRachConfigDedicated);
5347 SerializeSequence(mobCtrlIntoOptional, true);
5348
5349 // Serialize targetPhysCellId
5351
5353 {
5354 SerializeSequence(std::bitset<1>(1), false);
5357 }
5358
5360 {
5361 SerializeSequence(std::bitset<1>(1), false);
5362
5363 // Serialize dl-Bandwidth
5365
5366 // Serialize ul-Bandwidth
5368 }
5369
5370 // Serialize t304
5371 SerializeEnum(8, 0);
5372
5373 // Serialize newUE-Identity
5375
5376 // Serialize radioResourceConfigCommon
5378
5380 {
5381 SerializeSequence(std::bitset<0>(), false);
5384 }
5385 }
5386
5388 {
5389 // Serialize RadioResourceConfigDedicated
5391 }
5392
5394 {
5395 // Serialize NonCriticalExtension RRCConnectionReconfiguration-v890-IEs sequence:
5396 // 2 optional fields. Extension marker not present.
5397 std::bitset<2> noncriticalExtension_v890;
5398 noncriticalExtension_v890.set(1, false); // No lateNonCriticalExtension
5399 noncriticalExtension_v890.set(
5400 0,
5401 m_haveNonCriticalExtension); // Implemented nonCriticalExtension because compatibility
5402 // with R10 - CA
5403 // Enable RRCCoonectionReconfiguration-v920-IEs
5404 SerializeSequence(noncriticalExtension_v890, false);
5405
5406 // Serialize NonCriticalExtension RRCConnectionReconfiguration-v920-IEs sequence:
5407 // 3 optional fields. Extension marker not present.
5408 std::bitset<3> noncriticalExtension_v920;
5409 noncriticalExtension_v920.set(1, false); // No otherConfig-r9
5410 noncriticalExtension_v920.set(1, false); // No fullConfig-r9
5411 // Enable RRCCoonectionReconfiguration-v1020-IEs
5412 noncriticalExtension_v920.set(
5413 0,
5414 m_haveNonCriticalExtension); // Implemented nonCriticalExtension because compatibility
5415 // with R10 - CA
5416 SerializeSequence(noncriticalExtension_v920, false);
5417
5419 m_nonCriticalExtension); // Serializing RRCConnectionReconfiguration-r8-IEs
5420 }
5421
5422 // Finish serialization
5424}
5425
5428{
5429 std::bitset<0> bitset0;
5430
5431 bIterator = DeserializeDlDcchMessage(bIterator);
5432
5433 // RRCConnectionReconfiguration sequence
5434 bIterator = DeserializeSequence(&bitset0, false, bIterator);
5435
5436 // rrc-TransactionIdentifier
5437 int n;
5438 bIterator = DeserializeInteger(&n, 0, 3, bIterator);
5440
5441 // criticalExtensions
5442 int sel;
5443 bIterator = DeserializeChoice(2, false, &sel, bIterator);
5444 if (sel == 1)
5445 {
5446 // criticalExtensionsFuture
5447 bIterator = DeserializeSequence(&bitset0, false, bIterator);
5448 }
5449 else if (sel == 0)
5450 {
5451 // c1
5452 int c1Chosen;
5453 bIterator = DeserializeChoice(8, false, &c1Chosen, bIterator);
5454 if (c1Chosen > 0)
5455 {
5456 bIterator = DeserializeNull(bIterator);
5457 }
5458 else if (c1Chosen == 0)
5459 {
5460 // rrcConnectionReconfiguration-r8
5461 std::bitset<6> rrcConnRecOpts;
5462 bIterator = DeserializeSequence(&rrcConnRecOpts, false, bIterator);
5463
5464 m_haveMeasConfig = rrcConnRecOpts[5];
5465 if (m_haveMeasConfig)
5466 {
5467 bIterator = DeserializeMeasConfig(&m_measConfig, bIterator);
5468 }
5469
5470 m_haveMobilityControlInfo = rrcConnRecOpts[4];
5472 {
5473 // mobilityControlInfo
5474 std::bitset<4> mobCtrlOpts;
5475 bIterator = DeserializeSequence(&mobCtrlOpts, true, bIterator);
5476
5477 // PhysCellId
5478 bIterator = DeserializeInteger(&n, 0, 503, bIterator);
5480
5481 // carrierFreq
5482 m_mobilityControlInfo.haveCarrierFreq = mobCtrlOpts[3];
5484 {
5485 std::bitset<1> ulCarrierFreqPresent;
5486 bIterator = DeserializeSequence(&ulCarrierFreqPresent, false, bIterator);
5487
5488 bIterator = DeserializeInteger(&n, 0, MAX_EARFCN, bIterator);
5490
5491 if (ulCarrierFreqPresent[0])
5492 {
5493 bIterator = DeserializeInteger(&n, 0, MAX_EARFCN, bIterator);
5495 }
5496 }
5497
5498 // carrierBandwidth
5501 {
5502 std::bitset<1> ulBandwidthPresent;
5503 bIterator = DeserializeSequence(&ulBandwidthPresent, false, bIterator);
5504
5505 bIterator = DeserializeEnum(16, &n, bIterator);
5507
5508 if (ulBandwidthPresent[0])
5509 {
5510 bIterator = DeserializeEnum(16, &n, bIterator);
5512 }
5513 }
5514
5515 // additionalSpectrumEmission
5516 if (mobCtrlOpts[1])
5517 {
5518 // ...
5519 }
5520
5521 // t304
5522 bIterator = DeserializeEnum(8, &n, bIterator);
5523
5524 // newUE-Identity
5525 std::bitset<16> cRnti;
5526 bIterator = DeserializeBitstring(&cRnti, bIterator);
5527 m_mobilityControlInfo.newUeIdentity = cRnti.to_ulong();
5528
5529 // radioResourceConfigCommon
5532 bIterator);
5533
5536 {
5537 bIterator = DeserializeSequence(&bitset0, false, bIterator);
5538 bIterator = DeserializeInteger(&n, 0, 63, bIterator);
5540 bIterator = DeserializeInteger(&n, 0, 15, bIterator);
5542 }
5543 }
5544
5545 // dedicatedInfoNASList
5546 if (rrcConnRecOpts[3])
5547 {
5548 // ...
5549 }
5550
5551 // radioResourceConfigDedicated
5552 m_haveRadioResourceConfigDedicated = rrcConnRecOpts[2];
5554 {
5556 bIterator);
5557 }
5558
5559 // securityConfigHO
5560 if (rrcConnRecOpts[1])
5561 {
5562 // ...
5563 }
5564
5565 // nonCriticalExtension
5566 m_haveNonCriticalExtension = rrcConnRecOpts[0];
5568 {
5569 bIterator =
5571 // ...
5572 }
5573 }
5574 }
5575
5576 return GetSerializedSize();
5577}
5578
5579void
5581{
5582 os << "rrcTransactionIdentifier: " << (int)m_rrcTransactionIdentifier << std::endl;
5583 os << "haveMeasConfig: " << m_haveMeasConfig << std::endl;
5584 if (m_haveMeasConfig)
5585 {
5587 {
5588 os << " measObjectToRemoveList: ";
5589 std::list<uint8_t> auxList = m_measConfig.measObjectToRemoveList;
5590 auto it = auxList.begin();
5591 for (; it != auxList.end(); it++)
5592 {
5593 os << (int)*it << ", ";
5594 }
5595 os << std::endl;
5596 }
5598 {
5599 os << " reportConfigToRemoveList: ";
5600 std::list<uint8_t> auxList = m_measConfig.reportConfigToRemoveList;
5601 auto it = auxList.begin();
5602 for (; it != auxList.end(); it++)
5603 {
5604 os << (int)*it << ", ";
5605 }
5606 os << std::endl;
5607 }
5608 if (!m_measConfig.measIdToRemoveList.empty())
5609 {
5610 os << " measIdToRemoveList: ";
5611 std::list<uint8_t> auxList = m_measConfig.measIdToRemoveList;
5612 auto it = auxList.begin();
5613 for (; it != auxList.end(); it++)
5614 {
5615 os << (int)*it << ", ";
5616 }
5617 os << std::endl;
5618 }
5619
5621 {
5622 os << " measObjectToAddMod: " << std::endl;
5623 std::list<LteRrcSap::MeasObjectToAddMod> auxList = m_measConfig.measObjectToAddModList;
5624 auto it = auxList.begin();
5625 for (; it != auxList.end(); it++)
5626 {
5627 os << " measObjectId: " << (int)it->measObjectId << std::endl;
5628 os << " carrierFreq: " << (int)it->measObjectEutra.carrierFreq << std::endl;
5629 os << " allowedMeasBandwidth: " << (int)it->measObjectEutra.allowedMeasBandwidth
5630 << std::endl;
5631 os << " presenceAntennaPort1: " << it->measObjectEutra.presenceAntennaPort1
5632 << std::endl;
5633 os << " neighCellConfig: " << (int)it->measObjectEutra.neighCellConfig
5634 << std::endl;
5635 os << " offsetFreq: " << (int)it->measObjectEutra.offsetFreq << std::endl;
5636
5637 if (!it->measObjectEutra.cellsToRemoveList.empty())
5638 {
5639 os << " cellsToRemoveList: ";
5640 std::list<uint8_t> auxList = it->measObjectEutra.cellsToRemoveList;
5641 auto it = auxList.begin();
5642 for (; it != auxList.end(); it++)
5643 {
5644 os << (int)*it << ", ";
5645 }
5646 os << std::endl;
5647 }
5648
5649 if (!it->measObjectEutra.blackCellsToRemoveList.empty())
5650 {
5651 os << " blackCellsToRemoveList: ";
5652 std::list<uint8_t> auxList = it->measObjectEutra.blackCellsToRemoveList;
5653 auto it = auxList.begin();
5654 for (; it != auxList.end(); it++)
5655 {
5656 os << (int)*it << ", ";
5657 }
5658 os << std::endl;
5659 }
5660
5661 if (!it->measObjectEutra.cellsToAddModList.empty())
5662 {
5663 os << " cellsToAddModList: " << std::endl;
5664 std::list<LteRrcSap::CellsToAddMod> auxList =
5665 it->measObjectEutra.cellsToAddModList;
5666 auto it = auxList.begin();
5667 for (; it != auxList.end(); it++)
5668 {
5669 os << " cellIndex: " << (int)it->cellIndex << std::endl;
5670 os << " physCellId: " << (int)it->physCellId << std::endl;
5671 os << " cellIndividualOffset: " << (int)it->cellIndividualOffset
5672 << std::endl;
5673 os << " ------ " << std::endl;
5674 }
5675 }
5676
5677 if (!it->measObjectEutra.blackCellsToAddModList.empty())
5678 {
5679 os << " blackCellsToAddModList: " << std::endl;
5680 std::list<LteRrcSap::BlackCellsToAddMod> auxList =
5681 it->measObjectEutra.blackCellsToAddModList;
5682 auto it = auxList.begin();
5683 for (; it != auxList.end(); it++)
5684 {
5685 os << " cellIndex: " << (int)it->cellIndex << std::endl;
5686 os << " physCellIdRange.start: " << (int)it->physCellIdRange.start
5687 << std::endl;
5688 os << " physCellIdRange.haveRange: " << it->physCellIdRange.haveRange
5689 << std::endl;
5690 os << " physCellIdRange.range: " << (int)it->physCellIdRange.range
5691 << std::endl;
5692 os << " ------ " << std::endl;
5693 }
5694 }
5695
5696 os << " haveCellForWhichToReportCGI: "
5697 << it->measObjectEutra.haveCellForWhichToReportCGI << std::endl;
5698 os << " cellForWhichToReportCGI: "
5699 << (int)it->measObjectEutra.cellForWhichToReportCGI << std::endl;
5700 os << " ------------- " << std::endl;
5701 }
5702 }
5703
5705 {
5706 os << " reportConfigToAddModList: " << std::endl;
5707 std::list<LteRrcSap::ReportConfigToAddMod> auxList =
5709 auto it = auxList.begin();
5710 for (; it != auxList.end(); it++)
5711 {
5712 os << " reportConfigId: " << (int)it->reportConfigId << std::endl;
5713 os << " reportConfigEutra.triggerType "
5714 << (int)it->reportConfigEutra.triggerType << std::endl;
5715 if (it->reportConfigEutra.triggerType == LteRrcSap::ReportConfigEutra::EVENT)
5716 {
5717 os << " reportConfigEutra.eventId " << (int)it->reportConfigEutra.eventId
5718 << std::endl;
5719 if (it->reportConfigEutra.eventId == LteRrcSap::ReportConfigEutra::EVENT_A3)
5720 {
5721 os << " reportConfigEutra.reportOnLeave "
5722 << (int)it->reportConfigEutra.reportOnLeave << std::endl;
5723 os << " reportConfigEutra.a3Offset "
5724 << (int)it->reportConfigEutra.a3Offset << std::endl;
5725 }
5726 else
5727 {
5728 os << " reportConfigEutra.threshold1.choice "
5729 << (int)it->reportConfigEutra.threshold1.choice << std::endl;
5730 os << " reportConfigEutra.threshold1.range "
5731 << (int)it->reportConfigEutra.threshold1.range << std::endl;
5732 if (it->reportConfigEutra.eventId == LteRrcSap::ReportConfigEutra::EVENT_A5)
5733 {
5734 os << " reportConfigEutra.threshold2.choice "
5735 << (int)it->reportConfigEutra.threshold2.choice << std::endl;
5736 os << " reportConfigEutra.threshold2.range "
5737 << (int)it->reportConfigEutra.threshold2.range << std::endl;
5738 }
5739 }
5740 os << " reportConfigEutra.hysteresis "
5741 << (int)it->reportConfigEutra.hysteresis << std::endl;
5742 os << " reportConfigEutra.timeToTrigger "
5743 << (int)it->reportConfigEutra.timeToTrigger << std::endl;
5744 }
5745 else
5746 {
5747 os << " reportConfigEutra.purpose " << (int)it->reportConfigEutra.purpose
5748 << std::endl;
5749 }
5750 os << " reportConfigEutra.triggerQuantity "
5751 << (int)it->reportConfigEutra.triggerQuantity << std::endl;
5752 os << " reportConfigEutra.reportQuantity "
5753 << (int)it->reportConfigEutra.reportQuantity << std::endl;
5754 os << " reportConfigEutra.maxReportCells "
5755 << (int)it->reportConfigEutra.maxReportCells << std::endl;
5756 os << " reportConfigEutra.reportInterval "
5757 << (int)it->reportConfigEutra.reportInterval << std::endl;
5758 os << " reportConfigEutra.reportAmount "
5759 << (int)it->reportConfigEutra.reportAmount << std::endl;
5760 }
5761 }
5762
5763 if (!m_measConfig.measIdToAddModList.empty())
5764 {
5765 os << " measIdToAddModList: " << std::endl;
5766 std::list<LteRrcSap::MeasIdToAddMod> auxList = m_measConfig.measIdToAddModList;
5767 auto it = auxList.begin();
5768 for (; it != auxList.end(); it++)
5769 {
5770 os << " measId: " << (int)it->measId << std::endl;
5771 os << " measObjectId: " << (int)it->measObjectId << std::endl;
5772 os << " reportConfigId: " << (int)it->reportConfigId << std::endl;
5773 os << " ------ " << std::endl;
5774 }
5775 }
5776
5777 os << " haveQuantityConfig: " << m_measConfig.haveQuantityConfig << std::endl;
5779 {
5780 os << " filterCoefficientRSRP: "
5782 os << " filterCoefficientRSRQ:"
5784 }
5785
5786 os << " haveMeasGapConfig: " << m_measConfig.haveMeasGapConfig << std::endl;
5788 {
5789 os << " measGapConfig.type: " << m_measConfig.measGapConfig.type << std::endl;
5790 os << " measGapConfig.gap (gap0/1,value): ("
5792 << (int)m_measConfig.measGapConfig.gapOffsetValue << ")" << std::endl;
5793 }
5794
5795 os << " haveSmeasure: " << m_measConfig.haveSmeasure << std::endl;
5797 {
5798 os << " sMeasure: " << (int)m_measConfig.sMeasure << std::endl;
5799 }
5800
5801 os << " haveSpeedStatePars: " << m_measConfig.haveSpeedStatePars << std::endl;
5803 {
5804 os << " speedStatePars.type: " << m_measConfig.speedStatePars.type << std::endl;
5805 os << " speedStatePars.mobilityStateParameters.tEvaluation: "
5807 os << " speedStatePars.mobilityStateParameters.tHystNormal: "
5809 os << " speedStatePars.mobilityStateParameters.nCellChangeMedium: "
5811 << std::endl;
5812 os << " speedStatePars.mobilityStateParameters.nCellChangeHigh: "
5814 << std::endl;
5815 os << " speedStatePars.timeToTriggerSf.sfMedium: "
5817 os << " speedStatePars.timeToTriggerSf.sfHigh: "
5819 }
5820 }
5821
5822 os << "haveMobilityControlInfo: " << m_haveMobilityControlInfo << std::endl;
5824 {
5825 os << "targetPhysCellId: " << (int)m_mobilityControlInfo.targetPhysCellId << std::endl;
5826 os << "haveCarrierFreq: " << m_mobilityControlInfo.haveCarrierFreq << std::endl;
5828 {
5829 os << " carrierFreq.dlCarrierFreq: "
5830 << (int)m_mobilityControlInfo.carrierFreq.dlCarrierFreq << std::endl;
5831 os << " carrierFreq.dlCarrierFreq: "
5832 << (int)m_mobilityControlInfo.carrierFreq.ulCarrierFreq << std::endl;
5833 }
5834 os << "haveCarrierBandwidth: " << m_mobilityControlInfo.haveCarrierBandwidth << std::endl;
5836 {
5837 os << " carrierBandwidth.dlBandwidth: "
5839 os << " carrierBandwidth.ulBandwidth: "
5841 }
5842 os << "newUeIdentity: " << (int)m_mobilityControlInfo.newUeIdentity << std::endl;
5843 os << "haveRachConfigDedicated: " << m_mobilityControlInfo.haveRachConfigDedicated
5844 << std::endl;
5846 {
5847 os << "raPreambleIndex: "
5849 os << "raPrachMaskIndex: "
5851 }
5852 }
5853 os << "haveRadioResourceConfigDedicated: " << m_haveRadioResourceConfigDedicated << std::endl;
5855 {
5857 }
5858}
5859
5860void
5862{
5872
5873 m_isDataSerialized = false;
5874}
5875
5878{
5880
5882 msg.haveMeasConfig = m_haveMeasConfig;
5883 msg.measConfig = m_measConfig;
5884 msg.haveMobilityControlInfo = m_haveMobilityControlInfo;
5885 msg.mobilityControlInfo = m_mobilityControlInfo;
5886 msg.haveRadioResourceConfigDedicated = m_haveRadioResourceConfigDedicated;
5887 msg.radioResourceConfigDedicated = m_radioResourceConfigDedicated;
5888 msg.haveNonCriticalExtension = m_haveNonCriticalExtension;
5889 msg.nonCriticalExtension = m_nonCriticalExtension;
5890
5891 return msg;
5892}
5893
5894uint8_t
5896{
5898}
5899
5900bool
5902{
5903 return m_haveMeasConfig;
5904}
5905
5908{
5909 return m_measConfig;
5910}
5911
5912bool
5914{
5916}
5917
5920{
5921 return m_mobilityControlInfo;
5922}
5923
5924bool
5926{
5928}
5929
5932{
5934}
5935
5936bool
5938{
5940}
5941
5944{
5946}
5947
5948bool
5950{
5952}
5953
5954std::list<LteRrcSap::SrbToAddMod>
5956{
5958}
5959
5960std::list<LteRrcSap::DrbToAddMod>
5962{
5964}
5965
5966std::list<uint8_t>
5968{
5970}
5971
5974{
5976}
5977
5978//////////////////// HandoverPreparationInfoHeader class ////////////////////////
5979
5981{
5982}
5983
5984void
5986{
5988
5989 // Serialize HandoverPreparationInformation sequence:
5990 // no default or optional fields. Extension marker not present.
5991 SerializeSequence(std::bitset<0>(), false);
5992
5993 // Serialize criticalExtensions choice
5994 // 2 options, selected 0 (c1)
5995 SerializeChoice(2, 0, false);
5996
5997 // Serialize c1 choice
5998 // 8 options, selected 0 (handoverPreparationInformation-r8)
5999 SerializeChoice(8, 0, false);
6000
6001 // Serialize HandoverPreparationInformation-r8-IEs sequence
6002 // 4 optional fields, no extension marker.
6003 std::bitset<4> handoverPrepInfoOpts;
6004 handoverPrepInfoOpts.set(3, true); // as-Config present
6005 handoverPrepInfoOpts.set(2, false); // rrm-Config not present
6006 handoverPrepInfoOpts.set(1, false); // as-Context not present
6007 handoverPrepInfoOpts.set(0, false); // nonCriticalExtension not present
6008 SerializeSequence(handoverPrepInfoOpts, false);
6009
6010 // Serialize ue-RadioAccessCapabilityInfo
6012
6013 // Serialize as-Config
6014 SerializeSequence(std::bitset<0>(), true);
6015
6016 // Serialize sourceMeasConfig
6018
6019 // Serialize sourceRadioResourceConfig
6021
6022 // Serialize sourceSecurityAlgorithmConfig
6023 SerializeSequence(std::bitset<0>(), false);
6024 // cipheringAlgorithm
6025 SerializeEnum(8, 0);
6026 // integrityProtAlgorithm
6027 SerializeEnum(8, 0);
6028
6029 // Serialize sourceUE-Identity
6031
6032 // Serialize sourceMasterInformationBlock
6033 SerializeSequence(std::bitset<0>(), false);
6035 6,
6037 SerializeSequence(std::bitset<0>(), false); // phich-Config sequence
6038 SerializeEnum(2, 0); // phich-Duration
6039 SerializeEnum(4, 0); // phich-Resource
6040 SerializeBitstring(std::bitset<8>(
6042 SerializeBitstring(std::bitset<10>(321)); // spare
6043
6044 // Serialize sourceSystemInformationBlockType1 sequence
6046
6047 // Serialize sourceSystemInformationBlockType2
6049
6050 // Serialize AntennaInfoCommon
6051 SerializeSequence(std::bitset<0>(0), false);
6052 SerializeEnum(4, 0); // antennaPortsCount
6053
6054 // Serialize sourceDlCarrierFreq
6056
6057 // Finish serialization
6059}
6060
6063{
6064 std::bitset<0> bitset0;
6065 int n;
6066
6067 // Deserialize HandoverPreparationInformation sequence
6068 // 0 optional fields, no extension marker
6069 bIterator = DeserializeSequence(&bitset0, false, bIterator);
6070
6071 // Deserialize criticalExtensions choice
6072 int criticalExtensionsChosen;
6073 bIterator = DeserializeChoice(2, false, &criticalExtensionsChosen, bIterator);
6074
6075 if (criticalExtensionsChosen == 1)
6076 {
6077 // Deserialize criticalExtensionsFuture
6078 bIterator = DeserializeSequence(&bitset0, false, bIterator);
6079 }
6080 else if (criticalExtensionsChosen == 0)
6081 {
6082 // Deserialize c1 choice
6083 int c1Chosen;
6084 bIterator = DeserializeChoice(8, false, &c1Chosen, bIterator);
6085 if (c1Chosen > 0)
6086 {
6087 bIterator = DeserializeNull(bIterator);
6088 }
6089 else if (c1Chosen == 0)
6090 {
6091 // Deserialize handoverPreparationInformation-r8
6092 std::bitset<4> handoverPrepInfoOpts;
6093 bIterator = DeserializeSequence(&handoverPrepInfoOpts, false, bIterator);
6094
6095 // Deserialize ue-RadioAccessCapabilityInfo
6096 bIterator = DeserializeSequenceOf(&n, MAX_RAT_CAPABILITIES, 0, bIterator);
6097 for (int i = 0; i < n; i++)
6098 {
6099 // Deserialize UE-CapabilityRAT-Container
6100 // ...
6101 }
6102
6103 if (handoverPrepInfoOpts[3])
6104 {
6105 // Deserialize as-Config sequence
6106 bIterator = DeserializeSequence(&bitset0, true, bIterator);
6107
6108 // Deserialize sourceMeasConfig
6109 bIterator = DeserializeMeasConfig(&m_asConfig.sourceMeasConfig, bIterator);
6110
6111 // Deserialize sourceRadioResourceConfig
6112 bIterator =
6114 bIterator);
6115
6116 // Deserialize sourceSecurityAlgorithmConfig
6117 bIterator = DeserializeSequence(&bitset0, false, bIterator);
6118 bIterator = DeserializeEnum(8, &n, bIterator); // cipheringAlgorithm
6119 bIterator = DeserializeEnum(8, &n, bIterator); // integrityProtAlgorithm
6120
6121 // Deserialize sourceUE-Identity
6122 std::bitset<16> cRnti;
6123 bIterator = DeserializeBitstring(&cRnti, bIterator);
6124 m_asConfig.sourceUeIdentity = cRnti.to_ulong();
6125
6126 // Deserialize sourceMasterInformationBlock
6127 bIterator = DeserializeSequence(&bitset0, false, bIterator);
6128 bIterator = DeserializeEnum(6, &n, bIterator); // dl-Bandwidth
6130
6131 // phich-Config
6132 bIterator = DeserializeSequence(&bitset0, false, bIterator);
6133 bIterator = DeserializeEnum(2, &n, bIterator); // phich-Duration
6134 bIterator = DeserializeEnum(4, &n, bIterator); // phich-Resource
6135
6136 // systemFrameNumber
6137 std::bitset<8> systemFrameNumber;
6138 bIterator = DeserializeBitstring(&systemFrameNumber, bIterator);
6140 systemFrameNumber.to_ulong();
6141 // spare
6142 std::bitset<10> spare;
6143 bIterator = DeserializeBitstring(&spare, bIterator);
6144
6145 // Deserialize sourceSystemInformationBlockType1
6148 bIterator);
6149
6150 // Deserialize sourceSystemInformationBlockType2
6153 bIterator);
6154
6155 // Deserialize antennaInfoCommon
6156 bIterator = DeserializeSequence(&bitset0, false, bIterator);
6157 bIterator = DeserializeEnum(4, &n, bIterator); // antennaPortsCount
6158
6159 // Deserialize sourceDl-CarrierFreq
6160 bIterator = DeserializeInteger(&n, 0, MAX_EARFCN, bIterator);
6162 }
6163 if (handoverPrepInfoOpts[2])
6164 {
6165 // Deserialize rrm-Config
6166 // ...
6167 }
6168 if (handoverPrepInfoOpts[1])
6169 {
6170 // Deserialize as-Context
6171 // ...
6172 }
6173 if (handoverPrepInfoOpts[0])
6174 {
6175 // Deserialize nonCriticalExtension
6176 // ...
6177 }
6178 }
6179 }
6180
6181 return GetSerializedSize();
6182}
6183
6184void
6186{
6188 os << "sourceUeIdentity: " << m_asConfig.sourceUeIdentity << std::endl;
6189 os << "dlBandwidth: " << (int)m_asConfig.sourceMasterInformationBlock.dlBandwidth << std::endl;
6190 os << "systemFrameNumber: " << (int)m_asConfig.sourceMasterInformationBlock.systemFrameNumber
6191 << std::endl;
6192 os << "plmnIdentityInfo.plmnIdentity: "
6195 << std::endl;
6196 os << "cellAccessRelatedInfo.cellIdentity "
6198 << std::endl;
6199 os << "cellAccessRelatedInfo.csgIndication: "
6201 << std::endl;
6202 os << "cellAccessRelatedInfo.csgIdentity: "
6204 << std::endl;
6205 os << "sourceDlCarrierFreq: " << m_asConfig.sourceDlCarrierFreq << std::endl;
6206}
6207
6208void
6210{
6211 m_asConfig = msg.asConfig;
6212 m_isDataSerialized = false;
6213}
6214
6217{
6219 msg.asConfig = m_asConfig;
6220
6221 return msg;
6222}
6223
6226{
6227 return m_asConfig;
6228}
6229
6230//////////////////// RrcConnectionReestablishmentRequestHeader class ////////////////////////
6231
6233{
6234}
6235
6237{
6238}
6239
6240void
6242{
6244
6246
6247 // Serialize RrcConnectionReestablishmentRequest sequence:
6248 // no default or optional fields. Extension marker not present.
6249 SerializeSequence(std::bitset<0>(), false);
6250
6251 // Serialize criticalExtensions choice
6252 // chosen: rrcConnectionReestablishmentRequest-r8
6253 SerializeChoice(2, 0, false);
6254
6255 // Serialize RRCConnectionReestablishmentRequest-r8-IEs sequence
6256 // no default or optional fields. Extension marker not present.
6257 SerializeSequence(std::bitset<0>(), false);
6258
6259 // Serialize ue-Identity
6260 SerializeSequence(std::bitset<0>(), false);
6261 // Serialize c-RNTI
6262 SerializeBitstring(std::bitset<16>(m_ueIdentity.cRnti));
6263 // Serialize physCellId
6265 // Serialize shortMAC-I
6266 SerializeBitstring(std::bitset<16>(0));
6267
6268 // Serialize ReestablishmentCause
6269 switch (m_reestablishmentCause)
6270 {
6272 SerializeEnum(4, 0);
6273 break;
6275 SerializeEnum(4, 1);
6276 break;
6278 SerializeEnum(4, 2);
6279 break;
6280 default:
6281 SerializeEnum(4, 3);
6282 }
6283
6284 // Serialize spare
6285 SerializeBitstring(std::bitset<2>(0));
6286
6287 // Finish serialization
6289}
6290
6293{
6294 std::bitset<0> bitset0;
6295 int n;
6296
6297 bIterator = DeserializeUlCcchMessage(bIterator);
6298
6299 // Deserialize RrcConnectionReestablishmentRequest sequence
6300 // 0 optional fields, no extension marker
6301 bIterator = DeserializeSequence(&bitset0, false, bIterator);
6302
6303 // Deserialize criticalExtensions choice
6304 bIterator = DeserializeChoice(2, false, &n, bIterator);
6305 if (n == 1)
6306 {
6307 // Deserialize criticalExtensionsFuture
6308 bIterator = DeserializeSequence(&bitset0, false, bIterator);
6309 }
6310 else if (n == 0)
6311 {
6312 // Deserialize RRCConnectionReestablishmentRequest-r8-IEs
6313 bIterator = DeserializeSequence(&bitset0, false, bIterator);
6314
6315 // Deserialize ReestabUE-Identity sequence
6316 bIterator = DeserializeSequence(&bitset0, false, bIterator);
6317
6318 // Deserialize c-RNTI
6319 std::bitset<16> cRnti;
6320 bIterator = DeserializeBitstring(&cRnti, bIterator);
6321 m_ueIdentity.cRnti = cRnti.to_ulong();
6322
6323 // Deserialize physCellId
6324 int physCellId;
6325 bIterator = DeserializeInteger(&physCellId, 0, 503, bIterator);
6326 m_ueIdentity.physCellId = physCellId;
6327
6328 // Deserialize shortMAC-I
6329 std::bitset<16> shortMacI;
6330 bIterator = DeserializeBitstring(&shortMacI, bIterator);
6331
6332 // Deserialize ReestablishmentCause
6333 int reestCs;
6334 bIterator = DeserializeEnum(4, &reestCs, bIterator);
6335 switch (reestCs)
6336 {
6337 case 0:
6339 break;
6340 case 1:
6342 break;
6343 case 2:
6345 break;
6346 case 3:
6347 break;
6348 }
6349
6350 // Deserialize spare
6351 std::bitset<2> spare;
6352 bIterator = DeserializeBitstring(&spare, bIterator);
6353 }
6354
6355 return GetSerializedSize();
6356}
6357
6358void
6360{
6361 os << "ueIdentity.cRnti: " << (int)m_ueIdentity.cRnti << std::endl;
6362 os << "ueIdentity.physCellId: " << (int)m_ueIdentity.physCellId << std::endl;
6363 os << "m_reestablishmentCause: " << m_reestablishmentCause << std::endl;
6364}
6365
6366void
6369{
6372 m_isDataSerialized = false;
6373}
6374
6377{
6381
6382 return msg;
6383}
6384
6387{
6388 return m_ueIdentity;
6389}
6390
6393{
6395}
6396
6397//////////////////// RrcConnectionReestablishmentHeader class ////////////////////////
6398
6400{
6401}
6402
6404{
6405}
6406
6407void
6409{
6411
6413
6414 // Serialize RrcConnectionReestablishment sequence:
6415 // no default or optional fields. Extension marker not present.
6416 SerializeSequence(std::bitset<0>(), false);
6417
6418 // Serialize rrc-TransactionIdentifier
6420
6421 // Serialize criticalExtensions choice
6422 SerializeChoice(2, 0, false);
6423
6424 // Serialize c1 choice
6425 SerializeChoice(8, 0, false);
6426
6427 // Serialize RRCConnectionReestablishment-r8-IEs sequence
6428 // 1 optional field, no extension marker
6429 SerializeSequence(std::bitset<1>(0), false);
6430
6431 // Serialize radioResourceConfigDedicated
6433
6434 // Serialize nextHopChainingCount
6435 SerializeInteger(0, 0, 7);
6436
6437 // Finish serialization
6439}
6440
6443{
6444 std::bitset<0> bitset0;
6445 int n;
6446
6447 bIterator = DeserializeDlCcchMessage(bIterator);
6448
6449 // Deserialize RrcConnectionReestablishment sequence
6450 // 0 optional fields, no extension marker
6451 bIterator = DeserializeSequence(&bitset0, false, bIterator);
6452
6453 // Deserialize rrc-TransactionIdentifier
6454 bIterator = DeserializeInteger(&n, 0, 3, bIterator);
6456
6457 // Deserialize criticalExtensions choice
6458 int criticalExtensionsChoice;
6459 bIterator = DeserializeChoice(2, false, &criticalExtensionsChoice, bIterator);
6460 if (criticalExtensionsChoice == 1)
6461 {
6462 // Deserialize criticalExtensionsFuture
6463 bIterator = DeserializeSequence(&bitset0, false, bIterator);
6464 }
6465 else if (criticalExtensionsChoice == 0)
6466 {
6467 // Deserialize c1
6468 int c1;
6469 bIterator = DeserializeChoice(8, false, &c1, bIterator);
6470 if (c1 > 0)
6471 {
6472 bIterator = DeserializeNull(bIterator);
6473 }
6474 else if (c1 == 0)
6475 {
6476 // Deserialize rrcConnectionReestablishment-r8
6477 // 1 optional field
6478 std::bitset<1> nonCriticalExtensionPresent;
6479 bIterator = DeserializeSequence(&nonCriticalExtensionPresent, false, bIterator);
6480
6481 // Deserialize RadioResourceConfigDedicated
6482 bIterator =
6484
6485 // Deserialize nextHopChainingCount
6486 bIterator = DeserializeInteger(&n, 0, 7, bIterator);
6487 }
6488 }
6489
6490 return GetSerializedSize();
6491}
6492
6493void
6495{
6496 os << "rrcTransactionIdentifier: " << (int)m_rrcTransactionIdentifier << std::endl;
6497 os << "RadioResourceConfigDedicated: " << std::endl;
6499}
6500
6501void
6503{
6506 m_isDataSerialized = false;
6507}
6508
6511{
6515 return msg;
6516}
6517
6518uint8_t
6520{
6522}
6523
6526{
6528}
6529
6530//////////////////// RrcConnectionReestablishmentCompleteHeader class ////////////////////////
6531
6533{
6534}
6535
6536void
6538{
6540
6541 // Serialize DCCH message
6543
6544 // Serialize RrcConnectionReestablishmentComplete sequence:
6545 // no default or optional fields. Extension marker not present.
6546 SerializeSequence(std::bitset<0>(), false);
6547
6548 // Serialize rrc-TransactionIdentifier
6550
6551 // Serialize criticalExtensions choice
6552 SerializeChoice(2, 0, false);
6553
6554 // Serialize rrcConnectionReestablishmentComplete-r8 sequence
6555 // 1 optional field (not present), no extension marker.
6556 SerializeSequence(std::bitset<1>(0), false);
6557
6558 // Finish serialization
6560}
6561
6564{
6565 std::bitset<0> bitset0;
6566 int n;
6567
6568 bIterator = DeserializeUlDcchMessage(bIterator);
6569
6570 // Deserialize RrcConnectionReestablishmentComplete sequence
6571 // 0 optional fields, no extension marker
6572 bIterator = DeserializeSequence(&bitset0, false, bIterator);
6573
6574 // Deserialize rrc-TransactionIdentifier
6575 bIterator = DeserializeInteger(&n, 0, 3, bIterator);
6577
6578 // Deserialize criticalExtensions choice
6579 int criticalExtensionsChoice;
6580 bIterator = DeserializeChoice(2, false, &criticalExtensionsChoice, bIterator);
6581 if (criticalExtensionsChoice == 1)
6582 {
6583 // Deserialize criticalExtensionsFuture
6584 bIterator = DeserializeSequence(&bitset0, false, bIterator);
6585 }
6586 else if (criticalExtensionsChoice == 0)
6587 {
6588 // Deserialize rrcConnectionReestablishmentComplete-r8
6589 std::bitset<1> opts;
6590 bIterator = DeserializeSequence(&opts, false, bIterator);
6591 if (opts[0])
6592 {
6593 // Deserialize RRCConnectionReestablishmentComplete-v920-IEs
6594 // ...
6595 }
6596 }
6597
6598 return GetSerializedSize();
6599}
6600
6601void
6603{
6604 os << "rrcTransactionIdentifier: " << (int)m_rrcTransactionIdentifier << std::endl;
6605}
6606
6607void
6610{
6612 m_isDataSerialized = false;
6613}
6614
6617{
6620 return msg;
6621}
6622
6623uint8_t
6625{
6627}
6628
6629//////////////////// RrcConnectionReestablishmentRejectHeader class ////////////////////////
6630
6632{
6633}
6634
6636{
6637}
6638
6639void
6641{
6643
6644 // Serialize CCCH message
6646
6647 // Serialize RrcConnectionReestablishmentReject sequence:
6648 // no default or optional fields. Extension marker not present.
6649 SerializeSequence(std::bitset<0>(), false);
6650
6651 // Serialize criticalExtensions choice
6652 SerializeChoice(2, 0, false);
6653
6654 // Serialize RRCConnectionReestablishmentReject-r8-IEs sequence
6655 // 1 optional field (not present), no extension marker.
6656 SerializeSequence(std::bitset<1>(0), false);
6657
6658 // Finish serialization
6660}
6661
6664{
6665 std::bitset<0> bitset0;
6666
6667 bIterator = DeserializeDlCcchMessage(bIterator);
6668
6669 // Deserialize RrcConnectionReestablishmentReject sequence
6670 // 0 optional fields, no extension marker
6671 bIterator = DeserializeSequence(&bitset0, false, bIterator);
6672
6673 // Deserialize criticalExtensions choice
6674 int criticalExtensionsChoice;
6675 bIterator = DeserializeChoice(2, false, &criticalExtensionsChoice, bIterator);
6676 if (criticalExtensionsChoice == 1)
6677 {
6678 // Deserialize criticalExtensionsFuture
6679 bIterator = DeserializeSequence(&bitset0, false, bIterator);
6680 }
6681 else if (criticalExtensionsChoice == 0)
6682 {
6683 // Deserialize rrcConnectionReestablishmentReject-r8
6684 std::bitset<1> opts;
6685 bIterator = DeserializeSequence(&opts, false, bIterator);
6686 if (opts[0])
6687 {
6688 // Deserialize RRCConnectionReestablishmentReject-v8a0-IEs
6689 // ...
6690 }
6691 }
6692
6693 return GetSerializedSize();
6694}
6695
6696void
6698{
6699}
6700
6701void
6704{
6706 m_isDataSerialized = false;
6707}
6708
6711{
6713}
6714
6715//////////////////// RrcConnectionReleaseHeader class ////////////////////////
6716
6718{
6719}
6720
6722{
6723}
6724
6725void
6727{
6729
6730 // Serialize DCCH message
6732
6733 // Serialize RrcConnectionRelease sequence:
6734 // no default or optional fields. Extension marker not present.
6735 SerializeSequence(std::bitset<0>(), false);
6736
6737 // Serialize rrc-TransactionIdentifier
6739
6740 // Serialize criticalExtensions choice
6741 SerializeChoice(2, 0, false);
6742
6743 // Serialize c1 choice
6744 SerializeChoice(4, 0, false);
6745
6746 // Serialize RRCConnectionRelease-r8-IEs sequence
6747 // 3 optional field (not present), no extension marker.
6748 SerializeSequence(std::bitset<3>(0), false);
6749
6750 // Serialize ReleaseCause
6751 SerializeEnum(4, 1);
6752
6753 // Finish serialization
6755}
6756
6759{
6760 std::bitset<0> bitset0;
6761 int n;
6762
6763 bIterator = DeserializeDlDcchMessage(bIterator);
6764
6765 // Deserialize RrcConnectionRelease sequence
6766 // 0 optional fields, no extension marker
6767 bIterator = DeserializeSequence(&bitset0, false, bIterator);
6768
6769 // Deserialize rrc-TransactionIdentifier
6770 bIterator = DeserializeInteger(&n, 0, 3, bIterator);
6772
6773 // Deserialize criticalExtensions choice
6774 int criticalExtensionsChoice;
6775 bIterator = DeserializeChoice(2, false, &criticalExtensionsChoice, bIterator);
6776 if (criticalExtensionsChoice == 1)
6777 {
6778 // Deserialize criticalExtensionsFuture
6779 bIterator = DeserializeSequence(&bitset0, false, bIterator);
6780 }
6781 else if (criticalExtensionsChoice == 0)
6782 {
6783 // Deserialize c1
6784 int c1Choice;
6785 bIterator = DeserializeChoice(4, false, &c1Choice, bIterator);
6786
6787 if (c1Choice == 0)
6788 {
6789 // Deserialize RRCConnectionRelease-r8-IEs
6790 std::bitset<3> opts;
6791 bIterator = DeserializeSequence(&opts, false, bIterator);
6792
6793 // Deserialize releaseCause
6794 bIterator = DeserializeEnum(4, &n, bIterator);
6795
6796 if (opts[2])
6797 {
6798 // Deserialize redirectedCarrierInfo
6799 // ...
6800 }
6801 if (opts[1])
6802 {
6803 // Deserialize idleModeMobilityControlInfo
6804 // ...
6805 }
6806 if (opts[0])
6807 {
6808 // Deserialize nonCriticalExtension
6809 // ...
6810 }
6811 }
6812
6813 else
6814 {
6815 bIterator = DeserializeNull(bIterator);
6816 }
6817 }
6818
6819 return GetSerializedSize();
6820}
6821
6822void
6824{
6825}
6826
6827void
6829{
6831 m_isDataSerialized = false;
6832}
6833
6836{
6838}
6839
6840//////////////////// RrcConnectionRejectHeader class ////////////////////////
6841
6843{
6844}
6845
6847{
6848}
6849
6850void
6852{
6854
6855 // Serialize CCCH message
6857
6858 // Serialize RrcConnectionReject sequence:
6859 // no default or optional fields. Extension marker not present.
6860 SerializeSequence(std::bitset<0>(), false);
6861
6862 // Serialize criticalExtensions choice
6863 SerializeChoice(2, 0, false);
6864
6865 // Serialize c1 choice
6866 SerializeChoice(4, 0, false);
6867
6868 // Serialize rrcConnectionReject-r8 sequence
6869 // 1 optional field (not present), no extension marker.
6870 SerializeSequence(std::bitset<1>(0), false);
6871
6872 // Serialize waitTime
6874
6875 // Finish serialization
6877}
6878
6881{
6882 std::bitset<0> bitset0;
6883 int n;
6884
6885 bIterator = DeserializeDlCcchMessage(bIterator);
6886
6887 // Deserialize RrcConnectionReject sequence
6888 // 0 optional fields, no extension marker
6889 bIterator = DeserializeSequence(&bitset0, false, bIterator);
6890
6891 // Deserialize criticalExtensions choice
6892 int criticalExtensionsChoice;
6893 bIterator = DeserializeChoice(2, false, &criticalExtensionsChoice, bIterator);
6894 if (criticalExtensionsChoice == 1)
6895 {
6896 // Deserialize criticalExtensionsFuture
6897 bIterator = DeserializeSequence(&bitset0, false, bIterator);
6898 }
6899 else if (criticalExtensionsChoice == 0)
6900 {
6901 // Deserialize c1 choice
6902 int c1Choice;
6903 bIterator = DeserializeChoice(4, false, &c1Choice, bIterator);
6904
6905 if (c1Choice > 0)
6906 {
6907 bIterator = DeserializeNull(bIterator);
6908 }
6909 else if (c1Choice == 0)
6910 {
6911 // Deserialize rrcConnectionReject-r8
6912 std::bitset<1> opts;
6913 bIterator = DeserializeSequence(&opts, false, bIterator);
6914
6915 bIterator = DeserializeInteger(&n, 1, 16, bIterator);
6917
6918 if (opts[0])
6919 {
6920 // Deserialize RRCConnectionReject-v8a0-IEs
6921 // ...
6922 }
6923 }
6924 }
6925
6926 return GetSerializedSize();
6927}
6928
6929void
6931{
6932 os << "wait time: " << (int)m_rrcConnectionReject.waitTime << std::endl;
6933}
6934
6935void
6937{
6939 m_isDataSerialized = false;
6940}
6941
6944{
6945 return m_rrcConnectionReject;
6946}
6947
6948//////////////////// MeasurementReportHeader class ////////////////////////
6949
6951{
6952}
6953
6955{
6956}
6957
6958void
6960{
6962
6963 // Serialize DCCH message
6965
6966 // Serialize MeasurementReport sequence:
6967 // no default or optional fields. Extension marker not present.
6968 SerializeSequence(std::bitset<0>(), false);
6969
6970 // Serialize criticalExtensions choice:
6971 // c1 chosen
6972 SerializeChoice(2, 0, false);
6973
6974 // Serialize c1 choice
6975 // measurementReport-r8 chosen
6976 SerializeChoice(8, 0, false);
6977
6978 // Serialize MeasurementReport-r8-IEs sequence:
6979 // 1 optional fields, not present. Extension marker not present.
6980 SerializeSequence(std::bitset<1>(0), false);
6981
6982 // Serialize measResults
6984
6985 // Finish serialization
6987}
6988
6991{
6992 std::bitset<0> bitset0;
6993
6994 bIterator = DeserializeSequence(&bitset0, false, bIterator);
6995
6996 bIterator = DeserializeUlDcchMessage(bIterator);
6997
6998 int criticalExtensionsChoice;
6999 bIterator = DeserializeChoice(2, false, &criticalExtensionsChoice, bIterator);
7000
7001 if (criticalExtensionsChoice == 1)
7002 {
7003 // Deserialize criticalExtensionsFuture
7004 bIterator = DeserializeSequence(&bitset0, false, bIterator);
7005 }
7006 else if (criticalExtensionsChoice == 0)
7007 {
7008 // Deserialize c1
7009 int c1Choice;
7010 bIterator = DeserializeChoice(8, false, &c1Choice, bIterator);
7011
7012 if (c1Choice > 0)
7013 {
7014 bIterator = DeserializeNull(bIterator);
7015 }
7016 else
7017 {
7018 // Deserialize measurementReport-r8
7019 std::bitset<1> isNonCriticalExtensionPresent;
7020 bIterator = DeserializeSequence(&isNonCriticalExtensionPresent, false, bIterator);
7021
7022 // Deserialize measResults
7024
7025 if (isNonCriticalExtensionPresent[0])
7026 {
7027 // Deserialize nonCriticalExtension MeasurementReport-v8a0-IEs
7028 // ...
7029 }
7030 }
7031 }
7032
7033 return GetSerializedSize();
7034}
7035
7036void
7037MeasurementReportHeader::Print(std::ostream& os) const
7038{
7039 os << "measId = " << (int)m_measurementReport.measResults.measId << std::endl;
7040 os << "rsrpResult = " << (int)m_measurementReport.measResults.measResultPCell.rsrpResult
7041 << std::endl;
7042 os << "rsrqResult = " << (int)m_measurementReport.measResults.measResultPCell.rsrqResult
7043 << std::endl;
7044 os << "haveMeasResultNeighCells = "
7046
7048 {
7049 std::list<LteRrcSap::MeasResultEutra> measResultListEutra =
7051 auto it = measResultListEutra.begin();
7052 for (; it != measResultListEutra.end(); it++)
7053 {
7054 os << " physCellId =" << (int)it->physCellId << std::endl;
7055 os << " haveCgiInfo =" << it->haveCgiInfo << std::endl;
7056 if (it->haveCgiInfo)
7057 {
7058 os << " plmnIdentity = " << (int)it->cgiInfo.plmnIdentity << std::endl;
7059 os << " cellIdentity = " << (int)it->cgiInfo.cellIdentity << std::endl;
7060 os << " trackingAreaCode = " << (int)it->cgiInfo.trackingAreaCode << std::endl;
7061 os << " havePlmnIdentityList = " << !it->cgiInfo.plmnIdentityList.empty()
7062 << std::endl;
7063 if (!it->cgiInfo.plmnIdentityList.empty())
7064 {
7065 for (auto it2 = it->cgiInfo.plmnIdentityList.begin();
7066 it2 != it->cgiInfo.plmnIdentityList.end();
7067 it2++)
7068 {
7069 os << " plmnId : " << *it2 << std::endl;
7070 }
7071 }
7072 }
7073
7074 os << " haveRsrpResult =" << it->haveRsrpResult << std::endl;
7075 if (it->haveRsrpResult)
7076 {
7077 os << " rsrpResult =" << (int)it->rsrpResult << std::endl;
7078 }
7079
7080 os << " haveRsrqResult =" << it->haveRsrqResult << std::endl;
7081 if (it->haveRsrqResult)
7082 {
7083 os << " rsrqResult =" << (int)it->rsrqResult << std::endl;
7084 }
7085 }
7086 }
7087}
7088
7089void
7091{
7092 m_measurementReport = msg;
7093 m_isDataSerialized = false;
7094}
7095
7098{
7100 msg = m_measurementReport;
7101 return msg;
7102}
7103
7104/////////////////// RrcUlDcchMessage //////////////////////////////////
7106 : RrcAsn1Header()
7107{
7108}
7109
7111{
7112}
7113
7116{
7117 DeserializeUlDcchMessage(bIterator);
7118 return 1;
7119}
7120
7121void
7122RrcUlDcchMessage::Print(std::ostream& os) const
7123{
7124 std::cout << "UL DCCH MSG TYPE: " << m_messageType << std::endl;
7125}
7126
7127void
7129{
7131}
7132
7135{
7136 std::bitset<0> bitset0;
7137 int n;
7138
7139 bIterator = DeserializeSequence(&bitset0, false, bIterator);
7140 bIterator = DeserializeChoice(2, false, &n, bIterator);
7141 if (n == 1)
7142 {
7143 // Deserialize messageClassExtension
7144 bIterator = DeserializeSequence(&bitset0, false, bIterator);
7145 m_messageType = -1;
7146 }
7147 else if (n == 0)
7148 {
7149 // Deserialize c1
7150 bIterator = DeserializeChoice(16, false, &m_messageType, bIterator);
7151 }
7152
7153 return bIterator;
7154}
7155
7156void
7158{
7159 SerializeSequence(std::bitset<0>(), false);
7160 // Choose c1
7161 SerializeChoice(2, 0, false);
7162 // Choose message type
7163 SerializeChoice(16, messageType, false);
7164}
7165
7166/////////////////// RrcDlDcchMessage //////////////////////////////////
7168 : RrcAsn1Header()
7169{
7170}
7171
7173{
7174}
7175
7178{
7179 DeserializeDlDcchMessage(bIterator);
7180 return 1;
7181}
7182
7183void
7184RrcDlDcchMessage::Print(std::ostream& os) const
7185{
7186 std::cout << "DL DCCH MSG TYPE: " << m_messageType << std::endl;
7187}
7188
7189void
7191{
7193}
7194
7197{
7198 std::bitset<0> bitset0;
7199 int n;
7200
7201 bIterator = DeserializeSequence(&bitset0, false, bIterator);
7202 bIterator = DeserializeChoice(2, false, &n, bIterator);
7203 if (n == 1)
7204 {
7205 // Deserialize messageClassExtension
7206 bIterator = DeserializeSequence(&bitset0, false, bIterator);
7207 m_messageType = -1;
7208 }
7209 else if (n == 0)
7210 {
7211 // Deserialize c1
7212 bIterator = DeserializeChoice(16, false, &m_messageType, bIterator);
7213 }
7214
7215 return bIterator;
7216}
7217
7218void
7220{
7221 SerializeSequence(std::bitset<0>(), false);
7222 // Choose c1
7223 SerializeChoice(2, 0, false);
7224 // Choose message type
7225 SerializeChoice(16, messageType, false);
7226}
7227
7228/////////////////// RrcUlCcchMessage //////////////////////////////////
7230 : RrcAsn1Header()
7231{
7232}
7233
7235{
7236}
7237
7240{
7241 DeserializeUlCcchMessage(bIterator);
7242 return 1;
7243}
7244
7245void
7246RrcUlCcchMessage::Print(std::ostream& os) const
7247{
7248 std::cout << "UL CCCH MSG TYPE: " << m_messageType << std::endl;
7249}
7250
7251void
7253{
7255}
7256
7259{
7260 std::bitset<0> bitset0;
7261 int n;
7262
7263 bIterator = DeserializeSequence(&bitset0, false, bIterator);
7264 bIterator = DeserializeChoice(2, false, &n, bIterator);
7265 if (n == 1)
7266 {
7267 // Deserialize messageClassExtension
7268 bIterator = DeserializeSequence(&bitset0, false, bIterator);
7269 m_messageType = -1;
7270 }
7271 else if (n == 0)
7272 {
7273 // Deserialize c1
7274 bIterator = DeserializeChoice(2, false, &m_messageType, bIterator);
7275 }
7276
7277 return bIterator;
7278}
7279
7280void
7282{
7283 SerializeSequence(std::bitset<0>(), false);
7284 // Choose c1
7285 SerializeChoice(2, 0, false);
7286 // Choose message type
7287 SerializeChoice(2, messageType, false);
7288}
7289
7290/////////////////// RrcDlCcchMessage //////////////////////////////////
7292 : RrcAsn1Header()
7293{
7294}
7295
7297{
7298}
7299
7302{
7303 DeserializeDlCcchMessage(bIterator);
7304 return 1;
7305}
7306
7307void
7308RrcDlCcchMessage::Print(std::ostream& os) const
7309{
7310 std::cout << "DL CCCH MSG TYPE: " << m_messageType << std::endl;
7311}
7312
7313void
7315{
7317}
7318
7321{
7322 std::bitset<0> bitset0;
7323 int n;
7324
7325 bIterator = DeserializeSequence(&bitset0, false, bIterator);
7326 bIterator = DeserializeChoice(2, false, &n, bIterator);
7327 if (n == 1)
7328 {
7329 // Deserialize messageClassExtension
7330 bIterator = DeserializeSequence(&bitset0, false, bIterator);
7331 m_messageType = -1;
7332 }
7333 else if (n == 0)
7334 {
7335 // Deserialize c1
7336 bIterator = DeserializeChoice(4, false, &m_messageType, bIterator);
7337 }
7338
7339 return bIterator;
7340}
7341
7342void
7344{
7345 SerializeSequence(std::bitset<0>(), false);
7346 // Choose c1
7347 SerializeChoice(2, 0, false);
7348 // Choose message type
7349 SerializeChoice(4, messageType, false);
7350}
7351
7352} // namespace ns3
Buffer::Iterator DeserializeChoice(int numOptions, bool isExtensionMarkerPresent, int *selectedOption, Buffer::Iterator bIterator)
Deserialize a Choice (set of options)
Buffer::Iterator DeserializeSequenceOf(int *numElems, int nMax, int nMin, Buffer::Iterator bIterator)
Deserialize a Sequence.
Buffer::Iterator DeserializeNull(Buffer::Iterator bIterator)
Deserialize nothing (null op)
Buffer::Iterator DeserializeInteger(int *n, int nmin, int nmax, Buffer::Iterator bIterator)
Deserialize an integer.
void SerializeBitstring(std::bitset< N > bitstring) const
Serialize a bitstring.
Buffer::Iterator DeserializeEnum(int numElems, int *selectedElem, Buffer::Iterator bIterator)
Deserialize an Enum.
Buffer::Iterator DeserializeSequence(std::bitset< N > *optionalOrDefaultMask, bool isExtensionMarkerPresent, Buffer::Iterator bIterator)
Deserialize a sequence.
void SerializeSequence(std::bitset< N > optionalOrDefaultMask, bool isExtensionMarkerPresent) const
Serialize a sequence.
void SerializeChoice(int numOptions, int selectedOption, bool isExtensionMarkerPresent) const
Serialize a Choice (set of options)
Buffer m_serializationResult
serialization result
void FinalizeSerialization() const
Finalizes an in progress serialization.
void SerializeInteger(int n, int nmin, int nmax) const
Serialize an Integer.
Buffer::Iterator DeserializeBoolean(bool *value, Buffer::Iterator bIterator)
Deserialize a boolean.
uint32_t GetSerializedSize() const override
void SerializeBoolean(bool value) const
Serialize a bool.
Buffer::Iterator DeserializeBitstring(std::bitset< N > *bitstring, Buffer::Iterator bIterator)
Deserialize a bitstring.
void SerializeNull() const
Serialize nothing (null op)
bool m_isDataSerialized
true if data is serialized
void SerializeSequenceOf(int numElems, int nMax, int nMin) const
Serialize a Sequence.
void SerializeEnum(int numElems, int selectedElem) const
Serialize an Enum.
iterator in a Buffer instance
Definition: buffer.h:100
automatically resized byte buffer
Definition: buffer.h:94
void PreSerialize() const override
This function serializes class attributes to m_serializationResult local Buffer.
void Print(std::ostream &os) const override
This function prints the object, for debugging purposes.
void SetMessage(LteRrcSap::HandoverPreparationInfo msg)
Receives a HandoverPreparationInfo IE and stores the contents into the class attributes.
LteRrcSap::HandoverPreparationInfo GetMessage() const
Returns a HandoverPreparationInfo IE from the values in the class attributes.
LteRrcSap::AsConfig m_asConfig
AS config.
uint32_t Deserialize(Buffer::Iterator bIterator) override
LteRrcSap::AsConfig GetAsConfig() const
Getter for m_asConfig.
Protocol header serialization and deserialization.
Definition: header.h:44
ReestablishmentCause
ReestablishmentCause enumeration.
Definition: lte-rrc-sap.h:614
void Print(std::ostream &os) const override
This function prints the object, for debugging purposes.
uint32_t Deserialize(Buffer::Iterator bIterator) override
LteRrcSap::MeasurementReport m_measurementReport
measurement report
LteRrcSap::MeasurementReport GetMessage() const
Returns a MeasurementReport IE from the values in the class attributes.
void PreSerialize() const override
This function serializes class attributes to m_serializationResult local Buffer.
void SetMessage(LteRrcSap::MeasurementReport msg)
Receives a MeasurementReport IE and stores the contents into the class attributes.
This class extends Asn1Header functions, adding serialization/deserialization of some Information ele...
void SerializeNonCriticalExtensionConfiguration(LteRrcSap::NonCriticalExtensionConfiguration nonCriticalExtensionConfiguration) const
Serialize non critical extension config function.
void SerializeSrbToAddModList(std::list< LteRrcSap::SrbToAddMod > srbToAddModList) const
Serialize SRB to add mod list function.
void SerializeSystemInformationBlockType2(LteRrcSap::SystemInformationBlockType2 systemInformationBlockType2) const
Serialize system information block type 2 function.
void SerializeRadioResourceConfigCommonSCell(LteRrcSap::RadioResourceConfigCommonSCell rrccsc) const
Serialize radio resource config common SCell function.
void SerializeMeasResults(LteRrcSap::MeasResults measResults) const
Serialize measure results function.
void SerializePhysicalConfigDedicated(LteRrcSap::PhysicalConfigDedicated physicalConfigDedicated) const
Serialize physical config dedicated function.
Buffer::Iterator DeserializeCellIdentification(LteRrcSap::CellIdentification *ci, Buffer::Iterator bIterator)
Deserialize cell identification function.
Buffer::Iterator DeserializeLogicalChannelConfig(LteRrcSap::LogicalChannelConfig *logicalChannelConfig, Buffer::Iterator bIterator)
Deserialize logical channel config function.
void SerializeRachConfigCommon(LteRrcSap::RachConfigCommon rachConfigCommon) const
Serialize RACH config common function.
Buffer::Iterator DeserializeMeasConfig(LteRrcSap::MeasConfig *measConfig, Buffer::Iterator bIterator)
Deserialize measure config function.
int GetMessageType() const
Get message type.
Buffer::Iterator DeserializePhysicalConfigDedicated(LteRrcSap::PhysicalConfigDedicated *physicalConfigDedicated, Buffer::Iterator bIterator)
Deserialize physical config dedicated function.
Buffer::Iterator DeserializeNonCriticalExtensionConfig(LteRrcSap::NonCriticalExtensionConfiguration *nonCriticalExtension, Buffer::Iterator bIterator)
Deserialize non critical extension config function.
void SerializeRadioResourceConfigCommonSib(LteRrcSap::RadioResourceConfigCommonSib radioResourceConfigCommonSib) const
Serialize radio resource config common SIB function.
void SerializeSystemInformationBlockType1(LteRrcSap::SystemInformationBlockType1 systemInformationBlockType1) const
Serialize system information block type 1 function.
Buffer::Iterator DeserializeRachConfigCommon(LteRrcSap::RachConfigCommon *rachConfigCommon, Buffer::Iterator bIterator)
Deserialize RACH config common function.
Buffer::Iterator DeserializePlmnIdentity(uint32_t *plmnId, Buffer::Iterator bIterator)
Deserialize PLMN identity function.
uint16_t EnumToBandwidth(int n) const
Convert from ENUMERATED value to bandwidth (in RBs)
void SerializeDrbToAddModList(std::list< LteRrcSap::DrbToAddMod > drbToAddModList) const
Serialize DRB to add mod list function.
Buffer::Iterator DeserializeMeasResults(LteRrcSap::MeasResults *measResults, Buffer::Iterator bIterator)
Deserialize measure results function.
Buffer::Iterator DeserializeRadioResourceConfigCommonSCell(LteRrcSap::RadioResourceConfigCommonSCell *rrccsc, Buffer::Iterator bIterator)
Deserialize radio resource config common SCell function.
void SerializeRadioResourceDedicatedSCell(LteRrcSap::RadioResourceConfigDedicatedSCell rrcdsc) const
Serialize radio resource dedicated SCell function.
void SerializePhysicalConfigDedicatedSCell(LteRrcSap::PhysicalConfigDedicatedSCell pcdsc) const
Serialize physical config dedicated function.
TypeId GetInstanceTypeId() const override
Get the most derived TypeId for this Object.
Buffer::Iterator DeserializePhysicalConfigDedicatedSCell(LteRrcSap::PhysicalConfigDedicatedSCell *pcdsc, Buffer::Iterator bIterator)
Deserialize physical config dedicated SCell function.
Buffer::Iterator DeserializeThresholdEutra(LteRrcSap::ThresholdEutra *thresholdEutra, Buffer::Iterator bIterator)
Deserialize threshold eutra function.
void SerializeRadioResourceConfigDedicated(LteRrcSap::RadioResourceConfigDedicated radioResourceConfigDedicated) const
Serialize radio resource config function.
void SerializeThresholdEutra(LteRrcSap::ThresholdEutra thresholdEutra) const
Serialize threshold eutra function.
void SerializeQoffsetRange(int8_t qOffsetRange) const
Serialize Q offset range function.
Buffer::Iterator DeserializeRadioResourceConfigDedicated(LteRrcSap::RadioResourceConfigDedicated *radioResourceConfigDedicated, Buffer::Iterator bIterator)
Deserialize radio resource config dedicated function.
void Print(std::ostream &os) const override
This function prints the object, for debugging purposes.
int m_messageType
Stores RRC message type, according to 3GPP TS 36.331.
Buffer::Iterator DeserializeSystemInformationBlockType1(LteRrcSap::SystemInformationBlockType1 *systemInformationBlockType1, Buffer::Iterator bIterator)
Deserialize system information block type 1 function.
void SerializeLogicalChannelConfig(LteRrcSap::LogicalChannelConfig logicalChannelConfig) const
Serialize logicala channel config function.
static TypeId GetTypeId()
Get the type ID.
Buffer::Iterator DeserializeSystemInformationBlockType2(LteRrcSap::SystemInformationBlockType2 *systemInformationBlockType2, Buffer::Iterator bIterator)
Deserialize system information block type 2 function.
Buffer::Iterator DeserializeQoffsetRange(int8_t *qOffsetRange, Buffer::Iterator bIterator)
Deserialize Qoffset range function.
int BandwidthToEnum(uint16_t bandwidth) const
Convert from bandwidth (in RBs) to ENUMERATED value.
Buffer::Iterator DeserializeDrbToAddModList(std::list< LteRrcSap::DrbToAddMod > *drbToAddModLis, Buffer::Iterator bIterator)
Deserialize DRB to add mod list function.
void SerializePlmnIdentity(uint32_t plmnId) const
Serialize PLMN identity function.
Buffer::Iterator DeserializeRadioResourceConfigCommon(LteRrcSap::RadioResourceConfigCommon *radioResourceConfigCommon, Buffer::Iterator bIterator)
Deserialize radio resource config common function.
Buffer::Iterator DeserializeRadioResourceConfigDedicatedSCell(LteRrcSap::RadioResourceConfigDedicatedSCell *rrcdsc, Buffer::Iterator bIterator)
Deserialize radio resource config dedicated SCell function.
void SerializeRadioResourceConfigCommon(LteRrcSap::RadioResourceConfigCommon radioResourceConfigCommon) const
Serialize system information block type 2 function.
void SerializeMeasConfig(LteRrcSap::MeasConfig measConfig) const
Serialize measure config function.
Buffer::Iterator DeserializeSrbToAddModList(std::list< LteRrcSap::SrbToAddMod > *srbToAddModList, Buffer::Iterator bIterator)
Deserialize SRB to add mod list function.
Buffer::Iterator DeserializeRadioResourceConfigCommonSib(LteRrcSap::RadioResourceConfigCommonSib *radioResourceConfigCommonSib, Buffer::Iterator bIterator)
Deserialize radio resource config common SIB function.
uint8_t m_rrcTransactionIdentifier
RRC transaction identifier.
void Print(std::ostream &os) const override
This function prints the object, for debugging purposes.
LteRrcSap::RrcConnectionReconfigurationCompleted GetMessage() const
Returns a RrcConnectionReconfigurationCompleted IE from the values in the class attributes.
uint32_t Deserialize(Buffer::Iterator bIterator) override
void PreSerialize() const override
This function serializes class attributes to m_serializationResult local Buffer.
void SetMessage(LteRrcSap::RrcConnectionReconfigurationCompleted msg)
Receives a RrcConnectionReconfigurationCompleted IE and stores the contents into the class attributes...
uint8_t GetRrcTransactionIdentifier() const
Getter for m_rrcTransactionIdentifier.
bool m_haveNonCriticalExtension
Have non-critical extension.
std::list< LteRrcSap::SrbToAddMod > GetSrbToAddModList() const
Gets m_radioResourceConfigDedicated.srbToAddModList.
bool m_haveMeasConfig
have measure config?
std::list< LteRrcSap::DrbToAddMod > GetDrbToAddModList() const
Gets m_radioResourceConfigDedicated.drbToAddModList.
LteRrcSap::RrcConnectionReconfiguration GetMessage() const
Returns a RrcConnectionReconfiguration IE from the values in the class attributes.
LteRrcSap::NonCriticalExtensionConfiguration GetNonCriticalExtensionConfig()
Getter for m_nonCriticalExtension.
uint32_t Deserialize(Buffer::Iterator bIterator) override
LteRrcSap::RadioResourceConfigDedicated GetRadioResourceConfigDedicated()
Getter for m_radioResourceConfigDedicated.
bool HavePhysicalConfigDedicated() const
Gets m_radioResourceConfigDedicated.havePhysicalConfigDedicated.
LteRrcSap::MobilityControlInfo m_mobilityControlInfo
the modility control info
LteRrcSap::MeasConfig m_measConfig
the measure config
std::list< uint8_t > GetDrbToReleaseList() const
Gets m_radioResourceConfigDedicated.drbToReleaseList.
LteRrcSap::RadioResourceConfigDedicated m_radioResourceConfigDedicated
the radio resource config dedicated
bool GetHaveNonCriticalExtensionConfig() const
Getter for m_haveNonCriticalExtension.
LteRrcSap::PhysicalConfigDedicated GetPhysicalConfigDedicated() const
Gets m_radioResourceConfigDedicated.physicalConfigDedicated.
void PreSerialize() const override
This function serializes class attributes to m_serializationResult local Buffer.
bool m_haveMobilityControlInfo
have mobility control info?
bool GetHaveRadioResourceConfigDedicated() const
Getter for m_haveRadioResourceConfigDedicated.
bool GetHaveMobilityControlInfo() const
Getter for m_haveMobilityControlInfo.
void SetMessage(LteRrcSap::RrcConnectionReconfiguration msg)
Receives a RrcConnectionReconfiguration IE and stores the contents into the class attributes.
void Print(std::ostream &os) const override
This function prints the object, for debugging purposes.
LteRrcSap::NonCriticalExtensionConfiguration m_nonCriticalExtension
the non-critical extension
uint8_t GetRrcTransactionIdentifier() const
Getter for m_rrcTransactionIdentifier.
bool m_haveRadioResourceConfigDedicated
have radio resource config dedicated?
bool GetHaveMeasConfig() const
Getter for m_haveMeasConfig.
uint8_t m_rrcTransactionIdentifier
RRC transaction identifier.
LteRrcSap::MeasConfig GetMeasConfig()
Getter for m_measConfig.
LteRrcSap::MobilityControlInfo GetMobilityControlInfo()
Getter for m_mobilityControlInfo.
void SetMessage(LteRrcSap::RrcConnectionReestablishmentComplete msg)
Receives a RrcConnectionReestablishmentComplete IE and stores the contents into the class attributes.
void Print(std::ostream &os) const override
This function prints the object, for debugging purposes.
uint8_t m_rrcTransactionIdentifier
RRC transaction identifier.
uint32_t Deserialize(Buffer::Iterator bIterator) override
LteRrcSap::RrcConnectionReestablishmentComplete GetMessage() const
Returns a RrcConnectionReestablishmentComplete IE from the values in the class attributes.
void PreSerialize() const override
This function serializes class attributes to m_serializationResult local Buffer.
uint8_t GetRrcTransactionIdentifier() const
Getter for m_rrcTransactionIdentifier attribute.
uint8_t m_rrcTransactionIdentifier
RRC transaction identifier.
LteRrcSap::RadioResourceConfigDedicated m_radioResourceConfigDedicated
radio resource config dedicated
LteRrcSap::RrcConnectionReestablishment GetMessage() const
Returns a RrcConnectionReestablishment IE from the values in the class attributes.
uint8_t GetRrcTransactionIdentifier() const
Getter for m_rrcTransactionIdentifier attribute.
LteRrcSap::RadioResourceConfigDedicated GetRadioResourceConfigDedicated() const
Getter for m_radioResourceConfigDedicated attribute.
void PreSerialize() const override
This function serializes class attributes to m_serializationResult local Buffer.
void SetMessage(LteRrcSap::RrcConnectionReestablishment msg)
Receives a RrcConnectionReestablishment IE and stores the contents into the class attributes.
void Print(std::ostream &os) const override
This function prints the object, for debugging purposes.
uint32_t Deserialize(Buffer::Iterator bIterator) override
void SetMessage(LteRrcSap::RrcConnectionReestablishmentReject msg)
Receives a RrcConnectionReestablishmentReject IE and stores the contents into the class attributes.
void Print(std::ostream &os) const override
This function prints the object, for debugging purposes.
uint32_t Deserialize(Buffer::Iterator bIterator) override
void PreSerialize() const override
This function serializes class attributes to m_serializationResult local Buffer.
LteRrcSap::RrcConnectionReestablishmentReject m_rrcConnectionReestablishmentReject
RRC connection reestablishmnet reject.
LteRrcSap::RrcConnectionReestablishmentReject GetMessage() const
Returns a RrcConnectionReestablishmentReject IE from the values in the class attributes.
LteRrcSap::RrcConnectionReestablishmentRequest GetMessage() const
Returns a RrcConnectionReestablishmentRequest IE from the values in the class attributes.
void Print(std::ostream &os) const override
This function prints the object, for debugging purposes.
LteRrcSap::ReestablishmentCause m_reestablishmentCause
reestablishment cause
LteRrcSap::ReestablishmentCause GetReestablishmentCause() const
Getter for m_reestablishmentCause.
LteRrcSap::ReestabUeIdentity m_ueIdentity
UE identity.
void SetMessage(LteRrcSap::RrcConnectionReestablishmentRequest msg)
Receives a RrcConnectionReestablishmentRequest IE and stores the contents into the class attributes.
uint32_t Deserialize(Buffer::Iterator bIterator) override
void PreSerialize() const override
This function serializes class attributes to m_serializationResult local Buffer.
LteRrcSap::ReestabUeIdentity GetUeIdentity() const
Getter for m_ueIdentity.
void Print(std::ostream &os) const override
This function prints the object, for debugging purposes.
LteRrcSap::RrcConnectionReject GetMessage() const
Returns a RrcConnectionReject IE from the values in the class attributes.
LteRrcSap::RrcConnectionReject m_rrcConnectionReject
RRC connection reject.
uint32_t Deserialize(Buffer::Iterator bIterator) override
void PreSerialize() const override
This function serializes class attributes to m_serializationResult local Buffer.
void SetMessage(LteRrcSap::RrcConnectionReject msg)
Receives a RrcConnectionReject IE and stores the contents into the class attributes.
LteRrcSap::RrcConnectionRelease GetMessage() const
Returns a RrcConnectionRelease IE from the values in the class attributes.
void SetMessage(LteRrcSap::RrcConnectionRelease msg)
Receives a RrcConnectionRelease IE and stores the contents into the class attributes.
void PreSerialize() const override
This function serializes class attributes to m_serializationResult local Buffer.
void Print(std::ostream &os) const override
This function prints the object, for debugging purposes.
uint32_t Deserialize(Buffer::Iterator bIterator) override
LteRrcSap::RrcConnectionRelease m_rrcConnectionRelease
RRC connection release.
void PreSerialize() const override
This function serializes class attributes to m_serializationResult local Buffer.
std::bitset< 8 > GetMmec() const
Get MMEC attribute.
void Print(std::ostream &os) const override
This function prints the object, for debugging purposes.
enum ns3::RrcConnectionRequestHeader::@59 m_establishmentCause
EstablishmentCause enumeration.
void SetMessage(LteRrcSap::RrcConnectionRequest msg)
Receives a RrcConnectionRequest IE and stores the contents into the class attributes.
uint32_t Deserialize(Buffer::Iterator bIterator) override
std::bitset< 1 > m_spare
spare bit
LteRrcSap::RrcConnectionRequest GetMessage() const
Returns a RrcConnectionRequest IE from the values in the class attributes.
static TypeId GetTypeId()
Get the type ID.
std::bitset< 32 > GetMtmsi() const
Get M-TMSI attribute.
std::bitset< 8 > m_mmec
MMEC.
std::bitset< 32 > m_mTmsi
TMSI.
LteRrcSap::RrcConnectionSetupCompleted GetMessage() const
Returns a RrcConnectionSetupCompleted IE from the values in the class attributes.
uint8_t m_rrcTransactionIdentifier
RRC transaction identifier.
void PreSerialize() const override
This function serializes class attributes to m_serializationResult local Buffer.
void Print(std::ostream &os) const override
This function prints the object, for debugging purposes.
void SetMessage(LteRrcSap::RrcConnectionSetupCompleted msg)
Receives a RrcConnectionSetupCompleted IE and stores the contents into the class attributes.
uint8_t GetRrcTransactionIdentifier() const
Getter for m_rrcTransactionIdentifier.
uint32_t Deserialize(Buffer::Iterator bIterator) override
LteRrcSap::RadioResourceConfigDedicated m_radioResourceConfigDedicated
radio resource config dedicated
void SetMessage(LteRrcSap::RrcConnectionSetup msg)
Receives a RrcConnectionSetup IE and stores the contents into the class attributes.
void PreSerialize() const override
This function serializes class attributes to m_serializationResult local Buffer.
std::list< LteRrcSap::DrbToAddMod > GetDrbToAddModList() const
Gets m_radioResourceConfigDedicated.drbToAddModList.
LteRrcSap::RrcConnectionSetup GetMessage() const
Returns a RrcConnectionSetup IE from the values in the class attributes.
uint32_t Deserialize(Buffer::Iterator bIterator) override
std::list< uint8_t > GetDrbToReleaseList() const
Gets m_radioResourceConfigDedicated.drbToReleaseList.
uint8_t m_rrcTransactionIdentifier
RRC transaction identifier.
std::list< LteRrcSap::SrbToAddMod > GetSrbToAddModList() const
Gets m_radioResourceConfigDedicated.srbToAddModList.
bool HavePhysicalConfigDedicated() const
Gets m_radioResourceConfigDedicated.havePhysicalConfigDedicated.
void Print(std::ostream &os) const override
This function prints the object, for debugging purposes.
LteRrcSap::PhysicalConfigDedicated GetPhysicalConfigDedicated() const
Gets m_radioResourceConfigDedicated.physicalConfigDedicated.
uint8_t GetRrcTransactionIdentifier() const
Getter for m_rrcTransactionIdentifier.
LteRrcSap::RadioResourceConfigDedicated GetRadioResourceConfigDedicated() const
Getter for m_radioResourceConfigDedicated.
Buffer::Iterator DeserializeDlCcchMessage(Buffer::Iterator bIterator)
Deserialize DL CCCH message function.
uint32_t Deserialize(Buffer::Iterator bIterator) override
void Print(std::ostream &os) const override
This function prints the object, for debugging purposes.
void PreSerialize() const override
This function serializes class attributes to m_serializationResult local Buffer.
void SerializeDlCcchMessage(int msgType) const
Serialize DL CCCH message function.
void SerializeDlDcchMessage(int msgType) const
Serialize DL DCCH message function.
void PreSerialize() const override
This function serializes class attributes to m_serializationResult local Buffer.
void Print(std::ostream &os) const override
This function prints the object, for debugging purposes.
uint32_t Deserialize(Buffer::Iterator bIterator) override
Buffer::Iterator DeserializeDlDcchMessage(Buffer::Iterator bIterator)
Deserialize DL DCCH message function.
This class only serves to discriminate which message type has been received in uplink (ue to eNb) for...
void SerializeUlCcchMessage(int msgType) const
Serialize UL CCCH message function.
Buffer::Iterator DeserializeUlCcchMessage(Buffer::Iterator bIterator)
Deserialize DL CCCH message function.
void Print(std::ostream &os) const override
This function prints the object, for debugging purposes.
uint32_t Deserialize(Buffer::Iterator bIterator) override
void PreSerialize() const override
This function serializes class attributes to m_serializationResult local Buffer.
Buffer::Iterator DeserializeUlDcchMessage(Buffer::Iterator bIterator)
Deserialize UL DCCH message function.
uint32_t Deserialize(Buffer::Iterator bIterator) override
void Print(std::ostream &os) const override
This function prints the object, for debugging purposes.
void PreSerialize() const override
This function serializes class attributes to m_serializationResult local Buffer.
void SerializeUlDcchMessage(int msgType) const
Serialize UL DCCH message function.
a unique identifier for an interface.
Definition: type-id.h:59
TypeId SetParent(TypeId tid)
Set the parent TypeId.
Definition: type-id.cc:932
#define NS_ASSERT(condition)
At runtime, in debugging builds, if this condition is not true, the program prints the source file,...
Definition: assert.h:66
#define NS_FATAL_ERROR(msg)
Report a fatal error with a message and terminate.
Definition: fatal-error.h:179
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:202
#define NS_LOG_FUNCTION(parameters)
If log level LOG_FUNCTION is enabled, this macro will output all input parameters separated by ",...
#define MAX_CELL_REPORT
#define MAX_CELL_MEAS
#define MAX_DRB
#define MAX_SIB
#define MAX_EARFCN
#define MAX_SI_MESSAGE
#define MAX_MEAS_ID
#define MAX_OBJECT_ID
#define MAX_RAT_CAPABILITIES
#define MAX_REPORT_CONFIG_ID
#define MAX_SCELL_REPORT
Every class exported by the ns3 library is enclosed in the ns3 namespace.
uint16_t antennaPortsCount
antenna ports count
Definition: lte-rrc-sap.h:758
uint8_t transmissionMode
transmission mode
Definition: lte-rrc-sap.h:151
AsConfig structure.
Definition: lte-rrc-sap.h:650
RadioResourceConfigDedicated sourceRadioResourceConfig
source radio resource config
Definition: lte-rrc-sap.h:652
MasterInformationBlock sourceMasterInformationBlock
source master information block
Definition: lte-rrc-sap.h:654
uint16_t sourceUeIdentity
source UE identity
Definition: lte-rrc-sap.h:653
MeasConfig sourceMeasConfig
source measure config
Definition: lte-rrc-sap.h:651
uint32_t sourceDlCarrierFreq
source DL carrier frequency
Definition: lte-rrc-sap.h:659
SystemInformationBlockType1 sourceSystemInformationBlockType1
source system information block type 1
Definition: lte-rrc-sap.h:656
SystemInformationBlockType2 sourceSystemInformationBlockType2
source system information block type 2
Definition: lte-rrc-sap.h:658
BlackCellsToAddMod structure.
Definition: lte-rrc-sap.h:329
PhysCellIdRange physCellIdRange
Phy cell ID range.
Definition: lte-rrc-sap.h:331
uint16_t dlBandwidth
DL bandwidth.
Definition: lte-rrc-sap.h:580
uint16_t ulBandwidth
UL bandwidth.
Definition: lte-rrc-sap.h:581
uint32_t dlCarrierFreq
DL carrier frequency.
Definition: lte-rrc-sap.h:573
uint32_t ulCarrierFreq
UL carrier frequency.
Definition: lte-rrc-sap.h:574
CellIdentification structure.
Definition: lte-rrc-sap.h:750
uint32_t dlCarrierFreq
ARFCN - valueEUTRA.
Definition: lte-rrc-sap.h:752
uint32_t physCellId
physical cell ID
Definition: lte-rrc-sap.h:751
CellsToAddMod structure.
Definition: lte-rrc-sap.h:313
int8_t cellIndividualOffset
cell individual offset
Definition: lte-rrc-sap.h:316
uint8_t cellIndex
cell index
Definition: lte-rrc-sap.h:314
uint16_t physCellId
Phy cell ID.
Definition: lte-rrc-sap.h:315
uint32_t cellIdentity
cell identity
Definition: lte-rrc-sap.h:666
uint32_t plmnIdentity
PLMN identity.
Definition: lte-rrc-sap.h:665
std::list< uint32_t > plmnIdentityList
PLMN identity list.
Definition: lte-rrc-sap.h:668
uint16_t trackingAreaCode
tracking area code
Definition: lte-rrc-sap.h:667
DrbToAddMod structure.
Definition: lte-rrc-sap.h:245
uint8_t epsBearerIdentity
EPS bearer identity.
Definition: lte-rrc-sap.h:246
RlcConfig rlcConfig
RLC config.
Definition: lte-rrc-sap.h:248
uint8_t logicalChannelIdentity
logical channel identify
Definition: lte-rrc-sap.h:249
uint8_t drbIdentity
DRB identity.
Definition: lte-rrc-sap.h:247
LogicalChannelConfig logicalChannelConfig
logical channel config
Definition: lte-rrc-sap.h:250
uint32_t ulCarrierFreq
UL carrier frequency.
Definition: lte-rrc-sap.h:88
uint16_t ulBandwidth
UL bandwidth.
Definition: lte-rrc-sap.h:89
HandoverPreparationInfo structure.
Definition: lte-rrc-sap.h:942
LogicalChannelConfig structure.
Definition: lte-rrc-sap.h:109
uint16_t bucketSizeDurationMs
bucket size duration ms
Definition: lte-rrc-sap.h:112
uint16_t prioritizedBitRateKbps
prioritized bit rate Kbps
Definition: lte-rrc-sap.h:111
uint8_t logicalChannelGroup
logical channel group
Definition: lte-rrc-sap.h:113
uint16_t systemFrameNumber
system frame number
Definition: lte-rrc-sap.h:624
MeasConfig structure.
Definition: lte-rrc-sap.h:553
std::list< uint8_t > measIdToRemoveList
measure ID to remove list
Definition: lte-rrc-sap.h:558
uint8_t sMeasure
S measure.
Definition: lte-rrc-sap.h:565
std::list< MeasObjectToAddMod > measObjectToAddModList
measure object to add mod list
Definition: lte-rrc-sap.h:555
std::list< uint8_t > reportConfigToRemoveList
report config to remove list
Definition: lte-rrc-sap.h:556
std::list< uint8_t > measObjectToRemoveList
measure object to remove list
Definition: lte-rrc-sap.h:554
SpeedStatePars speedStatePars
speed state parameters
Definition: lte-rrc-sap.h:567
bool haveMeasGapConfig
have measure gap config?
Definition: lte-rrc-sap.h:562
QuantityConfig quantityConfig
quantity config
Definition: lte-rrc-sap.h:561
bool haveSmeasure
have S measure?
Definition: lte-rrc-sap.h:564
bool haveSpeedStatePars
have speed state parameters?
Definition: lte-rrc-sap.h:566
std::list< ReportConfigToAddMod > reportConfigToAddModList
report config to add mod list
Definition: lte-rrc-sap.h:557
MeasGapConfig measGapConfig
measure gap config
Definition: lte-rrc-sap.h:563
std::list< MeasIdToAddMod > measIdToAddModList
measure ID to add mod list
Definition: lte-rrc-sap.h:559
bool haveQuantityConfig
have quantity config?
Definition: lte-rrc-sap.h:560
uint8_t gapOffsetValue
gap offset value
Definition: lte-rrc-sap.h:515
MeasIdToAddMod structure.
Definition: lte-rrc-sap.h:488
uint8_t measObjectId
measure object ID
Definition: lte-rrc-sap.h:490
uint8_t reportConfigId
report config ID
Definition: lte-rrc-sap.h:491
std::list< uint8_t > cellsToRemoveList
cells to remove list
Definition: lte-rrc-sap.h:342
bool haveCellForWhichToReportCGI
have cell for which to report CGI?
Definition: lte-rrc-sap.h:346
std::list< CellsToAddMod > cellsToAddModList
cells to add mod list
Definition: lte-rrc-sap.h:343
uint16_t allowedMeasBandwidth
allowed measure bandwidth
Definition: lte-rrc-sap.h:338
int8_t offsetFreq
offset frequency
Definition: lte-rrc-sap.h:341
uint8_t neighCellConfig
neighbor cell config
Definition: lte-rrc-sap.h:340
uint16_t cellForWhichToReportCGI
cell for which to report CGI
Definition: lte-rrc-sap.h:347
bool presenceAntennaPort1
antenna port 1 present?
Definition: lte-rrc-sap.h:339
std::list< uint8_t > blackCellsToRemoveList
black cells to remove list
Definition: lte-rrc-sap.h:344
std::list< BlackCellsToAddMod > blackCellsToAddModList
black cells to add mod list
Definition: lte-rrc-sap.h:345
uint32_t carrierFreq
carrier frequency
Definition: lte-rrc-sap.h:337
MeasObjectToAddMod structure.
Definition: lte-rrc-sap.h:474
uint8_t measObjectId
measure object ID
Definition: lte-rrc-sap.h:475
MeasObjectEutra measObjectEutra
measure object eutra
Definition: lte-rrc-sap.h:476
uint16_t physCellId
physical cell ID
Definition: lte-rrc-sap.h:700
MeasResultEutra structure.
Definition: lte-rrc-sap.h:680
uint8_t rsrqResult
RSRQ result.
Definition: lte-rrc-sap.h:687
uint8_t rsrpResult
RSRP result.
Definition: lte-rrc-sap.h:685
bool haveRsrpResult
have RSRP result
Definition: lte-rrc-sap.h:684
bool haveRsrqResult
have RSRQ result?
Definition: lte-rrc-sap.h:686
uint16_t physCellId
Phy cell ID.
Definition: lte-rrc-sap.h:681
bool haveCgiInfo
have CGI info?
Definition: lte-rrc-sap.h:682
uint8_t rsrqResult
the RSRQ result
Definition: lte-rrc-sap.h:675
uint8_t rsrpResult
the RSRP result
Definition: lte-rrc-sap.h:674
uint8_t rsrpResult
the RSRP result
Definition: lte-rrc-sap.h:693
uint8_t rsrqResult
the RSRQ result
Definition: lte-rrc-sap.h:694
MeasResultServFreq structure.
Definition: lte-rrc-sap.h:707
bool haveMeasResultSCell
have measResultSCell?
Definition: lte-rrc-sap.h:709
MeasResultBestNeighCell measResultBestNeighCell
best neighbor cell measurement results
Definition: lte-rrc-sap.h:712
bool haveMeasResultBestNeighCell
have measResultBestNeighCell?
Definition: lte-rrc-sap.h:711
uint16_t servFreqId
serving cell index
Definition: lte-rrc-sap.h:708
MeasResultSCell measResultSCell
SCell measurement results.
Definition: lte-rrc-sap.h:710
MeasResults structure.
Definition: lte-rrc-sap.h:717
uint8_t measId
measure ID
Definition: lte-rrc-sap.h:718
bool haveMeasResultNeighCells
have measure result neighbor cells
Definition: lte-rrc-sap.h:720
std::list< MeasResultEutra > measResultListEutra
measure result list eutra
Definition: lte-rrc-sap.h:721
bool haveMeasResultServFreqList
has measResultServFreqList-r10
Definition: lte-rrc-sap.h:722
std::list< MeasResultServFreq > measResultServFreqList
MeasResultServFreqList-r10.
Definition: lte-rrc-sap.h:723
MeasResultPCell measResultPCell
measurement result primary cell
Definition: lte-rrc-sap.h:719
MeasurementReport structure.
Definition: lte-rrc-sap.h:948
MeasResults measResults
measure results
Definition: lte-rrc-sap.h:949
MobilityControlInfo structure.
Definition: lte-rrc-sap.h:593
RadioResourceConfigCommon radioResourceConfigCommon
radio resource config common
Definition: lte-rrc-sap.h:600
RachConfigDedicated rachConfigDedicated
RACH config dedicated.
Definition: lte-rrc-sap.h:602
bool haveRachConfigDedicated
Have RACH config dedicated?
Definition: lte-rrc-sap.h:601
uint16_t newUeIdentity
new UE identity
Definition: lte-rrc-sap.h:599
bool haveCarrierBandwidth
have carrier bandwidth?
Definition: lte-rrc-sap.h:597
bool haveCarrierFreq
have carrier frequency?
Definition: lte-rrc-sap.h:595
CarrierBandwidthEutra carrierBandwidth
carrier bandwidth
Definition: lte-rrc-sap.h:598
CarrierFreqEutra carrierFreq
carrier frequency
Definition: lte-rrc-sap.h:596
uint16_t targetPhysCellId
target Phy cell ID
Definition: lte-rrc-sap.h:594
uint8_t nCellChangeHigh
cell change high
Definition: lte-rrc-sap.h:524
uint8_t nCellChangeMedium
cell change medium
Definition: lte-rrc-sap.h:523
NonCriticalExtensionConfiguration structure.
Definition: lte-rrc-sap.h:874
std::list< uint8_t > sCellToReleaseList
SCell to release list.
Definition: lte-rrc-sap.h:876
std::list< SCellToAddMod > sCellToAddModList
SCell to add mod list.
Definition: lte-rrc-sap.h:875
AntennaInfoCommon antennaInfoCommon
2: Physical configuration, general antennaInfoCommon-r10
Definition: lte-rrc-sap.h:780
PdschConfigCommon pdschConfigCommon
4: Physical configuration, physical channels pdsch-ConfigCommon-r10
Definition: lte-rrc-sap.h:784
uint16_t dlBandwidth
1: Cell characteristics
Definition: lte-rrc-sap.h:778
int8_t referenceSignalPower
INTEGER (-60..50),.
Definition: lte-rrc-sap.h:157
int8_t pb
INTEGER (0..3),.
Definition: lte-rrc-sap.h:158
uint16_t start
starting cell ID
Definition: lte-rrc-sap.h:322
PhysicalConfigDedicated structure.
Definition: lte-rrc-sap.h:226
PdschConfigDedicated pdschConfigDedicated
PDSCH config dedicated.
Definition: lte-rrc-sap.h:233
bool haveAntennaInfoDedicated
have antenna info dedicated?
Definition: lte-rrc-sap.h:230
SoundingRsUlConfigDedicated soundingRsUlConfigDedicated
sounding RS UL config dedicated
Definition: lte-rrc-sap.h:229
bool haveSoundingRsUlConfigDedicated
have sounding RS UL config dedicated?
Definition: lte-rrc-sap.h:227
bool havePdschConfigDedicated
have PDSCH config dedicated?
Definition: lte-rrc-sap.h:232
AntennaInfoDedicated antennaInfo
antenna info
Definition: lte-rrc-sap.h:231
PhysicalConfigDedicatedSCell structure.
Definition: lte-rrc-sap.h:821
AntennaInfoDedicated antennaInfoUl
antenna info UL
Definition: lte-rrc-sap.h:835
SoundingRsUlConfigDedicated soundingRsUlConfigDedicated
sounding RS UL config dedicated
Definition: lte-rrc-sap.h:841
PdschConfigDedicated pdschConfigDedicated
PDSCH config dedicated.
Definition: lte-rrc-sap.h:830
bool haveSoundingRsUlConfigDedicated
have sounding RS UL config dedicated?
Definition: lte-rrc-sap.h:839
bool haveUlConfiguration
have UL configuration?
Definition: lte-rrc-sap.h:833
bool haveAntennaInfoUlDedicated
have antenna info UL dedicated?
Definition: lte-rrc-sap.h:834
bool havePdschConfigDedicated
have PDSCH config dedicated?
Definition: lte-rrc-sap.h:829
bool haveNonUlConfiguration
have non UL configuration?
Definition: lte-rrc-sap.h:823
AntennaInfoDedicated antennaInfo
antenna info dedicated
Definition: lte-rrc-sap.h:825
bool haveAntennaInfoDedicated
have antenna info dedicated?
Definition: lte-rrc-sap.h:824
uint32_t plmnIdentity
PLMN identity.
Definition: lte-rrc-sap.h:66
uint8_t numberOfRaPreambles
number of RA preambles
Definition: lte-rrc-sap.h:256
uint8_t filterCoefficientRSRQ
filter coefficient RSRQ
Definition: lte-rrc-sap.h:308
uint8_t filterCoefficientRSRP
filter coefficient RSRP
Definition: lte-rrc-sap.h:307
uint8_t raResponseWindowSize
RA response window size.
Definition: lte-rrc-sap.h:263
uint8_t preambleTransMax
preamble transmit maximum
Definition: lte-rrc-sap.h:262
RachConfigCommon structure.
Definition: lte-rrc-sap.h:275
TxFailParam txFailParam
txFailParams
Definition: lte-rrc-sap.h:278
PreambleInfo preambleInfo
preamble info
Definition: lte-rrc-sap.h:276
RaSupervisionInfo raSupervisionInfo
RA supervision info.
Definition: lte-rrc-sap.h:277
uint8_t raPreambleIndex
RA preamble index.
Definition: lte-rrc-sap.h:587
uint8_t raPrachMaskIndex
RA PRACH mask index.
Definition: lte-rrc-sap.h:588
RadioResourceConfigCommon structure.
Definition: lte-rrc-sap.h:283
RachConfigCommon rachConfigCommon
RACH config common.
Definition: lte-rrc-sap.h:284
RadioResourceConfigCommonSCell.
Definition: lte-rrc-sap.h:846
NonUlConfiguration nonUlConfiguration
non UL configuration
Definition: lte-rrc-sap.h:848
bool haveUlConfiguration
have UL configuration
Definition: lte-rrc-sap.h:849
bool haveNonUlConfiguration
have non UL configuration?
Definition: lte-rrc-sap.h:847
UlConfiguration ulConfiguration
UL configuration.
Definition: lte-rrc-sap.h:850
RadioResourceConfigCommonSib structure.
Definition: lte-rrc-sap.h:289
RachConfigCommon rachConfigCommon
RACH config common.
Definition: lte-rrc-sap.h:290
RadioResourceConfigDedicated structure.
Definition: lte-rrc-sap.h:296
PhysicalConfigDedicated physicalConfigDedicated
physical config dedicated
Definition: lte-rrc-sap.h:301
std::list< uint8_t > drbToReleaseList
DRB to release list.
Definition: lte-rrc-sap.h:299
bool havePhysicalConfigDedicated
have physical config dedicated?
Definition: lte-rrc-sap.h:300
std::list< DrbToAddMod > drbToAddModList
DRB to add mod list.
Definition: lte-rrc-sap.h:298
std::list< SrbToAddMod > srbToAddModList
SRB to add mod list.
Definition: lte-rrc-sap.h:297
RadioResourceConfigDedicatedSCell structure.
Definition: lte-rrc-sap.h:855
PhysicalConfigDedicatedSCell physicalConfigDedicatedSCell
physical config dedicated SCell
Definition: lte-rrc-sap.h:857
ReestabUeIdentity structure.
Definition: lte-rrc-sap.h:607
uint16_t physCellId
Phy cell ID.
Definition: lte-rrc-sap.h:609
bool reportOnLeave
Indicates whether or not the UE shall initiate the measurement reporting procedure when the leaving c...
Definition: lte-rrc-sap.h:399
uint8_t maxReportCells
Maximum number of cells, excluding the serving cell, to be included in the measurement report.
Definition: lte-rrc-sap.h:441
enum ns3::LteRrcSap::ReportConfigEutra::@62 eventId
Event enumeration.
enum ns3::LteRrcSap::ReportConfigEutra::@61 triggerType
Trigger enumeration.
uint8_t hysteresis
Parameter used within the entry and leave condition of an event triggered reporting condition.
Definition: lte-rrc-sap.h:407
@ RSRP
Reference Signal Received Power.
Definition: lte-rrc-sap.h:425
@ RSRQ
Reference Signal Received Quality.
Definition: lte-rrc-sap.h:426
@ EVENT_A2
Event A2: Serving becomes worse than absolute threshold.
Definition: lte-rrc-sap.h:385
@ EVENT_A3
Event A3: Neighbour becomes amount of offset better than PCell.
Definition: lte-rrc-sap.h:386
@ EVENT_A4
Event A4: Neighbour becomes better than absolute threshold.
Definition: lte-rrc-sap.h:387
@ EVENT_A1
Event A1: Serving becomes better than absolute threshold.
Definition: lte-rrc-sap.h:384
@ EVENT_A5
Event A5: PCell becomes worse than absolute threshold1 AND Neighbour becomes better than another abso...
Definition: lte-rrc-sap.h:388
uint8_t reportAmount
Number of measurement reports applicable, always assumed to be infinite.
Definition: lte-rrc-sap.h:465
enum ns3::LteRrcSap::ReportConfigEutra::@65 reportInterval
Report interval enumeration.
ThresholdEutra threshold2
Threshold for event A5.
Definition: lte-rrc-sap.h:394
enum ns3::LteRrcSap::ReportConfigEutra::@63 triggerQuantity
Trigger type enumeration.
@ BOTH
Both the RSRP and RSRQ quantities are to be included in the measurement report.
Definition: lte-rrc-sap.h:434
ThresholdEutra threshold1
Threshold for event A1, A2, A4, and A5.
Definition: lte-rrc-sap.h:393
enum ns3::LteRrcSap::ReportConfigEutra::@64 reportQuantity
Report type enumeration.
int8_t a3Offset
Offset value for Event A3.
Definition: lte-rrc-sap.h:403
uint16_t timeToTrigger
Time during which specific criteria for the event needs to be met in order to trigger a measurement r...
Definition: lte-rrc-sap.h:411
ReportConfigToAddMod structure.
Definition: lte-rrc-sap.h:481
uint8_t reportConfigId
report config ID
Definition: lte-rrc-sap.h:482
ReportConfigEutra reportConfigEutra
report config eutra
Definition: lte-rrc-sap.h:483
Direction choice
direction choice
Definition: lte-rrc-sap.h:104
RrcConnectionReconfigurationCompleted structure.
Definition: lte-rrc-sap.h:898
uint8_t rrcTransactionIdentifier
RRC transaction identifier.
Definition: lte-rrc-sap.h:899
RrcConnectionReconfiguration structure.
Definition: lte-rrc-sap.h:881
uint8_t rrcTransactionIdentifier
RRC transaction identifier.
Definition: lte-rrc-sap.h:882
bool haveMobilityControlInfo
have mobility control info
Definition: lte-rrc-sap.h:885
NonCriticalExtensionConfiguration nonCriticalExtension
3GPP TS 36.331 v.11.10 R11 Sec.
Definition: lte-rrc-sap.h:893
bool haveRadioResourceConfigDedicated
have radio resource config dedicated
Definition: lte-rrc-sap.h:887
RadioResourceConfigDedicated radioResourceConfigDedicated
radio resource config dedicated
Definition: lte-rrc-sap.h:889
bool haveNonCriticalExtension
have critical extension?
Definition: lte-rrc-sap.h:890
MobilityControlInfo mobilityControlInfo
mobility control info
Definition: lte-rrc-sap.h:886
RrcConnectionReestablishmentComplete structure.
Definition: lte-rrc-sap.h:919
uint8_t rrcTransactionIdentifier
RRC transaction identifier.
Definition: lte-rrc-sap.h:920
RrcConnectionReestablishment structure.
Definition: lte-rrc-sap.h:911
RadioResourceConfigDedicated radioResourceConfigDedicated
radio resource config dedicated
Definition: lte-rrc-sap.h:914
uint8_t rrcTransactionIdentifier
RRC transaction identifier.
Definition: lte-rrc-sap.h:912
RrcConnectionReestablishmentReject structure.
Definition: lte-rrc-sap.h:925
RrcConnectionReestablishmentRequest structure.
Definition: lte-rrc-sap.h:904
ReestablishmentCause reestablishmentCause
reestablishment cause
Definition: lte-rrc-sap.h:906
RrcConnectionReject structure.
Definition: lte-rrc-sap.h:936
RrcConnectionRelease structure.
Definition: lte-rrc-sap.h:930
uint8_t rrcTransactionIdentifier
RRC transaction identifier.
Definition: lte-rrc-sap.h:931
RrcConnectionRequest structure.
Definition: lte-rrc-sap.h:730
RrcConnectionSetupCompleted structure.
Definition: lte-rrc-sap.h:744
uint8_t rrcTransactionIdentifier
RRC transaction identifier.
Definition: lte-rrc-sap.h:745
RrcConnectionSetup structure.
Definition: lte-rrc-sap.h:736
uint8_t rrcTransactionIdentifier
RRC transaction identifier.
Definition: lte-rrc-sap.h:737
RadioResourceConfigDedicated radioResourceConfigDedicated
radio resource config dedicated
Definition: lte-rrc-sap.h:739
SCellToAddMod structure.
Definition: lte-rrc-sap.h:862
RadioResourceConfigDedicatedSCell radioResourceConfigDedicatedSCell
radio resource config dedicated SCell
Definition: lte-rrc-sap.h:869
uint32_t sCellIndex
SCell index.
Definition: lte-rrc-sap.h:863
bool haveRadioResourceConfigDedicatedSCell
have radio resource config dedicated SCell?
Definition: lte-rrc-sap.h:867
CellIdentification cellIdentification
cell identification
Definition: lte-rrc-sap.h:864
RadioResourceConfigCommonSCell radioResourceConfigCommonSCell
radio resource config common SCell
Definition: lte-rrc-sap.h:866
uint16_t srsConfigIndex
SRS config index.
Definition: lte-rrc-sap.h:145
SpeedStateScaleFactors timeToTriggerSf
time to trigger scale factors
Definition: lte-rrc-sap.h:548
MobilityStateParameters mobilityStateParameters
mobility state parameters
Definition: lte-rrc-sap.h:547
uint8_t sfHigh
scale factor high
Definition: lte-rrc-sap.h:532
uint8_t sfMedium
scale factor medium
Definition: lte-rrc-sap.h:531
SrbToAddMod structure.
Definition: lte-rrc-sap.h:238
LogicalChannelConfig logicalChannelConfig
logical channel config
Definition: lte-rrc-sap.h:240
uint8_t srbIdentity
SB identity.
Definition: lte-rrc-sap.h:239
SystemInformationBlockType1 structure.
Definition: lte-rrc-sap.h:629
CellAccessRelatedInfo cellAccessRelatedInfo
cell access related info
Definition: lte-rrc-sap.h:630
SystemInformationBlockType2 structure.
Definition: lte-rrc-sap.h:636
RadioResourceConfigCommonSib radioResourceConfigCommon
radio resource config common
Definition: lte-rrc-sap.h:637
Threshold for event evaluation.
Definition: lte-rrc-sap.h:360
@ THRESHOLD_RSRP
RSRP is used for the threshold.
Definition: lte-rrc-sap.h:364
@ THRESHOLD_RSRQ
RSRQ is used for the threshold.
Definition: lte-rrc-sap.h:365
enum ns3::LteRrcSap::ThresholdEutra::@60 choice
Threshold enumeration.
uint8_t range
Value range used in RSRP/RSRQ threshold.
Definition: lte-rrc-sap.h:368
uint8_t connEstFailCount
Number of times that the UE detects T300 expiry on the same cell.
Definition: lte-rrc-sap.h:269
UlPowerControlCommonSCell ulPowerControlCommonSCell
3GPP TS 36.331 v.11.10 R11 pag.223
Definition: lte-rrc-sap.h:793
FreqInfo ulFreqInfo
UL frequency info.
Definition: lte-rrc-sap.h:792
PrachConfigSCell prachConfigSCell
PRACH config SCell.
Definition: lte-rrc-sap.h:795