A Discrete-Event Network Simulator
API
Loading...
Searching...
No Matches
lte-test-uplink-power-control.cc
Go to the documentation of this file.
1/*
2 * Copyright (c) 2014 Piotr Gawlowicz
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: Piotr Gawlowicz <gawlowicz.p@gmail.com>
18 *
19 */
20
21#include "lte-test-uplink-power-control.h"
22
23#include "lte-ffr-simple.h"
24
25#include "ns3/lte-helper.h"
26#include "ns3/mobility-helper.h"
27#include <ns3/boolean.h>
28#include <ns3/callback.h>
29#include <ns3/config.h>
30#include <ns3/double.h>
31#include <ns3/enum.h>
32#include <ns3/ff-mac-scheduler.h>
33#include <ns3/integer.h>
34#include <ns3/log.h>
35#include <ns3/lte-common.h>
36#include <ns3/lte-enb-net-device.h>
37#include <ns3/lte-enb-phy.h>
38#include <ns3/lte-enb-rrc.h>
39#include <ns3/lte-rrc-sap.h>
40#include <ns3/lte-ue-net-device.h>
41#include <ns3/lte-ue-phy.h>
42#include <ns3/lte-ue-rrc.h>
43#include <ns3/pointer.h>
44#include <ns3/simulator.h>
45#include <ns3/string.h>
46
47using namespace ns3;
48
49NS_LOG_COMPONENT_DEFINE("LteUplinkPowerControlTest");
50
55LteUplinkPowerControlTestSuite::LteUplinkPowerControlTestSuite()
56 : TestSuite("lte-uplink-power-control", SYSTEM)
57{
58 // LogLevel logLevel = (LogLevel)(LOG_PREFIX_FUNC | LOG_PREFIX_TIME | LOG_LEVEL_DEBUG);
59 // LogComponentEnable ("LteUplinkPowerControlTest", logLevel);
60 NS_LOG_INFO("Creating LteUplinkPowerControlTestSuite");
61
62 AddTestCase(new LteUplinkOpenLoopPowerControlTestCase("OpenLoopTest1"), TestCase::QUICK);
63 AddTestCase(
64 new LteUplinkClosedLoopPowerControlAbsoluteModeTestCase("ClosedLoopAbsoluteModeTest1"),
65 TestCase::QUICK);
66 AddTestCase(new LteUplinkClosedLoopPowerControlAccumulatedModeTestCase(
67 "ClosedLoopAccumulatedModeTest1"),
68 TestCase::QUICK);
69}
70
75static LteUplinkPowerControlTestSuite lteUplinkPowerControlTestSuite;
76
80void
81PuschTxPowerNofitication(LteUplinkPowerControlTestCase* testcase,
82 uint16_t cellId,
83 uint16_t rnti,
84 double txPower)
85{
86 testcase->PuschTxPowerTrace(cellId, rnti, txPower);
87}
88
89void
90PucchTxPowerNofitication(LteUplinkPowerControlTestCase* testcase,
91 uint16_t cellId,
92 uint16_t rnti,
93 double txPower)
94{
95 testcase->PucchTxPowerTrace(cellId, rnti, txPower);
96}
97
98void
99SrsTxPowerNofitication(LteUplinkPowerControlTestCase* testcase,
100 uint16_t cellId,
101 uint16_t rnti,
102 double txPower)
103{
104 testcase->SrsTxPowerTrace(cellId, rnti, txPower);
105}
106
107LteUplinkPowerControlTestCase::LteUplinkPowerControlTestCase(std::string name)
108 : TestCase(name)
109{
110 NS_LOG_INFO("Creating LteUplinkPowerControlTestCase");
111}
112
113LteUplinkPowerControlTestCase::~LteUplinkPowerControlTestCase()
114{
115}
116
117void
118LteUplinkPowerControlTestCase::TeleportUe(uint32_t x,
119 uint32_t y,
120 double expectedPuschTxPower,
121 double expectedPucchTxPower,
122 double expectedSrsTxPower)
123{
124 NS_LOG_FUNCTION(this);
125 NS_LOG_DEBUG("Teleport UE to : (" << x << ", " << y << ", 0)");
126
127 m_ueMobility->SetPosition(Vector(x, y, 0.0));
128 m_teleportTime = Simulator::Now();
129
130 m_expectedPuschTxPower = expectedPuschTxPower;
131 m_expectedPucchTxPower = expectedPucchTxPower;
132 m_expectedSrsTxPower = expectedSrsTxPower;
133}
134
135void
136LteUplinkPowerControlTestCase::SetTpcConfiguration(uint32_t tpc,
137 uint32_t tpcNum,
138 double expectedPuschTxPower,
139 double expectedPucchTxPower,
140 double expectedSrsTxPower)
141{
142 NS_LOG_FUNCTION(this);
143
144 m_teleportTime = Simulator::Now();
145
146 m_expectedPuschTxPower = expectedPuschTxPower;
147 m_expectedPucchTxPower = expectedPucchTxPower;
148 m_expectedSrsTxPower = expectedSrsTxPower;
149
150 m_ffrSimple->SetTpc(tpc, tpcNum, m_accumulatedMode);
151}
152
153void
154LteUplinkPowerControlTestCase::PuschTxPowerTrace(uint16_t cellId, uint16_t rnti, double txPower)
155{
156 NS_LOG_FUNCTION(this);
157 NS_LOG_DEBUG("PuschTxPower : CellId: " << cellId << " RNTI: " << rnti
158 << " PuschTxPower: " << txPower);
159 // wait because of RSRP filtering
160 if ((Simulator::Now() - m_teleportTime) < MilliSeconds(50))
161 {
162 return;
163 }
164 NS_TEST_ASSERT_MSG_EQ_TOL(txPower, m_expectedPuschTxPower, 0.01, "Wrong Pusch Tx Power");
165}
166
167void
168LteUplinkPowerControlTestCase::PucchTxPowerTrace(uint16_t cellId, uint16_t rnti, double txPower)
169{
170 NS_LOG_FUNCTION(this);
171 NS_LOG_DEBUG("PucchTxPower : CellId: " << cellId << " RNTI: " << rnti
172 << " PuschTxPower: " << txPower);
173 // wait because of RSRP filtering
174 if ((Simulator::Now() - m_teleportTime) < MilliSeconds(50))
175 {
176 return;
177 }
178
179 NS_TEST_ASSERT_MSG_EQ_TOL(txPower, m_expectedPucchTxPower, 0.01, "Wrong Pucch Tx Power");
180}
181
182void
183LteUplinkPowerControlTestCase::SrsTxPowerTrace(uint16_t cellId, uint16_t rnti, double txPower)
184{
185 NS_LOG_FUNCTION(this);
186 NS_LOG_DEBUG("SrsTxPower : CellId: " << cellId << " RNTI: " << rnti
187 << " PuschTxPower: " << txPower);
188 // wait because of RSRP filtering
189 if ((Simulator::Now() - m_teleportTime) < MilliSeconds(50))
190 {
191 return;
192 }
193 NS_TEST_ASSERT_MSG_EQ_TOL(txPower, m_expectedSrsTxPower, 0.01, "Wrong Srs Tx Power");
194}
195
196void
197LteUplinkPowerControlTestCase::DoRun()
198{
199}
200
201LteUplinkOpenLoopPowerControlTestCase::LteUplinkOpenLoopPowerControlTestCase(std::string name)
202 : LteUplinkPowerControlTestCase("Uplink Open Loop Power Control: " + name)
203{
204 NS_LOG_INFO("Creating LteUplinkPowerControlTestCase");
205}
206
207LteUplinkOpenLoopPowerControlTestCase::~LteUplinkOpenLoopPowerControlTestCase()
208{
209}
210
211void
212LteUplinkOpenLoopPowerControlTestCase::DoRun()
213{
214 Config::Reset();
215 Config::SetDefault("ns3::LteHelper::UseIdealRrc", BooleanValue(false));
216
217 double eNbTxPower = 30;
218 Config::SetDefault("ns3::LteEnbPhy::TxPower", DoubleValue(eNbTxPower));
219 Config::SetDefault("ns3::LteUePhy::TxPower", DoubleValue(10.0));
220 Config::SetDefault("ns3::LteUePhy::EnableUplinkPowerControl", BooleanValue(true));
221
222 Config::SetDefault("ns3::LteUePowerControl::ClosedLoop", BooleanValue(false));
223 Config::SetDefault("ns3::LteUePowerControl::AccumulationEnabled", BooleanValue(false));
224 Config::SetDefault("ns3::LteUePowerControl::PoNominalPusch", IntegerValue(-90));
225 Config::SetDefault("ns3::LteUePowerControl::PsrsOffset", IntegerValue(9));
226
227 Ptr<LteHelper> lteHelper = CreateObject<LteHelper>();
228
229 uint16_t bandwidth = 25;
230 double d1 = 0;
231
232 // Create Nodes: eNodeB and UE
233 NodeContainer enbNodes;
234 NodeContainer ueNodes;
235 enbNodes.Create(1);
236 ueNodes.Create(1);
237 NodeContainer allNodes = NodeContainer(enbNodes, ueNodes);
238
239 /* the topology is the following:
240 *
241 * eNB1-------------------------UE
242 * d1
243 */
244
245 // Install Mobility Model
246 Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator>();
247 positionAlloc->Add(Vector(0.0, 0.0, 0.0)); // eNB1
248 positionAlloc->Add(Vector(d1, 0.0, 0.0)); // UE1
249
250 MobilityHelper mobility;
251 mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
252 mobility.SetPositionAllocator(positionAlloc);
253 mobility.Install(allNodes);
254 m_ueMobility = ueNodes.Get(0)->GetObject<MobilityModel>();
255
256 // Create Devices and install them in the Nodes (eNB and UE)
257 NetDeviceContainer enbDevs;
258 NetDeviceContainer ueDevs;
259 lteHelper->SetSchedulerType("ns3::PfFfMacScheduler");
260
261 lteHelper->SetEnbDeviceAttribute("DlBandwidth", UintegerValue(bandwidth));
262 lteHelper->SetEnbDeviceAttribute("UlBandwidth", UintegerValue(bandwidth));
263
264 enbDevs = lteHelper->InstallEnbDevice(enbNodes);
265 ueDevs = lteHelper->InstallUeDevice(ueNodes);
266
267 Ptr<LteUePhy> uePhy =
268 DynamicCast<LteUePhy>(ueDevs.Get(0)->GetObject<LteUeNetDevice>()->GetPhy());
269 m_ueUpc = uePhy->GetUplinkPowerControl();
270
271 m_ueUpc->TraceConnectWithoutContext("ReportPuschTxPower",
272 MakeBoundCallback(&PuschTxPowerNofitication, this));
273 m_ueUpc->TraceConnectWithoutContext("ReportPucchTxPower",
274 MakeBoundCallback(&PucchTxPowerNofitication, this));
275 m_ueUpc->TraceConnectWithoutContext("ReportSrsTxPower",
276 MakeBoundCallback(&SrsTxPowerNofitication, this));
277
278 // Attach a UE to a eNB
279 lteHelper->Attach(ueDevs, enbDevs.Get(0));
280
281 // Activate a data radio bearer
282 EpsBearer::Qci q = EpsBearer::GBR_CONV_VOICE;
283 EpsBearer bearer(q);
284 lteHelper->ActivateDataRadioBearer(ueDevs, bearer);
285
286 // Changing UE position
287 Simulator::Schedule(MilliSeconds(0),
288 &LteUplinkPowerControlTestCase::TeleportUe,
289 this,
290 0,
291 0,
292 -40,
293 -40,
294 -40);
295 Simulator::Schedule(MilliSeconds(200),
296 &LteUplinkPowerControlTestCase::TeleportUe,
297 this,
298 200,
299 0,
300 8.9745,
301 8.9745,
302 11.9745);
303 Simulator::Schedule(MilliSeconds(300),
304 &LteUplinkPowerControlTestCase::TeleportUe,
305 this,
306 400,
307 0,
308 14.9951,
309 14.9951,
310 17.9951);
311 Simulator::Schedule(MilliSeconds(400),
312 &LteUplinkPowerControlTestCase::TeleportUe,
313 this,
314 600,
315 0,
316 18.5169,
317 18.5169,
318 21.5169);
319 Simulator::Schedule(MilliSeconds(500),
320 &LteUplinkPowerControlTestCase::TeleportUe,
321 this,
322 800,
323 0,
324 21.0157,
325 21.0157,
326 23);
327 Simulator::Schedule(MilliSeconds(600),
328 &LteUplinkPowerControlTestCase::TeleportUe,
329 this,
330 1000,
331 0,
332 22.9539,
333 22.9539,
334 23);
335 Simulator::Schedule(MilliSeconds(700),
336 &LteUplinkPowerControlTestCase::TeleportUe,
337 this,
338 1200,
339 0,
340 23,
341 10,
342 23);
343 Simulator::Schedule(MilliSeconds(800),
344 &LteUplinkPowerControlTestCase::TeleportUe,
345 this,
346 400,
347 0,
348 14.9951,
349 14.9951,
350 17.9951);
351 Simulator::Schedule(MilliSeconds(900),
352 &LteUplinkPowerControlTestCase::TeleportUe,
353 this,
354 800,
355 0,
356 21.0157,
357 21.0157,
358 23);
359 Simulator::Schedule(MilliSeconds(1000),
360 &LteUplinkPowerControlTestCase::TeleportUe,
361 this,
362 0,
363 0,
364 -40,
365 -40,
366 -40);
367 Simulator::Schedule(MilliSeconds(1100),
368 &LteUplinkPowerControlTestCase::TeleportUe,
369 this,
370 100,
371 0,
372 2.9539,
373 2.9539,
374 5.9539);
375 Simulator::Stop(Seconds(1.200));
376 Simulator::Run();
377
378 Simulator::Destroy();
379}
380
381LteUplinkClosedLoopPowerControlAbsoluteModeTestCase::
382 LteUplinkClosedLoopPowerControlAbsoluteModeTestCase(std::string name)
383 : LteUplinkPowerControlTestCase("Uplink Closed Loop Power Control: " + name)
384{
385 NS_LOG_INFO("Creating LteUplinkClosedLoopPowerControlAbsoluteModeTestCase");
386}
387
388LteUplinkClosedLoopPowerControlAbsoluteModeTestCase::
389 ~LteUplinkClosedLoopPowerControlAbsoluteModeTestCase()
390{
391}
392
393void
394LteUplinkClosedLoopPowerControlAbsoluteModeTestCase::DoRun()
395{
396 Config::Reset();
397 Config::SetDefault("ns3::LteHelper::UseIdealRrc", BooleanValue(false));
398
399 double eNbTxPower = 30;
400 Config::SetDefault("ns3::LteEnbPhy::TxPower", DoubleValue(eNbTxPower));
401 Config::SetDefault("ns3::LteUePhy::TxPower", DoubleValue(10.0));
402 Config::SetDefault("ns3::LteUePhy::EnableUplinkPowerControl", BooleanValue(true));
403
404 Config::SetDefault("ns3::LteUePowerControl::ClosedLoop", BooleanValue(true));
405 Config::SetDefault("ns3::LteUePowerControl::AccumulationEnabled", BooleanValue(false));
406 Config::SetDefault("ns3::LteUePowerControl::PoNominalPusch", IntegerValue(-90));
407 Config::SetDefault("ns3::LteUePowerControl::PsrsOffset", IntegerValue(9));
408
409 Ptr<LteHelper> lteHelper = CreateObject<LteHelper>();
410 lteHelper->SetFfrAlgorithmType("ns3::LteFfrSimple");
411
412 uint16_t bandwidth = 25;
413 double d1 = 100;
414
415 // Create Nodes: eNodeB and UE
416 NodeContainer enbNodes;
417 NodeContainer ueNodes;
418 enbNodes.Create(1);
419 ueNodes.Create(1);
420 NodeContainer allNodes = NodeContainer(enbNodes, ueNodes);
421
422 /* the topology is the following:
423 *
424 * eNB1-------------------------UE
425 * d1
426 */
427
428 // Install Mobility Model
429 Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator>();
430 positionAlloc->Add(Vector(0.0, 0.0, 0.0)); // eNB1
431 positionAlloc->Add(Vector(d1, 0.0, 0.0)); // UE1
432
433 MobilityHelper mobility;
434 mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
435 mobility.SetPositionAllocator(positionAlloc);
436 mobility.Install(allNodes);
437 m_ueMobility = ueNodes.Get(0)->GetObject<MobilityModel>();
438
439 // Create Devices and install them in the Nodes (eNB and UE)
440 NetDeviceContainer enbDevs;
441 NetDeviceContainer ueDevs;
442 lteHelper->SetSchedulerType("ns3::PfFfMacScheduler");
443
444 lteHelper->SetEnbDeviceAttribute("DlBandwidth", UintegerValue(bandwidth));
445 lteHelper->SetEnbDeviceAttribute("UlBandwidth", UintegerValue(bandwidth));
446
447 enbDevs = lteHelper->InstallEnbDevice(enbNodes);
448 ueDevs = lteHelper->InstallUeDevice(ueNodes);
449
450 Ptr<LteUePhy> uePhy =
451 DynamicCast<LteUePhy>(ueDevs.Get(0)->GetObject<LteUeNetDevice>()->GetPhy());
452 m_ueUpc = uePhy->GetUplinkPowerControl();
453
454 m_ueUpc->TraceConnectWithoutContext("ReportPuschTxPower",
455 MakeBoundCallback(&PuschTxPowerNofitication, this));
456 m_ueUpc->TraceConnectWithoutContext("ReportPucchTxPower",
457 MakeBoundCallback(&PucchTxPowerNofitication, this));
458 m_ueUpc->TraceConnectWithoutContext("ReportSrsTxPower",
459 MakeBoundCallback(&SrsTxPowerNofitication, this));
460
461 // Attach a UE to a eNB
462 lteHelper->Attach(ueDevs, enbDevs.Get(0));
463
464 // Activate a data radio bearer
465 EpsBearer::Qci q = EpsBearer::GBR_CONV_VOICE;
466 EpsBearer bearer(q);
467 lteHelper->ActivateDataRadioBearer(ueDevs, bearer);
468
469 PointerValue tmp;
470 enbDevs.Get(0)->GetAttribute("LteFfrAlgorithm", tmp);
471 m_ffrSimple = DynamicCast<LteFfrSimple>(tmp.GetObject());
472 m_accumulatedMode = false;
473
474 // Changing TPC value
475 Simulator::Schedule(MilliSeconds(0),
476 &LteUplinkPowerControlTestCase::SetTpcConfiguration,
477 this,
478 1,
479 0,
480 1.9539,
481 1.9539,
482 4.9539);
483 Simulator::Schedule(MilliSeconds(100),
484 &LteUplinkPowerControlTestCase::SetTpcConfiguration,
485 this,
486 0,
487 0,
488 -1.0461,
489 -1.0461,
490 1.9539);
491 Simulator::Schedule(MilliSeconds(200),
492 &LteUplinkPowerControlTestCase::SetTpcConfiguration,
493 this,
494 2,
495 0,
496 3.9539,
497 3.9539,
498 6.9539);
499 Simulator::Schedule(MilliSeconds(300),
500 &LteUplinkPowerControlTestCase::SetTpcConfiguration,
501 this,
502 3,
503 0,
504 6.9539,
505 6.9539,
506 9.9539);
507 Simulator::Schedule(MilliSeconds(400),
508 &LteUplinkPowerControlTestCase::SetTpcConfiguration,
509 this,
510 0,
511 0,
512 -1.0461,
513 -1.0461,
514 1.9539);
515 Simulator::Schedule(MilliSeconds(500),
516 &LteUplinkPowerControlTestCase::SetTpcConfiguration,
517 this,
518 1,
519 0,
520 1.9539,
521 1.9539,
522 4.9539);
523 Simulator::Schedule(MilliSeconds(600),
524 &LteUplinkPowerControlTestCase::SetTpcConfiguration,
525 this,
526 3,
527 0,
528 6.9539,
529 6.9539,
530 9.9539);
531 Simulator::Schedule(MilliSeconds(800),
532 &LteUplinkPowerControlTestCase::SetTpcConfiguration,
533 this,
534 2,
535 0,
536 3.9539,
537 3.9539,
538 6.9539);
539 Simulator::Stop(Seconds(1.000));
540 Simulator::Run();
541
542 Simulator::Destroy();
543}
544
545LteUplinkClosedLoopPowerControlAccumulatedModeTestCase::
546 LteUplinkClosedLoopPowerControlAccumulatedModeTestCase(std::string name)
547 : LteUplinkPowerControlTestCase("Uplink Closed Loop Power Control: " + name)
548{
549 NS_LOG_INFO("Creating LteUplinkClosedLoopPowerControlAccumulatedModeTestCase");
550}
551
552LteUplinkClosedLoopPowerControlAccumulatedModeTestCase::
553 ~LteUplinkClosedLoopPowerControlAccumulatedModeTestCase()
554{
555}
556
557void
558LteUplinkClosedLoopPowerControlAccumulatedModeTestCase::DoRun()
559{
560 Config::Reset();
561 Config::SetDefault("ns3::LteHelper::UseIdealRrc", BooleanValue(false));
562
563 double eNbTxPower = 30;
564 Config::SetDefault("ns3::LteEnbPhy::TxPower", DoubleValue(eNbTxPower));
565 Config::SetDefault("ns3::LteUePhy::TxPower", DoubleValue(10.0));
566 Config::SetDefault("ns3::LteUePhy::EnableUplinkPowerControl", BooleanValue(true));
567
568 Config::SetDefault("ns3::LteUePowerControl::ClosedLoop", BooleanValue(true));
569 Config::SetDefault("ns3::LteUePowerControl::AccumulationEnabled", BooleanValue(true));
570 Config::SetDefault("ns3::LteUePowerControl::PoNominalPusch", IntegerValue(-90));
571 Config::SetDefault("ns3::LteUePowerControl::PsrsOffset", IntegerValue(9));
572
573 Ptr<LteHelper> lteHelper = CreateObject<LteHelper>();
574 lteHelper->SetFfrAlgorithmType("ns3::LteFfrSimple");
575
576 uint16_t bandwidth = 25;
577 double d1 = 10;
578
579 // Create Nodes: eNodeB and UE
580 NodeContainer enbNodes;
581 NodeContainer ueNodes;
582 enbNodes.Create(1);
583 ueNodes.Create(1);
584 NodeContainer allNodes = NodeContainer(enbNodes, ueNodes);
585
586 /* the topology is the following:
587 *
588 * eNB1-------------------------UE
589 * d1
590 */
591
592 // Install Mobility Model
593 Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator>();
594 positionAlloc->Add(Vector(0.0, 0.0, 0.0)); // eNB1
595 positionAlloc->Add(Vector(d1, 0.0, 0.0)); // UE1
596
597 MobilityHelper mobility;
598 mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
599 mobility.SetPositionAllocator(positionAlloc);
600 mobility.Install(allNodes);
601 m_ueMobility = ueNodes.Get(0)->GetObject<MobilityModel>();
602
603 // Create Devices and install them in the Nodes (eNB and UE)
604 NetDeviceContainer enbDevs;
605 NetDeviceContainer ueDevs;
606 lteHelper->SetSchedulerType("ns3::PfFfMacScheduler");
607
608 lteHelper->SetEnbDeviceAttribute("DlBandwidth", UintegerValue(bandwidth));
609 lteHelper->SetEnbDeviceAttribute("UlBandwidth", UintegerValue(bandwidth));
610
611 enbDevs = lteHelper->InstallEnbDevice(enbNodes);
612 ueDevs = lteHelper->InstallUeDevice(ueNodes);
613
614 Ptr<LteUePhy> uePhy =
615 DynamicCast<LteUePhy>(ueDevs.Get(0)->GetObject<LteUeNetDevice>()->GetPhy());
616 m_ueUpc = uePhy->GetUplinkPowerControl();
617
618 m_ueUpc->TraceConnectWithoutContext("ReportPuschTxPower",
619 MakeBoundCallback(&PuschTxPowerNofitication, this));
620 m_ueUpc->TraceConnectWithoutContext("ReportPucchTxPower",
621 MakeBoundCallback(&PucchTxPowerNofitication, this));
622 m_ueUpc->TraceConnectWithoutContext("ReportSrsTxPower",
623 MakeBoundCallback(&SrsTxPowerNofitication, this));
624
625 // Attach a UE to a eNB
626 lteHelper->Attach(ueDevs, enbDevs.Get(0));
627
628 // Activate a data radio bearer
629 EpsBearer::Qci q = EpsBearer::GBR_CONV_VOICE;
630 EpsBearer bearer(q);
631 lteHelper->ActivateDataRadioBearer(ueDevs, bearer);
632
633 PointerValue tmp;
634 enbDevs.Get(0)->GetAttribute("LteFfrAlgorithm", tmp);
635 m_ffrSimple = DynamicCast<LteFfrSimple>(tmp.GetObject());
636 m_accumulatedMode = true;
637
638 // Changing TPC value
639 Simulator::Schedule(MilliSeconds(0),
640 &LteUplinkPowerControlTestCase::SetTpcConfiguration,
641 this,
642 1,
643 0,
644 -17.0461,
645 -17.0461,
646 -14.0461);
647 Simulator::Schedule(MilliSeconds(100),
648 &LteUplinkPowerControlTestCase::SetTpcConfiguration,
649 this,
650 0,
651 20,
652 -37.0461,
653 -37.0461,
654 -34.0461);
655 Simulator::Schedule(MilliSeconds(200),
656 &LteUplinkPowerControlTestCase::SetTpcConfiguration,
657 this,
658 0,
659 20,
660 -40,
661 10,
662 -37.0461);
663 Simulator::Schedule(MilliSeconds(300),
664 &LteUplinkPowerControlTestCase::SetTpcConfiguration,
665 this,
666 2,
667 1,
668 -39.0461,
669 -39.0461,
670 -36.0461);
671 Simulator::Schedule(MilliSeconds(400),
672 &LteUplinkPowerControlTestCase::SetTpcConfiguration,
673 this,
674 3,
675 10,
676 -9.0461,
677 -9.0461,
678 -6.0461);
679 Simulator::Schedule(MilliSeconds(500),
680 &LteUplinkPowerControlTestCase::SetTpcConfiguration,
681 this,
682 2,
683 15,
684 5.9539,
685 5.9539,
686 8.9539);
687 Simulator::Schedule(MilliSeconds(600),
688 &LteUplinkPowerControlTestCase::SetTpcConfiguration,
689 this,
690 3,
691 1,
692 8.9539,
693 8.9539,
694 11.9539);
695 Simulator::Schedule(MilliSeconds(700),
696 &LteUplinkPowerControlTestCase::SetTpcConfiguration,
697 this,
698 2,
699 10,
700 18.9539,
701 18.9539,
702 21.9539);
703 Simulator::Schedule(MilliSeconds(800),
704 &LteUplinkPowerControlTestCase::SetTpcConfiguration,
705 this,
706 2,
707 20,
708 23,
709 23,
710 23);
711 Simulator::Schedule(MilliSeconds(900),
712 &LteUplinkPowerControlTestCase::SetTpcConfiguration,
713 this,
714 0,
715 1,
716 22.9539,
717 22.9539,
718 23);
719 Simulator::Schedule(MilliSeconds(1000),
720 &LteUplinkPowerControlTestCase::SetTpcConfiguration,
721 this,
722 0,
723 20,
724 2.9539,
725 2.9539,
726 5.9539);
727 Simulator::Schedule(MilliSeconds(1100),
728 &LteUplinkPowerControlTestCase::SetTpcConfiguration,
729 this,
730 2,
731 5,
732 7.9539,
733 7.9539,
734 10.9539);
735 Simulator::Stop(Seconds(1.200));
736 Simulator::Run();
737
738 Simulator::Destroy();
739}
ns3::BooleanValue
AttributeValue implementation for Boolean.
Definition: boolean.h:37
ns3::DoubleValue
This class can be used to hold variables of floating point type such as 'double' or 'float'.
Definition: double.h:42
ns3::EpsBearer
This class contains the specification of EPS Bearers.
Definition: eps-bearer.h:91
ns3::EpsBearer::Qci
Qci
QoS Class Indicator.
Definition: eps-bearer.h:106
ns3::EpsBearer::GBR_CONV_VOICE
@ GBR_CONV_VOICE
GBR Conversational Voice.
Definition: eps-bearer.h:107
ns3::IntegerValue
Hold a signed integer type.
Definition: integer.h:45
ns3::LteFfrSimple::SetTpc
void SetTpc(uint32_t tpc, uint32_t num, bool acculumatedMode)
Set transmission power control.
Definition: lte-ffr-simple.cc:168
ns3::LteUeNetDevice
The LteUeNetDevice class implements the UE net device.
Definition: lte-ue-net-device.h:57
ns3::LteUeNetDevice::GetPhy
Ptr< LteUePhy > GetPhy() const
Get the Phy.
Definition: lte-ue-net-device.cc:181
ns3::MobilityHelper
Helper class used to assign positions and mobility models to nodes.
Definition: mobility-helper.h:44
ns3::MobilityModel
Keep track of the current position and velocity of an object.
Definition: mobility-model.h:40
ns3::MobilityModel::SetPosition
void SetPosition(const Vector &position)
Definition: mobility-model.cc:92
ns3::NetDeviceContainer
holds a vector of ns3::NetDevice pointers
Definition: net-device-container.h:43
ns3::NetDeviceContainer::Get
Ptr< NetDevice > Get(uint32_t i) const
Get the Ptr<NetDevice> stored in this container at a given index.
Definition: net-device-container.cc:67
ns3::NodeContainer
keep track of a set of node pointers.
Definition: node-container.h:40
ns3::NodeContainer::Create
void Create(uint32_t n)
Create n nodes and append pointers to them to the end of this NodeContainer.
Definition: node-container.cc:84
ns3::NodeContainer::Get
Ptr< Node > Get(uint32_t i) const
Get the Ptr<Node> stored in this container at a given index.
Definition: node-container.cc:78
ns3::ObjectBase::TraceConnectWithoutContext
bool TraceConnectWithoutContext(std::string name, const CallbackBase &cb)
Connect a TraceSource to a Callback without a context.
Definition: object-base.cc:311
ns3::Object::GetObject
Ptr< T > GetObject() const
Get a pointer to the requested aggregated Object.
Definition: object.h:471
ns3::PointerValue
Hold objects of type Ptr<T>.
Definition: pointer.h:37
ns3::PointerValue::GetObject
Ptr< Object > GetObject() const
Get the Object referenced by the PointerValue.
Definition: pointer.cc:57
ns3::PointerValue::Get
Ptr< T > Get() const
Definition: pointer.h:202
ns3::Ptr
Smart pointer class similar to boost::intrusive_ptr.
Definition: ptr.h:78
ns3::Simulator::Schedule
static EventId Schedule(const Time &delay, FUNC f, Ts &&... args)
Schedule an event to expire after delay.
Definition: simulator.h:568
ns3::Simulator::Destroy
static void Destroy()
Execute the events scheduled with ScheduleDestroy().
Definition: simulator.cc:140
ns3::Simulator::Now
static Time Now()
Return the current simulation virtual time.
Definition: simulator.cc:199
ns3::Simulator::Run
static void Run()
Run the simulation.
Definition: simulator.cc:176
ns3::Simulator::Stop
static void Stop()
Tell the Simulator the calling event should be the last one executed.
Definition: simulator.cc:184
ns3::TestCase
encapsulates test code
Definition: test.h:1060
ns3::TestCase::QUICK
@ QUICK
Fast test.
Definition: test.h:1065
ns3::TestCase::AddTestCase
void AddTestCase(TestCase *testCase, TestDuration duration=QUICK)
Add an individual child TestCase to this test suite.
Definition: test.cc:301
ns3::TestSuite
A suite of tests to run.
Definition: test.h:1256
ns3::UintegerValue
Hold an unsigned integer type.
Definition: uinteger.h:45
uint32_t
ns3::Config::Reset
void Reset()
Reset the initial value of every attribute as well as the value of every global to what they were bef...
Definition: config.cc:856
ns3::Config::SetDefault
void SetDefault(std::string name, const AttributeValue &value)
Definition: config.cc:891
NS_LOG_COMPONENT_DEFINE
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:202
NS_LOG_DEBUG
#define NS_LOG_DEBUG(msg)
Use NS_LOG to output a message of level LOG_DEBUG.
Definition: log.h:268
NS_LOG_FUNCTION
#define NS_LOG_FUNCTION(parameters)
If log level LOG_FUNCTION is enabled, this macro will output all input parameters separated by ",...
Definition: log-macros-enabled.h:238
NS_LOG_INFO
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Definition: log.h:275
lteUplinkPowerControlTestSuite
static LteUplinkPowerControlTestSuite lteUplinkPowerControlTestSuite
Static variable for test initialization.
Definition: lte-test-uplink-power-control.cc:75
ns3::MakeBoundCallback
auto MakeBoundCallback(R(*fnPtr)(Args...), BArgs &&... bargs)
Make Callbacks with varying number of bound arguments.
Definition: callback.h:763
NS_TEST_ASSERT_MSG_EQ_TOL
#define NS_TEST_ASSERT_MSG_EQ_TOL(actual, limit, tol, msg)
Test that actual and expected (limit) values are equal to plus or minus some tolerance and report and...
Definition: test.h:337
ns3::Seconds
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1336
ns3::MilliSeconds
Time MilliSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:1348
ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.