A Discrete-Event Network Simulator
API
Loading...
Searching...
No Matches
lte-test-entities.cc
Go to the documentation of this file.
1/*
2 * Copyright (c) 2011 Centre Tecnologic de Telecomunicacions de Catalunya (CTTC)
3 *
4 * SPDX-License-Identifier: GPL-2.0-only
5 *
6 * Author: Manuel Requena <manuel.requena@cttc.es>
7 */
8
9#include "lte-test-entities.h"
10
11#include "ns3/log.h"
12#include "ns3/lte-pdcp-header.h"
13#include "ns3/lte-rlc-am-header.h"
14#include "ns3/lte-rlc-header.h"
15#include "ns3/node.h"
16#include "ns3/simulator.h"
17
18namespace ns3
19{
20
21NS_LOG_COMPONENT_DEFINE("LteTestEntities");
22
23/////////////////////////////////////////////////////////////////////
24
25TypeId
27{
28 static TypeId tid = TypeId("ns3::LteTestRrc").SetParent<Object>().AddConstructor<LteTestRrc>();
29
30 return tid;
31}
32
34{
35 NS_LOG_FUNCTION(this);
36
37 m_txPdus = 0;
38 m_txBytes = 0;
39 m_rxPdus = 0;
40 m_rxBytes = 0;
41 m_txLastTime = Time(0);
42 m_rxLastTime = Time(0);
43
45 // Simulator::ScheduleNow (&LteTestRrc::Start, this);
46}
47
52
53void
59
60void
62{
63 m_device = device;
64}
65
66void
71
77
78std::string
84
85// Stats
88{
90 return m_txPdus;
91}
92
99
102{
103 NS_LOG_FUNCTION(this << m_rxPdus);
104 return m_rxPdus;
105}
106
109{
110 NS_LOG_FUNCTION(this << m_rxBytes);
111 return m_rxBytes;
112}
113
114Time
120
121Time
127
128void
130{
131 NS_LOG_FUNCTION(this << arrivalTime);
132 m_arrivalTime = arrivalTime;
133}
134
135void
137{
138 NS_LOG_FUNCTION(this << pduSize);
139 m_pduSize = pduSize;
140}
141
142/**
143 * PDCP SAP
144 */
145
146void
148{
149 NS_LOG_FUNCTION(this << params.pdcpSdu->GetSize());
150 Ptr<Packet> p = params.pdcpSdu;
151 // NS_LOG_LOGIC ("PDU received = " << (*p));
152
153 uint32_t dataLen = p->GetSize();
154 auto buf = new uint8_t[dataLen];
155
156 // Stats
157 m_rxPdus++;
158 m_rxBytes += dataLen;
160
161 p->CopyData(buf, dataLen);
162 m_receivedData = std::string((char*)buf, dataLen);
163
164 // NS_LOG_LOGIC (m_receivedData);
165
166 delete[] buf;
167}
168
169/**
170 * START
171 */
172
173void
175{
176 NS_LOG_FUNCTION(this);
177 NS_ASSERT_MSG(m_arrivalTime != Time(0), "Arrival time must be different from 0");
178
179 // Stats
180 m_txPdus++;
183
185 p.rnti = 1111;
186 p.lcid = 222;
188
189 bool haveContext = false;
190 Ptr<Node> node;
191 if (m_device)
192 {
193 node = m_device->GetNode();
194 if (node)
195 {
196 haveContext = true;
197 }
198 }
199 if (haveContext)
200 {
201 Simulator::ScheduleWithContext(node->GetId(),
202 Seconds(0),
205 p);
206 }
207 else
208 {
210 }
211
213 // Simulator::Run ();
214}
215
216void
218{
219 NS_LOG_FUNCTION(this);
221}
222
223void
224LteTestRrc::SendData(Time at, std::string dataToSend)
225{
226 NS_LOG_FUNCTION(this << at << dataToSend.length() << dataToSend);
227
228 // Stats
229 m_txPdus++;
230 m_txBytes += dataToSend.length();
231
233 p.rnti = 1111;
234 p.lcid = 222;
235
236 NS_LOG_LOGIC("Data(" << dataToSend.length() << ") = " << dataToSend.data());
237 p.pdcpSdu = Create<Packet>((uint8_t*)dataToSend.data(), dataToSend.length());
238
239 NS_LOG_LOGIC("Packet(" << p.pdcpSdu->GetSize() << ")");
241}
242
243/////////////////////////////////////////////////////////////////////
244
245TypeId
247{
248 static TypeId tid =
249 TypeId("ns3::LteTestPdcp").SetParent<Object>().AddConstructor<LteTestPdcp>();
250
251 return tid;
252}
253
260
265
266void
268{
269 NS_LOG_FUNCTION(this);
270 delete m_rlcSapUser;
271}
272
273void
278
284
285std::string
287{
288 NS_LOG_FUNCTION(this);
289
290 return m_receivedData;
291}
292
293/**
294 * RLC SAP
295 */
296
297void
299{
300 NS_LOG_FUNCTION(this << p->GetSize());
301 NS_LOG_LOGIC("Data = " << (*p));
302
303 uint32_t dataLen = p->GetSize();
304 auto buf = new uint8_t[dataLen];
305 p->CopyData(buf, dataLen);
306 m_receivedData = std::string((char*)buf, dataLen);
307
309
310 delete[] buf;
311}
312
313/**
314 * START
315 */
316
317void
319{
320 NS_LOG_FUNCTION(this);
321}
322
323void
324LteTestPdcp::SendData(Time time, std::string dataToSend)
325{
326 NS_LOG_FUNCTION(this << time << dataToSend.length() << dataToSend);
327
329 p.rnti = 1111;
330 p.lcid = 222;
331
332 NS_LOG_LOGIC("Data(" << dataToSend.length() << ") = " << dataToSend.data());
333 p.pdcpPdu = Create<Packet>((uint8_t*)dataToSend.data(), dataToSend.length());
334
335 NS_LOG_LOGIC("Packet(" << p.pdcpPdu->GetSize() << ")");
337}
338
339/////////////////////////////////////////////////////////////////////
340
341TypeId
343{
344 static TypeId tid = TypeId("ns3::LteTestMac").SetParent<Object>().AddConstructor<LteTestMac>();
345
346 return tid;
347}
348
350{
351 NS_LOG_FUNCTION(this);
352 m_device = nullptr;
354 m_macSapUser = nullptr;
355 m_macLoopback = nullptr;
356 m_pdcpHeaderPresent = false;
359 m_txOppTime = Seconds(0.001);
360 m_txOppSize = 0;
361
362 m_txPdus = 0;
363 m_txBytes = 0;
364 m_rxPdus = 0;
365 m_rxBytes = 0;
366
367 // m_cmacSapProvider = new EnbMacMemberLteEnbCmacSapProvider (this);
368 // m_schedSapUser = new EnbMacMemberFfMacSchedSapUser (this);
369 // m_cschedSapUser = new EnbMacMemberFfMacCschedSapUser (this);
370 // m_enbPhySapUser = new EnbMacMemberLteEnbPhySapUser (this);
371}
372
377
378void
380{
381 NS_LOG_FUNCTION(this);
382 delete m_macSapProvider;
383 // delete m_cmacSapProvider;
384 // delete m_schedSapUser;
385 // delete m_cschedSapUser;
386 // delete m_enbPhySapUser;
387
388 m_device = nullptr;
389}
390
391void
393{
394 m_device = device;
395}
396
397void
402
408
409void
414
415std::string
421
422// Stats
425{
426 NS_LOG_FUNCTION(this << m_txPdus);
427 return m_txPdus;
428}
429
432{
433 NS_LOG_FUNCTION(this << m_txBytes);
434 return m_txBytes;
435}
436
439{
440 NS_LOG_FUNCTION(this << m_rxPdus);
441 return m_rxPdus;
442}
443
446{
447 NS_LOG_FUNCTION(this << m_rxBytes);
448 return m_rxBytes;
449}
450
451void
453{
454 NS_LOG_FUNCTION(this << time << bytes);
455 bool haveContext = false;
456 Ptr<Node> node;
457 if (m_device)
458 {
459 node = m_device->GetNode();
460 if (node)
461 {
462 haveContext = true;
463 }
464 }
466 txOpParams.bytes = bytes;
467 txOpParams.layer = 0;
468 txOpParams.componentCarrierId = 0;
469 txOpParams.harqId = 0;
470 txOpParams.rnti = 0;
471 txOpParams.lcid = 0;
472
473 if (haveContext)
474 {
475 Simulator::ScheduleWithContext(node->GetId(),
476 time,
479 txOpParams);
480 }
481 else
482 {
484 }
485
487 {
488 if (m_txOppTime != Seconds(0))
489 {
492 this,
495 }
496 }
497}
498
499void
501{
502 NS_LOG_FUNCTION(this << present);
503 m_pdcpHeaderPresent = present;
504}
505
506void
507LteTestMac::SetRlcHeaderType(uint8_t rlcHeaderType)
508{
509 NS_LOG_FUNCTION(this << rlcHeaderType);
510 m_rlcHeaderType = rlcHeaderType;
511}
512
513void
515{
516 NS_LOG_FUNCTION(this << (uint32_t)mode);
517 m_txOpportunityMode = mode;
518
520 {
521 if (m_txOppTime != Seconds(0.0))
522 {
524 }
525 }
526}
527
528void
530{
531 NS_LOG_FUNCTION(this << txOppTime);
532 m_txOppTime = txOppTime;
533}
534
535void
537{
538 NS_LOG_FUNCTION(this << txOppSize);
539 m_txOppSize = txOppSize;
540}
541
542/**
543 * MAC SAP
544 */
545
546void
548{
549 NS_LOG_FUNCTION(this << params.pdu->GetSize());
550
551 m_txPdus++;
552 m_txBytes += params.pdu->GetSize();
553
555 rxPduParams.p = params.pdu;
556 rxPduParams.rnti = params.rnti;
557 rxPduParams.lcid = params.lcid;
558
559 if (m_device)
560 {
561 m_device->Send(params.pdu, m_device->GetBroadcast(), 0);
562 }
563 else if (m_macLoopback)
564 {
567 m_macLoopback->m_macSapUser,
568 rxPduParams);
569 }
570 else
571 {
572 LtePdcpHeader pdcpHeader;
573
575 {
576 // Remove AM RLC header
577 LteRlcAmHeader rlcAmHeader;
578 params.pdu->RemoveHeader(rlcAmHeader);
579 NS_LOG_LOGIC("AM RLC header: " << rlcAmHeader);
580 }
581 else // if (m_rlcHeaderType == UM_RLC_HEADER)
582 {
583 // Remove UM RLC header
584 LteRlcHeader rlcHeader;
585 params.pdu->RemoveHeader(rlcHeader);
586 NS_LOG_LOGIC("UM RLC header: " << rlcHeader);
587 }
588
589 // Remove PDCP header, if present
591 {
592 params.pdu->RemoveHeader(pdcpHeader);
593 NS_LOG_LOGIC("PDCP header: " << pdcpHeader);
594 }
595
596 // Copy data to a string
597 uint32_t dataLen = params.pdu->GetSize();
598 auto buf = new uint8_t[dataLen];
599 params.pdu->CopyData(buf, dataLen);
600 m_receivedData = std::string((char*)buf, dataLen);
601
602 NS_LOG_LOGIC("Data (" << dataLen << ") = " << m_receivedData);
603 delete[] buf;
604 }
605}
606
607void
609{
610 NS_LOG_FUNCTION(this << params.txQueueSize << params.retxQueueSize << params.statusPduSize);
611
613 {
614 // cancel all previously scheduled TxOpps
615 for (auto it = m_nextTxOppList.begin(); it != m_nextTxOppList.end(); ++it)
616 {
617 it->Cancel();
618 }
619 m_nextTxOppList.clear();
620
621 int32_t size = params.statusPduSize + params.txQueueSize + params.retxQueueSize;
622 Time time = m_txOppTime;
624 txOpParams.bytes = m_txOppSize;
625 txOpParams.layer = 0;
626 txOpParams.componentCarrierId = 0;
627 txOpParams.harqId = 0;
628 txOpParams.rnti = params.rnti;
629 txOpParams.lcid = params.lcid;
630 while (size > 0)
631 {
635 txOpParams);
636 m_nextTxOppList.push_back(e);
637 size -= m_txOppSize;
638 time += m_txOppTime;
639 }
640 }
641}
642
643bool
644LteTestMac::Receive(Ptr<NetDevice> nd, Ptr<const Packet> p, uint16_t protocol, const Address& addr)
645{
646 NS_LOG_FUNCTION(this << addr << protocol << p->GetSize());
647
648 m_rxPdus++;
649 m_rxBytes += p->GetSize();
650
651 Ptr<Packet> packet = p->Copy();
653 rxPduParams.p = packet;
654 rxPduParams.rnti = 0;
655 rxPduParams.lcid = 0;
656 m_macSapUser->ReceivePdu(rxPduParams);
657 return true;
658}
659
661
663 : m_s1SapProvider(nullptr)
664{
665 NS_LOG_FUNCTION(this);
667}
668
673
674void
676{
677 NS_LOG_FUNCTION(this);
678 delete m_s1SapUser;
679}
680
681TypeId
683{
684 NS_LOG_FUNCTION("EpcTestRrc::GetTypeId");
685 static TypeId tid = TypeId("ns3::EpcTestRrc").SetParent<Object>().AddConstructor<EpcTestRrc>();
686 return tid;
687}
688
689void
694
697{
698 return m_s1SapUser;
699}
700
701void
706
707void
712
713void
718
719} // namespace ns3
a polymophic address class
Definition address.h:90
This class implements the Service Access Point (SAP) between the LteEnbRrc and the EpcEnbApplication.
This class implements the Service Access Point (SAP) between the LteEnbRrc and the EpcEnbApplication.
RRC stub providing a testing S1 SAP user to be used with the EpcEnbApplication.
EpcEnbS1SapUser * m_s1SapUser
S1 SAP user.
static TypeId GetTypeId()
Get the type ID.
void SetS1SapProvider(EpcEnbS1SapProvider *s)
Set the S1 SAP Provider.
friend class MemberEpcEnbS1SapUser< EpcTestRrc >
allow MemberEpcEnbS1SapUser<EpcTestRrc> class friend access
void DoPathSwitchRequestAcknowledge(EpcEnbS1SapUser::PathSwitchRequestAcknowledgeParameters params)
Path switch request acknowledge function.
void DoDispose() override
Destructor implementation.
EpcEnbS1SapProvider * m_s1SapProvider
S1 SAP provider.
EpcEnbS1SapUser * GetS1SapUser()
void DoInitialContextSetupRequest(EpcEnbS1SapUser::InitialContextSetupRequestParameters params)
Initial context setup request.
void DoDataRadioBearerSetupRequest(EpcEnbS1SapUser::DataRadioBearerSetupRequestParameters params)
Data radio bearer setup request.
An identifier for simulation events.
Definition event-id.h:45
void Cancel()
This method is syntactic sugar for the ns3::Simulator::Cancel method.
Definition event-id.cc:44
Service Access Point (SAP) offered by the MAC to the RLC See Femto Forum MAC Scheduler Interface Spec...
Definition lte-mac-sap.h:25
Service Access Point (SAP) offered by the MAC to the RLC See Femto Forum MAC Scheduler Interface Spec...
Definition lte-mac-sap.h:85
virtual void NotifyTxOpportunity(TxOpportunityParameters params)=0
Called by the MAC to notify the RLC that the scheduler granted a transmission opportunity to this RLC...
virtual void ReceivePdu(ReceivePduParameters params)=0
Called by the MAC to notify the RLC of the reception of a new PDU.
The packet header for the Packet Data Convergence Protocol (PDCP) packets.
Service Access Point (SAP) offered by the PDCP entity to the RRC entity See 3GPP 36....
virtual void TransmitPdcpSdu(TransmitPdcpSduParameters params)=0
Send RRC PDU parameters to the PDCP for transmission.
Service Access Point (SAP) offered by the PDCP entity to the RRC entity See 3GPP 36....
The packet header for the AM Radio Link Control (RLC) protocol packets.
The packet header for the Radio Link Control (RLC) protocol packets.
Service Access Point (SAP) offered by the UM-RLC and AM-RLC entities to the PDCP entity See 3GPP 36....
Definition lte-rlc-sap.h:25
virtual void TransmitPdcpPdu(TransmitPdcpPduParameters params)=0
Send a PDCP PDU to the RLC for transmission This method is to be called when upper PDCP entity has a ...
Service Access Point (SAP) offered by the UM-RLC and AM-RLC entities to the PDCP entity See 3GPP 36....
Definition lte-rlc-sap.h:56
uint32_t GetTxPdus()
Get the transmit PDUs.
void SendTxOpportunity(Time time, uint32_t bytes)
Send transmit opportunity function.
uint8_t m_txOpportunityMode
transmit opportunity mode
void SetLteMacSapUser(LteMacSapUser *s)
Set the MAC SAP user.
uint32_t GetRxPdus()
Get the receive PDUs.
uint32_t m_txOppSize
transmit opportunity size
void SetPdcpHeaderPresent(bool present)
Set PDCP header present function.
uint32_t m_rxBytes
the number of receive bytes
void SetLteMacLoopback(Ptr< LteTestMac > s)
Set the other side of the MAC Loopback.
uint32_t GetRxBytes()
Get the receive bytes.
void DoTransmitPdu(LteMacSapProvider::TransmitPduParameters params)
Transmit PDU.
void SetTxOppSize(uint32_t txOppSize)
Set transmit opportunity time.
void DoReportBufferStatus(LteMacSapProvider::ReportBufferStatusParameters params)
Report buffer status function.
std::list< EventId > m_nextTxOppList
next transmit opportunity list
Time m_txOppTime
transmit opportunity time
LteMacSapProvider * GetLteMacSapProvider()
Get the MAC SAP provider.
std::string GetDataReceived()
Get data received function.
std::string m_receivedData
the received data string
bool m_pdcpHeaderPresent
PDCP header present?
LteMacSapUser * m_macSapUser
MAC SAP user.
bool Receive(Ptr< NetDevice > nd, Ptr< const Packet > p, uint16_t protocol, const Address &addr)
the Receive function
void SetDevice(Ptr< NetDevice > device)
Set the device function.
void SetRlcHeaderType(uint8_t rlcHeaderType)
Set RLC header type.
uint8_t m_rlcHeaderType
RLC header type.
uint32_t m_rxPdus
the number of receive PDUs
static TypeId GetTypeId()
Get the type ID.
void DoDispose() override
Destructor implementation.
friend class EnbMacMemberLteMacSapProvider< LteTestMac >
allow EnbMacMemberLteMacSapProvider<LteTestMac> class friend access
void SetTxOppTime(Time txOppTime)
Set transmit opportunity time.
LteMacSapProvider * m_macSapProvider
MAC SAP provider.
uint32_t m_txPdus
the number of transmit PDUs
void SetTxOpportunityMode(uint8_t mode)
Set transmit opportunity mode.
Ptr< LteTestMac > m_macLoopback
MAC loopback.
uint32_t m_txBytes
the number of transmit bytes
uint32_t GetTxBytes()
Get the transmit bytes.
Ptr< NetDevice > m_device
the device
std::string GetDataReceived()
Get data received function.
friend class LteRlcSpecificLteRlcSapUser< LteTestPdcp >
allow LteRlcSpecificLteRlcSapUser<LteTestPdcp> class friend access
LteRlcSapProvider * m_rlcSapProvider
RLC SAP provider.
void SetLteRlcSapProvider(LteRlcSapProvider *s)
Set the RLC SAP provider.
virtual void DoReceivePdcpPdu(Ptr< Packet > p)
Interface forwarded by LteRlcSapUser.
void DoDispose() override
Destructor implementation.
LteRlcSapUser * m_rlcSapUser
RLC SAP user.
LteRlcSapUser * GetLteRlcSapUser()
Get the RLC SAP user.
void Start()
Start function.
void SendData(Time time, std::string dataToSend)
Send data function.
std::string m_receivedData
the received data
static TypeId GetTypeId()
Get the type ID.
void SendData(Time at, std::string dataToSend)
Send data function.
uint32_t GetTxPdus()
Get the transmit PDUs.
uint32_t GetRxPdus()
Get the receive PDUs.
uint32_t m_rxPdus
number of receive PDUs
uint32_t m_pduSize
PDU size.
static TypeId GetTypeId()
Get the type ID.
void SetDevice(Ptr< NetDevice > device)
Set the device.
Time m_arrivalTime
next arrival time
LtePdcpSapUser * m_pdcpSapUser
PDCP SAP user.
void SetLtePdcpSapProvider(LtePdcpSapProvider *s)
Set the PDCP SAP provider.
void DoDispose() override
Destructor implementation.
void Stop()
Stop function.
Time m_rxLastTime
last reeive time
uint32_t m_rxBytes
number of receive bytes
uint32_t m_txBytes
number of transmit bytes
void Start()
Start function.
friend class LtePdcpSpecificLtePdcpSapUser< LteTestRrc >
allow LtePdcpSpecificLtePdcpSapUser<LteTestRrc> class friend access
Time m_txLastTime
last transmit time
void SetArrivalTime(Time arrivalTime)
Set the arrival time.
std::string m_receivedData
the received data
uint32_t m_txPdus
number of transmit PDUs
uint32_t GetTxBytes()
Get the transmit bytes.
LtePdcpSapUser * GetLtePdcpSapUser()
Get the PDCP SAP user.
void SetPduSize(uint32_t pduSize)
Set the PDU size.
Time GetRxLastTime()
Get the last receive time.
virtual void DoReceivePdcpSdu(LtePdcpSapUser::ReceivePdcpSduParameters params)
Interface forwarded by LtePdcpSapUser.
EventId m_nextPdu
next PDU event
std::string GetDataReceived()
Get data received function.
LtePdcpSapProvider * m_pdcpSapProvider
PDCP SAP provider.
Time GetTxLastTime()
Get the last transmit time.
Ptr< NetDevice > m_device
the device
uint32_t GetRxBytes()
Get the receive bytes.
A base class which provides memory management and object aggregation.
Definition object.h:78
uint32_t GetSize() const
Returns the the size in bytes of the packet (including the zero-filled initial payload).
Definition packet.h:850
Smart pointer class similar to boost::intrusive_ptr.
static EventId Schedule(const Time &delay, FUNC f, Ts &&... args)
Schedule an event to expire after delay.
Definition simulator.h:560
static void ScheduleWithContext(uint32_t context, const Time &delay, FUNC f, Ts &&... args)
Schedule an event with the given context.
Definition simulator.h:577
static Time Now()
Return the current simulation virtual time.
Definition simulator.cc:197
static EventId ScheduleNow(FUNC f, Ts &&... args)
Schedule an event to expire Now.
Definition simulator.h:594
Simulation virtual time values and global simulation resolution.
Definition nstime.h:94
a unique identifier for an interface.
Definition type-id.h:48
TypeId SetParent(TypeId tid)
Set the parent TypeId.
Definition type-id.cc:1001
#define NS_ASSERT_MSG(condition, message)
At runtime, in debugging builds, if this condition is not true, the program prints the message to out...
Definition assert.h:75
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition log.h:191
#define NS_LOG_LOGIC(msg)
Use NS_LOG to output a message of level LOG_LOGIC.
Definition log.h:271
#define NS_LOG_FUNCTION(parameters)
If log level LOG_FUNCTION is enabled, this macro will output all input parameters separated by ",...
#define NS_OBJECT_ENSURE_REGISTERED(type)
Register an Object subclass with the TypeId system.
Definition object-base.h:35
Ptr< T > Create(Ts &&... args)
Create class instances by constructors with varying numbers of arguments and return them by Ptr.
Definition ptr.h:436
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition nstime.h:1308
Every class exported by the ns3 library is enclosed in the ns3 namespace.
Parameters passed to DataRadioBearerSetupRequest ()
Parameters passed to InitialContextSetupRequest ()
PathSwitchRequestAcknowledgeParameters structure.
Parameters for LteMacSapProvider::ReportBufferStatus.
Definition lte-mac-sap.h:58
Parameters for LteMacSapProvider::TransmitPdu.
Definition lte-mac-sap.h:34
Parameters for LteMacSapUser::ReceivePdu.
Ptr< Packet > p
the RLC PDU to be received
uint8_t lcid
the logical channel id
uint16_t rnti
the C-RNTI identifying the UE
Parameters for LteMacSapUser::NotifyTxOpportunity.
Definition lte-mac-sap.h:94
uint16_t rnti
the C-RNTI identifying the UE
uint32_t bytes
the number of bytes to transmit
uint8_t componentCarrierId
the component carrier id
uint8_t layer
the layer of transmission (MIMO)
uint8_t lcid
the logical channel id
Parameters for LtePdcpSapProvider::TransmitPdcpSdu.
uint8_t lcid
the logical channel id corresponding to the sending RLC instance
uint16_t rnti
the C-RNTI identifying the UE
Parameters for LtePdcpSapUser::ReceivePdcpSdu.
Parameters for LteRlcSapProvider::TransmitPdcpPdu.
Definition lte-rlc-sap.h:33
uint8_t lcid
the logical channel id corresponding to the sending RLC instance
Definition lte-rlc-sap.h:36
uint16_t rnti
the C-RNTI identifying the UE
Definition lte-rlc-sap.h:35