A Discrete-Event Network Simulator
API
wifi-sleep.cc
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2009 The Boeing Company
3  * 2014 Universita' degli Studi di Napoli "Federico II"
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  */
19 
20 // This script configures two nodes on an 802.11b physical layer, with
21 // 802.11b NICs in adhoc mode. One of the nodes generates on-off traffic
22 // destined to the other node.
23 //
24 // The purpose is to test the energy depletion on the nodes and the
25 // activation of the callback that puts a node in the sleep state when
26 // its energy is depleted. Furthermore, this script can be used to test
27 // the available policies for updating the transmit current based on
28 // the nominal tx power used to transmit each frame.
29 //
30 // There are a number of command-line options available to control
31 // the default behavior. The list of available command-line options
32 // can be listed with the following command:
33 // ./ns3 run "wifi-sleep --help"
34 //
35 // Note that all ns-3 attributes (not just the ones exposed in the below
36 // script) can be changed at command line; see the documentation.
37 //
38 // This script can also be helpful to put the Wifi layer into verbose
39 // logging mode; this command will turn on all wifi logging:
40 //
41 // ./ns3 run "wifi-sleep --verbose=1"
42 //
43 // When you are done, you will notice four trace files in your directory:
44 // two for the remaining energy on each node and two for the state transitions
45 // of each node.
46 
47 #include "ns3/basic-energy-source-helper.h"
48 #include "ns3/command-line.h"
49 #include "ns3/config.h"
50 #include "ns3/internet-stack-helper.h"
51 #include "ns3/ipv4-address-helper.h"
52 #include "ns3/log.h"
53 #include "ns3/mobility-helper.h"
54 #include "ns3/mobility-model.h"
55 #include "ns3/on-off-helper.h"
56 #include "ns3/packet-sink-helper.h"
57 #include "ns3/string.h"
58 #include "ns3/wifi-net-device.h"
59 #include "ns3/wifi-radio-energy-model-helper.h"
60 #include "ns3/wifi-utils.h"
61 #include "ns3/yans-wifi-channel.h"
62 #include "ns3/yans-wifi-helper.h"
63 
64 using namespace ns3;
65 
66 NS_LOG_COMPONENT_DEFINE("WifiSleep");
67 
75 template <int node>
76 void
77 RemainingEnergyTrace(double oldValue, double newValue)
78 {
79  std::stringstream ss;
80  ss << "energy_" << node << ".log";
81 
82  static std::fstream f(ss.str(), std::ios::out);
83 
84  f << Simulator::Now().GetSeconds() << " remaining energy=" << newValue << std::endl;
85 }
86 
96 template <int node>
97 void
98 PhyStateTrace(std::string context, Time start, Time duration, WifiPhyState state)
99 {
100  std::stringstream ss;
101  ss << "state_" << node << ".log";
102 
103  static std::fstream f(ss.str(), std::ios::out);
104 
105  f << Simulator::Now().GetSeconds() << " state=" << state << " start=" << start
106  << " duration=" << duration << std::endl;
107 }
108 
109 int
110 main(int argc, char* argv[])
111 {
112  std::string dataRate = "1Mbps";
113  uint32_t packetSize = 1000; // bytes
114  double duration = 10.0; // seconds
115  double initialEnergy = 7.5; // joule
116  double voltage = 3.0; // volts
117  double txPowerStart = 0.0; // dbm
118  double txPowerEnd = 15.0; // dbm
119  uint32_t nTxPowerLevels = 16;
120  uint32_t txPowerLevel = 0;
121  double idleCurrent = 0.273; // Ampere
122  double txCurrent = 0.380; // Ampere
123  bool verbose = false;
124 
125  CommandLine cmd(__FILE__);
126  cmd.AddValue("dataRate", "Data rate", dataRate);
127  cmd.AddValue("packetSize", "size of application packet sent", packetSize);
128  cmd.AddValue("duration", "duration (seconds) of the experiment", duration);
129  cmd.AddValue("initialEnergy", "Initial Energy (Joule) of each node", initialEnergy);
130  cmd.AddValue("voltage", "Supply voltage (Joule)", voltage);
131  cmd.AddValue("txPowerStart", "Minimum available transmission level (dbm)", txPowerStart);
132  cmd.AddValue("txPowerEnd", "Maximum available transmission level (dbm)", txPowerEnd);
133  cmd.AddValue("nTxPowerLevels",
134  "Number of transmission power levels available between txPowerStart and "
135  "txPowerEnd included",
136  nTxPowerLevels);
137  cmd.AddValue("txPowerLevel", "Transmission power level", txPowerLevel);
138  cmd.AddValue("idleCurrent", "The radio Idle current in Ampere", idleCurrent);
139  cmd.AddValue("txCurrent", "The radio Tx current in Ampere", txCurrent);
140  cmd.AddValue("verbose", "turn on all WifiNetDevice log components", verbose);
141  cmd.Parse(argc, argv);
142 
143  NodeContainer c;
144  c.Create(2);
145 
146  // The below set of helpers will help us to put together the wifi NICs we want
148  if (verbose)
149  {
150  WifiHelper::EnableLogComponents(); // Turn on all Wifi logging
151  }
152  wifi.SetStandard(WIFI_STANDARD_80211b);
153 
154  YansWifiPhyHelper wifiPhy;
155  wifiPhy.Set("TxPowerStart", DoubleValue(txPowerStart));
156  wifiPhy.Set("TxPowerEnd", DoubleValue(txPowerEnd));
157  wifiPhy.Set("TxPowerLevels", UintegerValue(nTxPowerLevels));
158 
160  wifiPhy.SetChannel(wifiChannel.Create());
161 
162  // Add a mac and set the selected tx power level
163  WifiMacHelper wifiMac;
164  wifi.SetRemoteStationManager("ns3::ArfWifiManager",
165  "DefaultTxPowerLevel",
166  UintegerValue(txPowerLevel));
167  // Set it to adhoc mode
168  wifiMac.SetType("ns3::AdhocWifiMac");
169  NetDeviceContainer devices = wifi.Install(wifiPhy, wifiMac, c);
170 
172  Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator>();
173  positionAlloc->Add(Vector(0.0, 0.0, 0.0));
174  positionAlloc->Add(Vector(10.0, 0.0, 0.0));
175  mobility.SetPositionAllocator(positionAlloc);
176  mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
177  mobility.Install(c);
178 
180  internet.Install(c);
181 
183  NS_LOG_INFO("Assign IP Addresses.");
184  ipv4.SetBase("10.1.1.0", "255.255.255.0");
185  Ipv4InterfaceContainer i = ipv4.Assign(devices);
186 
188 
189  std::string transportProto = std::string("ns3::UdpSocketFactory");
190  OnOffHelper onOff(transportProto, InetSocketAddress(Ipv4Address("10.1.1.2"), 9000));
191 
192  onOff.SetAttribute("DataRate", DataRateValue(DataRate(dataRate)));
193  onOff.SetAttribute("PacketSize", UintegerValue(packetSize));
194  onOff.SetAttribute("OffTime", StringValue("ns3::ConstantRandomVariable[Constant=0.001]"));
195 
196  apps = onOff.Install(c.Get(0));
197 
198  apps.Start(Seconds(0.01));
199  apps.Stop(Seconds(duration));
200 
201  // Create a packet sink to receive these packets
203  apps = sink.Install(c.Get(1));
204  apps.Start(Seconds(0.01));
205  apps.Stop(Seconds(duration));
206 
207  // Energy sources
208  EnergySourceContainer eSources;
209  BasicEnergySourceHelper basicSourceHelper;
210  WifiRadioEnergyModelHelper radioEnergyHelper;
211 
212  basicSourceHelper.Set("BasicEnergySourceInitialEnergyJ", DoubleValue(initialEnergy));
213  basicSourceHelper.Set("BasicEnergySupplyVoltageV", DoubleValue(voltage));
214 
215  radioEnergyHelper.Set("IdleCurrentA", DoubleValue(idleCurrent));
216  radioEnergyHelper.Set("TxCurrentA", DoubleValue(txCurrent));
217 
218  // compute the efficiency of the power amplifier (eta) assuming that the provided value for tx
219  // current corresponds to the minimum tx power level
220  double eta = DbmToW(txPowerStart) / ((txCurrent - idleCurrent) * voltage);
221 
222  radioEnergyHelper.SetTxCurrentModel("ns3::LinearWifiTxCurrentModel",
223  "Voltage",
224  DoubleValue(voltage),
225  "IdleCurrent",
226  DoubleValue(idleCurrent),
227  "Eta",
228  DoubleValue(eta));
229 
230  // install an energy source on each node
231  for (auto n = c.Begin(); n != c.End(); n++)
232  {
233  eSources.Add(basicSourceHelper.Install(*n));
234 
235  Ptr<WifiNetDevice> wnd;
236 
237  for (uint32_t i = 0; i < (*n)->GetNDevices(); ++i)
238  {
239  wnd = (*n)->GetDevice(i)->GetObject<WifiNetDevice>();
240  // if it is a WifiNetDevice
241  if (wnd)
242  {
243  // this device draws power from the last created energy source
244  radioEnergyHelper.Install(wnd, eSources.Get(eSources.GetN() - 1));
245  }
246  }
247  }
248 
249  // Tracing
250  eSources.Get(0)->TraceConnectWithoutContext("RemainingEnergy",
251  MakeCallback(&RemainingEnergyTrace<0>));
252  eSources.Get(1)->TraceConnectWithoutContext("RemainingEnergy",
253  MakeCallback(&RemainingEnergyTrace<1>));
254 
255  Config::Connect("/NodeList/0/DeviceList/*/Phy/State/State", MakeCallback(&PhyStateTrace<0>));
256  Config::Connect("/NodeList/1/DeviceList/*/Phy/State/State", MakeCallback(&PhyStateTrace<1>));
257 
258  Simulator::Stop(Seconds(duration + 1));
259 
260  Simulator::Run();
262 
263  return 0;
264 }
double f(double x, void *params)
Definition: 80211b.c:70
holds a vector of ns3::Application pointers.
void Start(Time start) const
Start all of the Applications in this container at the start time given as a parameter.
void Stop(Time stop) const
Arrange for all of the Applications in this container to Stop() at the Time given as a parameter.
Creates a BasicEnergySource object.
void Set(std::string name, const AttributeValue &v) override
Parse command-line arguments.
Definition: command-line.h:232
DeviceEnergyModelContainer Install(Ptr< NetDevice > device, Ptr< EnergySource > source) const
This class can be used to hold variables of floating point type such as 'double' or 'float'.
Definition: double.h:42
Holds a vector of ns3::EnergySource pointers.
Ptr< EnergySource > Get(uint32_t i) const
Get the i-th Ptr<EnergySource> stored in this container.
uint32_t GetN() const
Get the number of Ptr<EnergySource> stored in this container.
void Add(EnergySourceContainer container)
EnergySourceContainer Install(Ptr< Node > node) const
an Inet address class
aggregate IP/TCP/UDP functionality to existing Nodes.
A helper class to make life easier while doing simple IPv4 address assignment in scripts.
Ipv4 addresses are stored in host order in this class.
Definition: ipv4-address.h:42
static Ipv4Address GetAny()
holds a vector of std::pair of Ptr<Ipv4> and interface index.
Helper class used to assign positions and mobility models to nodes.
holds a vector of ns3::NetDevice pointers
keep track of a set of node pointers.
Iterator End() const
Get an iterator which indicates past-the-last Node in the container.
void Create(uint32_t n)
Create n nodes and append pointers to them to the end of this NodeContainer.
Iterator Begin() const
Get an iterator which refers to the first Node in the container.
Ptr< Node > Get(uint32_t i) const
Get the Ptr<Node> stored in this container at a given index.
Ptr< T > GetObject() const
Get a pointer to the requested aggregated Object.
Definition: object.h:471
A helper to make it easier to instantiate an ns3::OnOffApplication on a set of nodes.
Definition: on-off-helper.h:44
A helper to make it easier to instantiate an ns3::PacketSinkApplication on a set of nodes.
Smart pointer class similar to boost::intrusive_ptr.
Definition: ptr.h:77
static void Destroy()
Execute the events scheduled with ScheduleDestroy().
Definition: simulator.cc:142
static Time Now()
Return the current simulation virtual time.
Definition: simulator.cc:208
static void Run()
Run the simulation.
Definition: simulator.cc:178
static void Stop()
Tell the Simulator the calling event should be the last one executed.
Definition: simulator.cc:186
Hold variables of type string.
Definition: string.h:56
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:105
double GetSeconds() const
Get an approximation of the time stored in this instance in the indicated unit.
Definition: nstime.h:403
Hold an unsigned integer type.
Definition: uinteger.h:45
helps to create WifiNetDevice objects
Definition: wifi-helper.h:324
static void EnableLogComponents()
Helper to enable all WifiNetDevice log components with one statement.
Definition: wifi-helper.cc:880
create MAC layers for a ns3::WifiNetDevice.
void SetType(std::string type, Args &&... args)
Hold together all Wifi-related objects.
void Set(std::string name, const AttributeValue &v)
Definition: wifi-helper.cc:163
Assign WifiRadioEnergyModel to wifi devices.
void Set(std::string name, const AttributeValue &v) override
void SetTxCurrentModel(std::string name, Ts &&... args)
manage and create wifi channel objects for the YANS model.
static YansWifiChannelHelper Default()
Create a channel helper in a default working state.
Ptr< YansWifiChannel > Create() const
Make it easy to create and manage PHY objects for the YANS model.
void SetChannel(Ptr< YansWifiChannel > channel)
void Connect(std::string path, const CallbackBase &cb)
Definition: config.cc:974
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:202
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Definition: log.h:275
void(* DataRate)(DataRate oldValue, DataRate newValue)
TracedValue callback signature for DataRate.
Definition: data-rate.h:327
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1326
@ WIFI_STANDARD_80211b
devices
Definition: first.py:42
Every class exported by the ns3 library is enclosed in the ns3 namespace.
Callback< R, Args... > MakeCallback(R(T::*memPtr)(Args...), OBJ objPtr)
Build Callbacks for class method members which take varying numbers of arguments and potentially retu...
Definition: callback.h:704
double DbmToW(double dBm)
Convert from dBm to Watts.
Definition: wifi-utils.cc:40
cmd
Definition: second.py:40
wifi
Definition: third.py:95
mobility
Definition: third.py:105
bool verbose
WifiPhyState
The state of the PHY layer.
static const uint32_t packetSize
Packet size generated at the AP.
void RemainingEnergyTrace(double oldValue, double newValue)
Remaining energy trace sink.
Definition: wifi-sleep.cc:77
void PhyStateTrace(std::string context, Time start, Time duration, WifiPhyState state)
PHY state trace sink.
Definition: wifi-sleep.cc:98
Ptr< PacketSink > sink
Pointer to the packet sink application.
Definition: wifi-tcp.cc:55