A Discrete-Event Network Simulator
API
Loading...
Searching...
No Matches
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
64using namespace ns3;
65
66NS_LOG_COMPONENT_DEFINE("WifiSleep");
67
75template <int node>
76void
77RemainingEnergyTrace(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
96template <int node>
97void
98PhyStateTrace(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
109int
110main(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
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
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
262
263 return 0;
264}
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
Class for representing data rates.
Definition: data-rate.h:89
AttributeValue implementation for DataRate.
Definition: data-rate.h:296
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.
A helper to make it easier to instantiate an ns3::OnOffApplication on a set of nodes.
Definition: on-off-helper.h:37
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:978
#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
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1326
@ WIFI_STANDARD_80211b
ns devices
Definition: first.py:42
Every class exported by the ns3 library is enclosed in the ns3 namespace.
WifiPhyState
The state of the PHY layer.
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
ns cmd
Definition: second.py:40
ns wifi
Definition: third.py:95
ns mobility
Definition: third.py:105
bool verbose
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