A Discrete-Event Network Simulator
API
basic-energy-model-test.cc
Go to the documentation of this file.
1 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * Copyright (c) 2010 Network Security Lab, University of Washington, Seattle.
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License version 2 as
7  * published by the Free Software Foundation;
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17  *
18  * Author: He Wu <mdzz@u.washington.edu>
19  */
20 
21 #include "ns3/basic-energy-source.h"
22 #include "ns3/wifi-radio-energy-model.h"
23 #include "ns3/basic-energy-source-helper.h"
24 #include "ns3/wifi-radio-energy-model-helper.h"
25 #include "ns3/energy-source-container.h"
26 #include "ns3/device-energy-model-container.h"
27 #include "ns3/log.h"
28 #include "ns3/node.h"
29 #include "ns3/simulator.h"
30 #include "ns3/double.h"
31 #include "ns3/config.h"
32 #include "ns3/string.h"
33 #include "ns3/yans-wifi-helper.h"
34 #include <cmath>
35 
36 using namespace ns3;
37 
38 NS_LOG_COMPONENT_DEFINE ("BasicEnergyModelTestSuite");
39 
45 {
46 public:
48  virtual ~BasicEnergyUpdateTest ();
49 
54  bool DoRun (void);
55 
56 private:
64  bool StateSwitchTest (WifiPhyState state);
65 
66 private:
67  double m_timeS; // in seconds
68  double m_tolerance; // tolerance for power estimation
69 
72 };
73 
75 {
76  m_timeS = 15.5; // idle for 15 seconds before changing state
77  m_tolerance = 1.0e-5; //
78 }
79 
81 {
82 }
83 
84 bool
86 {
87  // set types
88  m_energySource.SetTypeId ("ns3::BasicEnergySource");
89  m_deviceEnergyModel.SetTypeId ("ns3::WifiRadioEnergyModel");
90 
91  // run state switch tests
92  if (StateSwitchTest (WifiPhyState::IDLE))
93  {
94  return 1;
95  std::cerr << "Problem with state switch test (WifiPhy idle)." << std::endl;
96  }
97  if (StateSwitchTest (WifiPhyState::CCA_BUSY))
98  {
99  return 1;
100  std::cerr << "Problem with state switch test (WifiPhy cca busy)." << std::endl;
101  }
102  if (StateSwitchTest (WifiPhyState::TX))
103  {
104  return 1;
105  std::cerr << "Problem with state switch test (WifiPhy tx)." << std::endl;
106  }
107  if (StateSwitchTest (WifiPhyState::RX))
108  {
109  return 1;
110  std::cerr << "Problem with state switch test (WifiPhy rx)." << std::endl;
111  }
112  if (StateSwitchTest (WifiPhyState::SWITCHING))
113  {
114  return 1;
115  std::cerr << "Problem with state switch test (WifiPhy switching)." << std::endl;
116  }
117  if (StateSwitchTest (WifiPhyState::SLEEP))
118  {
119  return 1;
120  std::cerr << "Problem with state switch test (WifiPhy sleep)." << std::endl;
121  }
122  return 0;
123 }
124 
125 bool
127 {
128  // create node
129  Ptr<Node> node = CreateObject<Node> ();
130 
131  // create energy source
132  Ptr<BasicEnergySource> source = m_energySource.Create<BasicEnergySource> ();
133  source->SetInitialEnergy (50);
134  // aggregate energy source to node
135  node->AggregateObject (source);
136  source->SetNode (node);
137 
138  // create device energy model
140  m_deviceEnergyModel.Create<WifiRadioEnergyModel> ();
141  // set energy source pointer
142  model->SetEnergySource (source);
143  // add device energy model to model list in energy source
144  source->AppendDeviceEnergyModel (model);
145 
146  // retrieve device energy model from energy source
148  source->FindDeviceEnergyModels ("ns3::WifiRadioEnergyModel");
149  // check list
150  if ((models.GetN () == 0))
151  {
152  std::cerr << "Model list is empty!." << std::endl;
153  return true;
154  }
155  // get pointer
156  Ptr<WifiRadioEnergyModel> devModel =
157  DynamicCast<WifiRadioEnergyModel> (models.Get (0));
158  // check pointer
159  if ((devModel == 0))
160  {
161  std::cerr << "NULL pointer to device model!." << std::endl;
162  return true;
163  }
164 
165  /*
166  * The radio will stay IDLE for m_timeS seconds. Then it will switch into a
167  * different state.
168  */
169 
170  // schedule change of state
171  Simulator::Schedule (Seconds (m_timeS),
172  &WifiRadioEnergyModel::ChangeState, devModel, state);
173 
174  // Calculate remaining energy at simulation stop time
175  Simulator::Schedule (Seconds (m_timeS * 2),
177 
178  double timeDelta = 0.000000001; // 1 nanosecond
179  // run simulation; stop just after last scheduled event
180  Simulator::Stop (Seconds (m_timeS * 2 + timeDelta));
181  Simulator::Run ();
182 
183  // energy = current * voltage * time
184 
185  // calculate idle power consumption
186  double estRemainingEnergy = source->GetInitialEnergy ();
187  double voltage = source->GetSupplyVoltage ();
188  estRemainingEnergy -= devModel->GetIdleCurrentA () * voltage * m_timeS;
189 
190  // calculate new state power consumption
191  double current = 0.0;
192  switch (state)
193  {
194  case WifiPhyState::IDLE:
195  current = devModel->GetIdleCurrentA ();
196  break;
198  current = devModel->GetCcaBusyCurrentA ();
199  break;
200  case WifiPhyState::TX:
201  current = devModel->GetTxCurrentA ();
202  break;
203  case WifiPhyState::RX:
204  current = devModel->GetRxCurrentA ();
205  break;
207  current = devModel->GetSwitchingCurrentA ();
208  break;
209  case WifiPhyState::SLEEP:
210  current = devModel->GetSleepCurrentA ();
211  break;
212  case WifiPhyState::OFF:
213  current = 0;
214  break;
215  default:
216  NS_FATAL_ERROR ("Undefined radio state: " << state);
217  break;
218  }
219  estRemainingEnergy -= current * voltage * m_timeS;
220  estRemainingEnergy = std::max (0.0, estRemainingEnergy);
221 
222  // obtain remaining energy from source
223  double remainingEnergy = source->GetRemainingEnergy ();
224  NS_LOG_DEBUG ("Remaining energy is " << remainingEnergy);
225  NS_LOG_DEBUG ("Estimated remaining energy is " << estRemainingEnergy);
226  NS_LOG_DEBUG ("Difference is " << estRemainingEnergy - remainingEnergy);
227 
228  // check remaining energy
229  if ((remainingEnergy > (estRemainingEnergy + m_tolerance))
230  || (remainingEnergy < (estRemainingEnergy - m_tolerance)))
231  {
232  std::cerr << "Incorrect remaining energy!" << std::endl;
233  return true;
234  }
235 
236  // obtain radio state
237  WifiPhyState endState = devModel->GetCurrentState ();
238  NS_LOG_DEBUG ("Radio state is " << endState);
239  // check end state
240  if (endState != state)
241  {
242  std::cerr << "Incorrect end state!" << std::endl;
243  return true;
244  }
246 
247  return false; // no error
248 }
249 
250 // -------------------------------------------------------------------------- //
251 
257 {
258 public:
260  virtual ~BasicEnergyDepletionTest ();
261 
266  bool DoRun (void);
267 
268 private:
272  void DepletionHandler (void);
273 
281  bool DepletionTestCase (double simTimeS, double updateIntervalS);
282 
283 private:
284  int m_numOfNodes; // number of nodes in simulation
285  int m_callbackCount; // counter for # of callbacks invoked
286  double m_simTimeS; // maximum simulation time, in seconds
287  double m_timeStepS; // simulation time step size, in seconds
288  double m_updateIntervalS; // update interval of each device model
289 
290 };
291 
293 {
294  m_numOfNodes = 10;
295  m_callbackCount = 0;
296  m_simTimeS = 4.5;
297  m_timeStepS = 0.5;
298  m_updateIntervalS = 1.5;
299 }
300 
302 {
303 }
304 
305 bool
307 {
308  /*
309  * Run simulation with different simulation time and update interval.
310  */
311  uint8_t ret = 0;
312 
313  for (double simTimeS = 0.0; simTimeS <= m_simTimeS; simTimeS += m_timeStepS)
314  {
315  for (double updateIntervalS = 0.5; updateIntervalS <= m_updateIntervalS;
316  updateIntervalS += m_timeStepS)
317  {
318  if (DepletionTestCase (simTimeS, updateIntervalS))
319  {
320  ret = 1;
321  std::cerr << "Depletion test case problem." << std::endl;
322  }
323  // reset callback count
324  m_callbackCount = 0;
325  }
326  }
327  return ret;
328 }
329 
330 void
332 {
333  m_callbackCount++;
334 }
335 
336 bool
338  double updateIntervalS)
339 {
340  // create node
341  NodeContainer c;
342  c.Create (m_numOfNodes);
343 
344  std::string phyMode ("DsssRate1Mbps");
345 
346  // disable fragmentation for frames below 2200 bytes
347  Config::SetDefault ("ns3::WifiRemoteStationManager::FragmentationThreshold",
348  StringValue ("2200"));
349  // turn off RTS/CTS for frames below 2200 bytes
350  Config::SetDefault ("ns3::WifiRemoteStationManager::RtsCtsThreshold",
351  StringValue ("2200"));
352  // Fix non-unicast data rate to be the same as that of unicast
353  Config::SetDefault ("ns3::WifiRemoteStationManager::NonUnicastMode",
354  StringValue (phyMode));
355 
356  // install YansWifiPhy
358  wifi.SetStandard (WIFI_PHY_STANDARD_80211b);
359 
361  /*
362  * This is one parameter that matters when using FixedRssLossModel, set it to
363  * zero; otherwise, gain will be added.
364  */
365  wifiPhy.Set ("RxGain", DoubleValue (0));
366  // ns-3 supports RadioTap and Prism tracing extensions for 802.11b
368 
369  YansWifiChannelHelper wifiChannel;
370  wifiChannel.SetPropagationDelay ("ns3::ConstantSpeedPropagationDelayModel");
371  wifiPhy.SetChannel (wifiChannel.Create ());
372 
373  // Add a MAC and disable rate control
374  WifiMacHelper wifiMac;
375  wifi.SetRemoteStationManager ("ns3::ConstantRateWifiManager",
376  "DataMode", StringValue (phyMode),
377  "ControlMode", StringValue (phyMode));
378  // Set it to ad-hoc mode
379  wifiMac.SetType ("ns3::AdhocWifiMac");
380  NetDeviceContainer devices = wifi.Install (wifiPhy, wifiMac, c);
381 
382  /*
383  * Create and install energy source and a single basic radio energy model on
384  * the node using helpers.
385  */
386  // source helper
387  BasicEnergySourceHelper basicSourceHelper;
388  // set energy to 0 so that we deplete energy at the beginning of simulation
389  basicSourceHelper.Set ("BasicEnergySourceInitialEnergyJ", DoubleValue (0.0));
390  // set update interval
391  basicSourceHelper.Set ("PeriodicEnergyUpdateInterval",
392  TimeValue (Seconds (updateIntervalS)));
393  // install source
394  EnergySourceContainer sources = basicSourceHelper.Install (c);
395 
396  // device energy model helper
397  WifiRadioEnergyModelHelper radioEnergyHelper;
398  // set energy depletion callback
401  radioEnergyHelper.SetDepletionCallback (callback);
402  // install on node
403  DeviceEnergyModelContainer deviceModels = radioEnergyHelper.Install (devices, sources);
404 
405  // run simulation
406  Simulator::Stop (Seconds (simTimeS));
407  Simulator::Run ();
409 
410  NS_LOG_DEBUG ("Simulation time = " << simTimeS << "s");
411  NS_LOG_DEBUG ("Update interval = " << updateIntervalS << "s");
412  NS_LOG_DEBUG ("Expected callback count is " << m_numOfNodes);
413  NS_LOG_DEBUG ("Actual callback count is " << m_callbackCount);
414 
415  // check result, call back should only be invoked once
416  if (m_numOfNodes != m_callbackCount)
417  {
418  std::cerr << "Not all callbacks are invoked!" << std::endl;
419  return true;
420  }
421 
422  return false;
423 }
424 
425 // -------------------------------------------------------------------------- //
426 
427 int
428 main (int argc, char **argv)
429 {
430  BasicEnergyUpdateTest testEnergyUpdate;
431  if (testEnergyUpdate.DoRun ())
432  {
433  return 1;
434  }
435 
436  BasicEnergyDepletionTest testEnergyDepletion;
437  if (testEnergyDepletion.DoRun ())
438  {
439  return 1;
440  }
441 
442  return 0;
443 }
void Set(std::string name, const AttributeValue &v)
Definition: wifi-helper.cc:143
double GetRxCurrentA(void) const
Gets receive current.
Assign WifiRadioEnergyModel to wifi devices.
Holds a vector of ns3::EnergySource pointers.
void SetDepletionCallback(WifiRadioEnergyModel::WifiRadioEnergyDepletionCallback callback)
Hold variables of type string.
Definition: string.h:41
Make it easy to create and manage PHY objects for the yans model.
double GetTxCurrentA(void) const
Gets transmit current.
bool StateSwitchTest(WifiPhyState state)
void AggregateObject(Ptr< Object > other)
Aggregate two Objects together.
Definition: object.cc:252
The PHY layer is sleeping.
static void Run(void)
Run the simulation.
Definition: simulator.cc:170
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:204
BasicEnergySource decreases/increases remaining energy stored in itself in linearly.
void ChangeState(int newState)
Changes state of the WifiRadioEnergyMode.
#define NS_FATAL_ERROR(msg)
Report a fatal error with a message and terminate.
Definition: fatal-error.h:162
virtual void UpdateEnergySource(void)
Implements UpdateEnergySource.
Test case of update remaining energy for BasicEnergySource and WifiRadioEnergyModel.
static YansWifiPhyHelper Default(void)
Create a phy helper in a default working state.
helps to create WifiNetDevice objects
Definition: wifi-helper.h:300
Holds a vector of ns3::DeviceEnergyModel pointers.
Ptr< DeviceEnergyModel > Get(uint32_t i) const
Get the i-th Ptr<DeviceEnergyModel> stored in this container.
Ptr< YansWifiChannel > Create(void) const
void SetChannel(Ptr< YansWifiChannel > channel)
WifiPhyState GetCurrentState(void) const
static EventId Schedule(Time const &delay, MEM mem_ptr, OBJ obj)
Schedule an event to expire after delay.
Definition: simulator.h:1389
#define max(a, b)
Definition: 80211b.c:43
AttributeValue implementation for Time.
Definition: nstime.h:1124
Creates a BasicEnergySource object.
holds a vector of ns3::NetDevice pointers
uint32_t GetN(void) const
Get the number of Ptr<DeviceEnergyModel> stored in this container.
The PHY layer has sense the medium busy through the CCA mechanism.
Callback< R > MakeCallback(R(T::*memPtr)(void), OBJ objPtr)
Definition: callback.h:1489
double GetSwitchingCurrentA(void) const
Gets switching current.
static void Destroy(void)
Execute the events scheduled with ScheduleDestroy().
Definition: simulator.cc:134
Every class exported by the ns3 library is enclosed in the ns3 namespace.
keep track of a set of node pointers.
The PHY layer is IDLE.
bool DoRun(void)
Performs some tests involving state updates and the relative energy consumption.
WifiPhyState
The state of the PHY layer.
DSSS PHY (Clause 15) and HR/DSSS PHY (Clause 18)
bool DoRun(void)
Performs some tests involving energy depletion.
Test case of energy depletion handling for BasicEnergySource and WifiRadioEnergyModel.
manage and create wifi channel objects for the yans model.
create MAC layers for a ns3::WifiNetDevice.
void SetPcapDataLinkType(SupportedPcapDataLinkTypes dlt)
Set the data link type of PCAP traces to be used.
Definition: wifi-helper.cc:514
double GetCcaBusyCurrentA(void) const
Gets CCA busy current.
A WiFi radio energy model.
virtual void SetType(std::string type, std::string n0="", const AttributeValue &v0=EmptyAttributeValue(), std::string n1="", const AttributeValue &v1=EmptyAttributeValue(), std::string n2="", const AttributeValue &v2=EmptyAttributeValue(), std::string n3="", const AttributeValue &v3=EmptyAttributeValue(), std::string n4="", const AttributeValue &v4=EmptyAttributeValue(), std::string n5="", const AttributeValue &v5=EmptyAttributeValue(), std::string n6="", const AttributeValue &v6=EmptyAttributeValue(), std::string n7="", const AttributeValue &v7=EmptyAttributeValue(), std::string n8="", const AttributeValue &v8=EmptyAttributeValue(), std::string n9="", const AttributeValue &v9=EmptyAttributeValue(), std::string n10="", const AttributeValue &v10=EmptyAttributeValue())
wifi
Definition: third.py:96
Instantiate subclasses of ns3::Object.
The PHY layer is sending a packet.
EnergySourceContainer Install(Ptr< Node > node) const
static void Stop(void)
Tell the Simulator the calling event should be the last one executed.
Definition: simulator.cc:178
#define NS_LOG_DEBUG(msg)
Use NS_LOG to output a message of level LOG_DEBUG.
Definition: log.h:272
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1062
The PHY layer is receiving a packet.
void SetDefault(std::string name, const AttributeValue &value)
Definition: config.cc:810
void Set(std::string name, const AttributeValue &v)
The PHY layer is switched off.
The PHY layer is switching to other channel.
void SetInitialEnergy(double initialEnergyJ)
void Create(uint32_t n)
Create n nodes and append pointers to them to the end of this NodeContainer.
void SetEnergySource(const Ptr< EnergySource > source)
Sets pointer to EnergySouce installed on node.
void SetPropagationDelay(std::string name, std::string n0="", const AttributeValue &v0=EmptyAttributeValue(), std::string n1="", const AttributeValue &v1=EmptyAttributeValue(), std::string n2="", const AttributeValue &v2=EmptyAttributeValue(), std::string n3="", const AttributeValue &v3=EmptyAttributeValue(), std::string n4="", const AttributeValue &v4=EmptyAttributeValue(), std::string n5="", const AttributeValue &v5=EmptyAttributeValue(), std::string n6="", const AttributeValue &v6=EmptyAttributeValue(), std::string n7="", const AttributeValue &v7=EmptyAttributeValue())
devices
Definition: first.py:32
This class can be used to hold variables of floating point type such as &#39;double&#39; or &#39;float&#39;...
Definition: double.h:41
double GetSleepCurrentA(void) const
Gets sleep current.
Include Radiotap link layer information.
Definition: wifi-helper.h:179
bool DepletionTestCase(double simTimeS, double updateIntervalS)
void DepletionHandler(void)
Callback invoked when energy is drained from source.
double GetIdleCurrentA(void) const
Gets idle current.
DeviceEnergyModelContainer Install(Ptr< NetDevice > device, Ptr< EnergySource > source) const