A Discrete-Event Network Simulator
API
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 
47 using namespace ns3;
48 
49 NS_LOG_COMPONENT_DEFINE("LteUplinkPowerControlTest");
50 
55 LteUplinkPowerControlTestSuite::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 
75 static LteUplinkPowerControlTestSuite lteUplinkPowerControlTestSuite;
76 
80 void
81 PuschTxPowerNotification(LteUplinkPowerControlTestCase* testcase,
82  uint16_t cellId,
83  uint16_t rnti,
84  double txPower)
85 {
86  testcase->PuschTxPowerTrace(cellId, rnti, txPower);
87 }
88 
89 void
90 PucchTxPowerNotification(LteUplinkPowerControlTestCase* testcase,
91  uint16_t cellId,
92  uint16_t rnti,
93  double txPower)
94 {
95  testcase->PucchTxPowerTrace(cellId, rnti, txPower);
96 }
97 
98 void
99 SrsTxPowerNotification(LteUplinkPowerControlTestCase* testcase,
100  uint16_t cellId,
101  uint16_t rnti,
102  double txPower)
103 {
104  testcase->SrsTxPowerTrace(cellId, rnti, txPower);
105 }
106 
107 LteUplinkPowerControlTestCase::LteUplinkPowerControlTestCase(std::string name)
108  : TestCase(name)
109 {
110  NS_LOG_INFO("Creating LteUplinkPowerControlTestCase");
111 }
112 
113 LteUplinkPowerControlTestCase::~LteUplinkPowerControlTestCase()
114 {
115 }
116 
117 void
118 LteUplinkPowerControlTestCase::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 
135 void
136 LteUplinkPowerControlTestCase::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 
153 void
154 LteUplinkPowerControlTestCase::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 
167 void
168 LteUplinkPowerControlTestCase::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 
182 void
183 LteUplinkPowerControlTestCase::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 
196 void
197 LteUplinkPowerControlTestCase::DoRun()
198 {
199 }
200 
201 LteUplinkOpenLoopPowerControlTestCase::LteUplinkOpenLoopPowerControlTestCase(std::string name)
202  : LteUplinkPowerControlTestCase("Uplink Open Loop Power Control: " + name)
203 {
204  NS_LOG_INFO("Creating LteUplinkPowerControlTestCase");
205 }
206 
207 LteUplinkOpenLoopPowerControlTestCase::~LteUplinkOpenLoopPowerControlTestCase()
208 {
209 }
210 
211 void
212 LteUplinkOpenLoopPowerControlTestCase::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(&PuschTxPowerNotification, this));
273  m_ueUpc->TraceConnectWithoutContext("ReportPucchTxPower",
274  MakeBoundCallback(&PucchTxPowerNotification, this));
275  m_ueUpc->TraceConnectWithoutContext("ReportSrsTxPower",
276  MakeBoundCallback(&SrsTxPowerNotification, 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 
381 LteUplinkClosedLoopPowerControlAbsoluteModeTestCase::
382  LteUplinkClosedLoopPowerControlAbsoluteModeTestCase(std::string name)
383  : LteUplinkPowerControlTestCase("Uplink Closed Loop Power Control: " + name)
384 {
385  NS_LOG_INFO("Creating LteUplinkClosedLoopPowerControlAbsoluteModeTestCase");
386 }
387 
388 LteUplinkClosedLoopPowerControlAbsoluteModeTestCase::
389  ~LteUplinkClosedLoopPowerControlAbsoluteModeTestCase()
390 {
391 }
392 
393 void
394 LteUplinkClosedLoopPowerControlAbsoluteModeTestCase::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(&PuschTxPowerNotification, this));
456  m_ueUpc->TraceConnectWithoutContext("ReportPucchTxPower",
457  MakeBoundCallback(&PucchTxPowerNotification, this));
458  m_ueUpc->TraceConnectWithoutContext("ReportSrsTxPower",
459  MakeBoundCallback(&SrsTxPowerNotification, 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 
545 LteUplinkClosedLoopPowerControlAccumulatedModeTestCase::
546  LteUplinkClosedLoopPowerControlAccumulatedModeTestCase(std::string name)
547  : LteUplinkPowerControlTestCase("Uplink Closed Loop Power Control: " + name)
548 {
549  NS_LOG_INFO("Creating LteUplinkClosedLoopPowerControlAccumulatedModeTestCase");
550 }
551 
552 LteUplinkClosedLoopPowerControlAccumulatedModeTestCase::
553  ~LteUplinkClosedLoopPowerControlAccumulatedModeTestCase()
554 {
555 }
556 
557 void
558 LteUplinkClosedLoopPowerControlAccumulatedModeTestCase::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(&PuschTxPowerNotification, this));
620  m_ueUpc->TraceConnectWithoutContext("ReportPucchTxPower",
621  MakeBoundCallback(&PucchTxPowerNotification, this));
622  m_ueUpc->TraceConnectWithoutContext("ReportSrsTxPower",
623  MakeBoundCallback(&SrsTxPowerNotification, 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::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::IntegerValue
Hold a signed integer type.
Definition: integer.h:45
ns3::LteFfrSimple::SetTpc
void SetTpc(uint32_t tpc, uint32_t num, bool accumulatedMode)
Set transmission power control.
Definition: lte-ffr-simple.cc:168
ns3::LteHelper::SetFfrAlgorithmType
void SetFfrAlgorithmType(std::string type)
Set the type of FFR algorithm to be used by eNodeB devices.
Definition: lte-helper.cc:319
ns3::LteHelper::InstallEnbDevice
NetDeviceContainer InstallEnbDevice(NodeContainer c)
Create a set of eNodeB devices.
Definition: lte-helper.cc:485
ns3::LteHelper::SetSchedulerType
void SetSchedulerType(std::string type)
Set the type of scheduler to be used by eNodeB devices.
Definition: lte-helper.cc:292
ns3::LteHelper::Attach
void Attach(NetDeviceContainer ueDevices)
Enables automatic attachment of a set of UE devices to a suitable cell using Idle mode initial cell s...
Definition: lte-helper.cc:1039
ns3::LteHelper::SetEnbDeviceAttribute
void SetEnbDeviceAttribute(std::string n, const AttributeValue &v)
Set an attribute for the eNodeB devices (LteEnbNetDevice) to be created.
Definition: lte-helper.cc:412
ns3::LteHelper::ActivateDataRadioBearer
void ActivateDataRadioBearer(NetDeviceContainer ueDevices, EpsBearer bearer)
Activate a Data Radio Bearer on a given UE devices (for LTE-only simulation).
Definition: lte-helper.cc:1436
ns3::LteHelper::InstallUeDevice
NetDeviceContainer InstallUeDevice(NodeContainer c)
Create a set of UE devices.
Definition: lte-helper.cc:500
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:315
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::TestCase
encapsulates test code
Definition: test.h:1060
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
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:855
ns3::Config::SetDefault
void SetDefault(std::string name, const AttributeValue &value)
Definition: config.cc:890
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:240
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:765
ns3::Now
Time Now()
create an ns3::Time instance which contains the current simulation time.
Definition: simulator.cc:305
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:1326
ns3::MilliSeconds
Time MilliSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:1338
ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.
third.mobility
mobility
Definition: third.py:105