A Discrete-Event Network Simulator
API
wifi-power-adaptation-distance.cc
Go to the documentation of this file.
1/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
2/*
3 * Copyright (c) 2014 Universidad de la Rep├║blica - Uruguay
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: Matias Richart <mrichart@fing.edu.uy>
19 */
20
88#include "ns3/gnuplot.h"
89#include "ns3/command-line.h"
90#include "ns3/config.h"
91#include "ns3/uinteger.h"
92#include "ns3/double.h"
93#include "ns3/log.h"
94#include "ns3/yans-wifi-helper.h"
95#include "ns3/ssid.h"
96#include "ns3/mobility-helper.h"
97#include "ns3/internet-stack-helper.h"
98#include "ns3/ipv4-address-helper.h"
99#include "ns3/packet-sink-helper.h"
100#include "ns3/on-off-helper.h"
101#include "ns3/yans-wifi-channel.h"
102#include "ns3/wifi-net-device.h"
103#include "ns3/wifi-mac.h"
104#include "ns3/wifi-mac-header.h"
105#include "ns3/mobility-model.h"
106
107using namespace ns3;
108using namespace std;
109
110NS_LOG_COMPONENT_DEFINE ("PowerAdaptationDistance");
111
112//packet size generated at the AP
113static const uint32_t packetSize = 1420;
114
116{
117public:
119
120 void PhyCallback (std::string path, Ptr<const Packet> packet, double powerW);
121 void RxCallback (std::string path, Ptr<const Packet> packet, const Address &from);
122 void PowerCallback (std::string path, double oldPower, double newPower, Mac48Address dest);
123 void RateCallback (std::string path, DataRate oldRate, DataRate newRate, Mac48Address dest);
124 void SetPosition (Ptr<Node> node, Vector position);
125 void AdvancePosition (Ptr<Node> node, int stepsSize, int stepsTime);
126 Vector GetPosition (Ptr<Node> node);
127
130
131
132private:
133 typedef std::vector<std::pair<Time, DataRate> > TxTime;
136
137 std::map<Mac48Address, double> currentPower;
138 std::map<Mac48Address, DataRate> currentRate;
141 double totalTime;
146};
147
149{
150 Ptr<NetDevice> device = aps.Get (0);
151 Ptr<WifiNetDevice> wifiDevice = DynamicCast<WifiNetDevice> (device);
152 Ptr<WifiPhy> phy = wifiDevice->GetPhy ();
153 myPhy = phy;
154 SetupPhy (phy);
155 DataRate dataRate = DataRate (phy->GetDefaultMode ().GetDataRate (phy->GetChannelWidth ()));
156 double power = phy->GetTxPowerEnd ();
157 for (uint32_t j = 0; j < stas.GetN (); j++)
158 {
159 Ptr<NetDevice> staDevice = stas.Get (j);
160 Ptr<WifiNetDevice> wifiStaDevice = DynamicCast<WifiNetDevice> (staDevice);
161 Mac48Address addr = wifiStaDevice->GetMac ()->GetAddress ();
162 currentPower[addr] = power;
163 currentRate[addr] = dataRate;
164 }
165 currentRate[Mac48Address ("ff:ff:ff:ff:ff:ff")] = dataRate;
166 totalEnergy = 0;
167 totalTime = 0;
168 m_bytesTotal = 0;
169 m_output.SetTitle ("Throughput Mbits/s");
170 m_output_power.SetTitle ("Average Transmit Power");
171}
172
173void
175{
176 for (const auto & mode : phy->GetModeList ())
177 {
178 WifiTxVector txVector;
179 txVector.SetMode (mode);
181 txVector.SetChannelWidth (phy->GetChannelWidth ());
182 DataRate dataRate = DataRate (mode.GetDataRate (phy->GetChannelWidth ()));
183 Time time = phy->CalculateTxDuration (packetSize, txVector, phy->GetPhyBand ());
184 NS_LOG_DEBUG (mode.GetUniqueName () << " " << time.GetSeconds () << " " << dataRate);
185 timeTable.push_back (std::make_pair (time, dataRate));
186 }
187}
188
189Time
191{
192 for (TxTime::const_iterator i = timeTable.begin (); i != timeTable.end (); i++)
193 {
194 if (rate == i->second)
195 {
196 return i->first;
197 }
198 }
199 NS_ASSERT (false);
200 return Seconds (0);
201}
202
203void
204NodeStatistics::PhyCallback (std::string path, Ptr<const Packet> packet, double powerW)
205{
206 WifiMacHeader head;
207 packet->PeekHeader (head);
208 Mac48Address dest = head.GetAddr1 ();
209
210 if (head.GetType () == WIFI_MAC_DATA)
211 {
212 totalEnergy += pow (10.0, currentPower[dest] / 10.0) * GetCalcTxTime (currentRate[dest]).GetSeconds ();
214 }
215}
216
217void
218NodeStatistics::PowerCallback (std::string path, double oldPower, double newPower, Mac48Address dest)
219{
220 currentPower[dest] = newPower;
221}
222
223void
224NodeStatistics::RateCallback (std::string path, DataRate oldRate, DataRate newRate, Mac48Address dest)
225{
226 currentRate[dest] = newRate;
227}
228
229void
230NodeStatistics::RxCallback (std::string path, Ptr<const Packet> packet, const Address &from)
231{
232 m_bytesTotal += packet->GetSize ();
233}
234
235void
237{
239 mobility->SetPosition (position);
240}
241
242Vector
244{
246 return mobility->GetPosition ();
247}
248
249void
250NodeStatistics::AdvancePosition (Ptr<Node> node, int stepsSize, int stepsTime)
251{
252 Vector pos = GetPosition (node);
253 double mbs = ((m_bytesTotal * 8.0) / (1000000 * stepsTime));
254 m_bytesTotal = 0;
255 double atp = totalEnergy / stepsTime;
256 totalEnergy = 0;
257 totalTime = 0;
258 m_output_power.Add (pos.x, atp);
259 m_output.Add (pos.x, mbs);
260 pos.x += stepsSize;
261 SetPosition (node, pos);
262 NS_LOG_INFO ("At time " << Simulator::Now ().GetSeconds () << " sec; setting new position to " << pos);
263 Simulator::Schedule (Seconds (stepsTime), &NodeStatistics::AdvancePosition, this, node, stepsSize, stepsTime);
264}
265
268{
269 return m_output;
270}
271
274{
275 return m_output_power;
276}
277
278void PowerCallback (std::string path, double oldPower, double newPower, Mac48Address dest)
279{
280 NS_LOG_INFO ((Simulator::Now ()).GetSeconds () << " " << dest << " Old power=" << oldPower << " New power=" << newPower);
281}
282
283void RateCallback (std::string path, DataRate oldRate, DataRate newRate, Mac48Address dest)
284{
285 NS_LOG_INFO ((Simulator::Now ()).GetSeconds () << " " << dest << " Old rate=" << oldRate << " New rate=" << newRate);
286}
287
288int main (int argc, char *argv[])
289{
290 double maxPower = 17;
291 double minPower = 0;
292 uint32_t powerLevels = 18;
293
294 uint32_t rtsThreshold = 2346;
295 std::string manager = "ns3::ParfWifiManager";
296 std::string outputFileName = "parf";
297 int ap1_x = 0;
298 int ap1_y = 0;
299 int sta1_x = 5;
300 int sta1_y = 0;
301 uint32_t steps = 200;
302 uint32_t stepsSize = 1;
303 uint32_t stepsTime = 1;
304
305 CommandLine cmd (__FILE__);
306 cmd.AddValue ("manager", "PRC Manager", manager);
307 cmd.AddValue ("rtsThreshold", "RTS threshold", rtsThreshold);
308 cmd.AddValue ("outputFileName", "Output filename", outputFileName);
309 cmd.AddValue ("steps", "How many different distances to try", steps);
310 cmd.AddValue ("stepsTime", "Time on each step", stepsTime);
311 cmd.AddValue ("stepsSize", "Distance between steps", stepsSize);
312 cmd.AddValue ("maxPower", "Maximum available transmission level (dbm).", maxPower);
313 cmd.AddValue ("minPower", "Minimum available transmission level (dbm).", minPower);
314 cmd.AddValue ("powerLevels", "Number of transmission power levels available between "
315 "TxPowerStart and TxPowerEnd included.", powerLevels);
316 cmd.AddValue ("AP1_x", "Position of AP1 in x coordinate", ap1_x);
317 cmd.AddValue ("AP1_y", "Position of AP1 in y coordinate", ap1_y);
318 cmd.AddValue ("STA1_x", "Position of STA1 in x coordinate", sta1_x);
319 cmd.AddValue ("STA1_y", "Position of STA1 in y coordinate", sta1_y);
320 cmd.Parse (argc, argv);
321
322 if (steps == 0)
323 {
324 std::cout << "Exiting without running simulation; steps value of 0" << std::endl;
325 }
326
327 uint32_t simuTime = (steps + 1) * stepsTime;
328
329 //Define the APs
330 NodeContainer wifiApNodes;
331 wifiApNodes.Create (1);
332
333 //Define the STAs
335 wifiStaNodes.Create (1);
336
338 wifi.SetStandard (WIFI_STANDARD_80211a);
339 WifiMacHelper wifiMac;
340 YansWifiPhyHelper wifiPhy;
341 YansWifiChannelHelper wifiChannel = YansWifiChannelHelper::Default ();
342
343 wifiPhy.SetChannel (wifiChannel.Create ());
344
345 NetDeviceContainer wifiApDevices;
346 NetDeviceContainer wifiStaDevices;
347 NetDeviceContainer wifiDevices;
348
349 //Configure the STA node
350 wifi.SetRemoteStationManager ("ns3::MinstrelWifiManager", "RtsCtsThreshold", UintegerValue (rtsThreshold));
351 wifiPhy.Set ("TxPowerStart", DoubleValue (maxPower));
352 wifiPhy.Set ("TxPowerEnd", DoubleValue (maxPower));
353
354 Ssid ssid = Ssid ("AP");
355 wifiMac.SetType ("ns3::StaWifiMac",
356 "Ssid", SsidValue (ssid));
357 wifiStaDevices.Add (wifi.Install (wifiPhy, wifiMac, wifiStaNodes.Get (0)));
358
359 //Configure the AP node
360 wifi.SetRemoteStationManager (manager, "DefaultTxPowerLevel", UintegerValue (powerLevels - 1), "RtsCtsThreshold", UintegerValue (rtsThreshold));
361 wifiPhy.Set ("TxPowerStart", DoubleValue (minPower));
362 wifiPhy.Set ("TxPowerEnd", DoubleValue (maxPower));
363 wifiPhy.Set ("TxPowerLevels", UintegerValue (powerLevels));
364
365 ssid = Ssid ("AP");
366 wifiMac.SetType ("ns3::ApWifiMac",
367 "Ssid", SsidValue (ssid));
368 wifiApDevices.Add (wifi.Install (wifiPhy, wifiMac, wifiApNodes.Get (0)));
369
370 wifiDevices.Add (wifiStaDevices);
371 wifiDevices.Add (wifiApDevices);
372
373 //Configure the mobility.
375 Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator> ();
376 //Initial position of AP and STA
377 positionAlloc->Add (Vector (ap1_x, ap1_y, 0.0));
378 NS_LOG_INFO ("Setting initial AP position to " << Vector (ap1_x, ap1_y, 0.0));
379 positionAlloc->Add (Vector (sta1_x, sta1_y, 0.0));
380 NS_LOG_INFO ("Setting initial STA position to " << Vector (sta1_x, sta1_y, 0.0));
381 mobility.SetPositionAllocator (positionAlloc);
382 mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
383 mobility.Install (wifiApNodes.Get (0));
384 mobility.Install (wifiStaNodes.Get (0));
385
386 //Statistics counter
387 NodeStatistics statistics = NodeStatistics (wifiApDevices, wifiStaDevices);
388
389 //Move the STA by stepsSize meters every stepsTime seconds
390 Simulator::Schedule (Seconds (0.5 + stepsTime), &NodeStatistics::AdvancePosition, &statistics, wifiStaNodes.Get (0), stepsSize, stepsTime);
391
392 //Configure the IP stack
394 stack.Install (wifiApNodes);
395 stack.Install (wifiStaNodes);
397 address.SetBase ("10.1.1.0", "255.255.255.0");
398 Ipv4InterfaceContainer i = address.Assign (wifiDevices);
399 Ipv4Address sinkAddress = i.GetAddress (0);
400 uint16_t port = 9;
401
402 //Configure the CBR generator
403 PacketSinkHelper sink ("ns3::UdpSocketFactory", InetSocketAddress (sinkAddress, port));
404 ApplicationContainer apps_sink = sink.Install (wifiStaNodes.Get (0));
405
406 OnOffHelper onoff ("ns3::UdpSocketFactory", InetSocketAddress (sinkAddress, port));
407 onoff.SetConstantRate (DataRate ("54Mb/s"), packetSize);
408 onoff.SetAttribute ("StartTime", TimeValue (Seconds (0.5)));
409 onoff.SetAttribute ("StopTime", TimeValue (Seconds (simuTime)));
410 ApplicationContainer apps_source = onoff.Install (wifiApNodes.Get (0));
411
412 apps_sink.Start (Seconds (0.5));
413 apps_sink.Stop (Seconds (simuTime));
414
415 //------------------------------------------------------------
416 //-- Setup stats and data collection
417 //--------------------------------------------
418
419 //Register packet receptions to calculate throughput
420 Config::Connect ("/NodeList/1/ApplicationList/*/$ns3::PacketSink/Rx",
422
423 //Register power and rate changes to calculate the Average Transmit Power
424 Config::Connect ("/NodeList/0/DeviceList/*/$ns3::WifiNetDevice/RemoteStationManager/$" + manager + "/PowerChange",
426 Config::Connect ("/NodeList/0/DeviceList/*/$ns3::WifiNetDevice/RemoteStationManager/$" + manager + "/RateChange",
428
429 Config::Connect ("/NodeList/0/DeviceList/*/$ns3::WifiNetDevice/Phy/PhyTxBegin",
431
432 //Callbacks to print every change of power and rate
433 Config::Connect ("/NodeList/0/DeviceList/*/$ns3::WifiNetDevice/RemoteStationManager/$" + manager + "/PowerChange",
435 Config::Connect ("/NodeList/0/DeviceList/*/$ns3::WifiNetDevice/RemoteStationManager/$" + manager + "/RateChange",
437
438 Simulator::Stop (Seconds (simuTime));
439 Simulator::Run ();
440
441 std::ofstream outfile (("throughput-" + outputFileName + ".plt").c_str ());
442 Gnuplot gnuplot = Gnuplot (("throughput-" + outputFileName + ".eps").c_str (), "Throughput");
443 gnuplot.SetTerminal ("post eps color enhanced");
444 gnuplot.SetLegend ("Time (seconds)", "Throughput (Mb/s)");
445 gnuplot.SetTitle ("Throughput (AP to STA) vs time");
446 gnuplot.AddDataset (statistics.GetDatafile ());
447 gnuplot.GenerateOutput (outfile);
448
449 if (manager.compare ("ns3::ParfWifiManager") == 0
450 || manager.compare ("ns3::AparfWifiManager") == 0
451 || manager.compare ("ns3::RrpaaWifiManager") == 0)
452 {
453 std::ofstream outfile2 (("power-" + outputFileName + ".plt").c_str ());
454 gnuplot = Gnuplot (("power-" + outputFileName + ".eps").c_str (), "Average Transmit Power");
455 gnuplot.SetTerminal ("post eps color enhanced");
456 gnuplot.SetLegend ("Time (seconds)", "Power (mW)");
457 gnuplot.SetTitle ("Average transmit power (AP to STA) vs time");
458 gnuplot.AddDataset (statistics.GetPowerDatafile ());
459 gnuplot.GenerateOutput (outfile2);
460 }
461
462 Simulator::Destroy ();
463
464 return 0;
465}
void SetPosition(Ptr< Node > node, Vector position)
std::map< Mac48Address, DataRate > currentRate
Gnuplot2dDataset GetPowerDatafile()
void RateCallback(std::string path, DataRate oldRate, DataRate newRate, Mac48Address dest)
void RxCallback(std::string path, Ptr< const Packet > packet, const Address &from)
NodeStatistics(NetDeviceContainer aps, NetDeviceContainer stas)
std::map< Mac48Address, double > currentPower
Time GetCalcTxTime(DataRate rate)
void PowerCallback(std::string path, double oldPower, double newPower, Mac48Address dest)
uint32_t m_bytesTotal
total bytes
void SetupPhy(Ptr< WifiPhy > phy)
std::vector< std::pair< Time, DataRate > > TxTime
Vector GetPosition(Ptr< Node > node)
Gnuplot2dDataset m_output
gnuplot 2d dataset
void AdvancePosition(Ptr< Node > node, int stepsSize, int stepsTime)
void PhyCallback(std::string path, Ptr< const Packet > packet, double powerW)
a polymophic address class
Definition: address.h:91
holds a vector of ns3::Application pointers.
void Start(Time start)
Arrange for all of the Applications in this container to Start() at the Time given as a parameter.
void Stop(Time stop)
Arrange for all of the Applications in this container to Stop() at the Time given as a parameter.
Parse command-line arguments.
Definition: command-line.h:229
Class for representing data rates.
Definition: data-rate.h:89
This class can be used to hold variables of floating point type such as 'double' or 'float'.
Definition: double.h:41
Class to represent a 2D points plot.
Definition: gnuplot.h:118
void Add(double x, double y)
Definition: gnuplot.cc:361
void SetTitle(const std::string &title)
Change line title.
Definition: gnuplot.cc:141
a simple class to generate gnuplot-ready plotting commands from a set of datasets.
Definition: gnuplot.h:372
void AddDataset(const GnuplotDataset &dataset)
Definition: gnuplot.cc:758
void SetLegend(const std::string &xLegend, const std::string &yLegend)
Definition: gnuplot.cc:738
void SetTerminal(const std::string &terminal)
Definition: gnuplot.cc:726
void GenerateOutput(std::ostream &os)
Writes gnuplot commands and data values to a single output stream.
Definition: gnuplot.cc:764
void SetTitle(const std::string &title)
Definition: gnuplot.cc:732
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:41
holds a vector of std::pair of Ptr<Ipv4> and interface index.
Ipv4Address GetAddress(uint32_t i, uint32_t j=0) const
an EUI-48 address
Definition: mac48-address.h:44
Helper class used to assign positions and mobility models to nodes.
Keep track of the current position and velocity of an object.
holds a vector of ns3::NetDevice pointers
uint32_t GetN(void) const
Get the number of Ptr<NetDevice> stored in this container.
void Add(NetDeviceContainer other)
Append the contents of another NetDeviceContainer to the end of this container.
Ptr< NetDevice > Get(uint32_t i) const
Get the Ptr<NetDevice> stored in this container at a given index.
keep track of a set of node pointers.
void Create(uint32_t n)
Create n nodes and append pointers to them to the end of this NodeContainer.
Ptr< Node > Get(uint32_t i) const
Get the Ptr<Node> stored in this container at a given index.
Ptr< T > GetObject(void) const
Get a pointer to the requested aggregated Object.
Definition: object.h:470
A helper to make it easier to instantiate an ns3::OnOffApplication on a set of nodes.
Definition: on-off-helper.h:43
uint32_t PeekHeader(Header &header) const
Deserialize but does not remove the header from the internal buffer.
Definition: packet.cc:290
uint32_t GetSize(void) const
Returns the the size in bytes of the packet (including the zero-filled initial payload).
Definition: packet.h:852
A helper to make it easier to instantiate an ns3::PacketSinkApplication on a set of nodes.
The IEEE 802.11 SSID Information Element.
Definition: ssid.h:36
AttributeValue implementation for Ssid.
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:103
double GetSeconds(void) const
Get an approximation of the time stored in this instance in the indicated unit.
Definition: nstime.h:379
AttributeValue implementation for Time.
Definition: nstime.h:1308
Hold an unsigned integer type.
Definition: uinteger.h:44
Vector3D Vector
Vector alias typedef for compatibility with mobility models.
Definition: vector.h:324
helps to create WifiNetDevice objects
Definition: wifi-helper.h:323
Implements the IEEE 802.11 MAC header.
Mac48Address GetAddr1(void) const
Return the address in the Address 1 field.
WifiMacType GetType(void) const
Return the type (enum WifiMacType)
create MAC layers for a ns3::WifiNetDevice.
void SetType(std::string type, Args &&... args)
Ptr< WifiMac > GetMac(void) const
Ptr< WifiPhy > GetPhy(void) const
void Set(std::string name, const AttributeValue &v)
Definition: wifi-helper.cc:141
This class mimics the TXVECTOR which is to be passed to the PHY in order to define the parameters whi...
void SetChannelWidth(uint16_t channelWidth)
Sets the selected channelWidth (in MHz)
void SetMode(WifiMode mode)
Sets the selected payload transmission mode.
void SetPreambleType(WifiPreamble preamble)
Sets the preamble type.
manage and create wifi channel objects for the YANS model.
Ptr< YansWifiChannel > Create(void) const
Make it easy to create and manage PHY objects for the YANS model.
void SetChannel(Ptr< YansWifiChannel > channel)
uint16_t port
Definition: dsdv-manet.cc:45
#define NS_ASSERT(condition)
At runtime, in debugging builds, if this condition is not true, the program prints the source file,...
Definition: assert.h:67
void Connect(std::string path, const CallbackBase &cb)
Definition: config.cc:920
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:205
#define NS_LOG_DEBUG(msg)
Use NS_LOG to output a message of level LOG_DEBUG.
Definition: log.h:273
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Definition: log.h:281
void(* DataRate)(DataRate oldValue, DataRate newValue)
TracedValue callback signature for DataRate.
Definition: data-rate.h:329
Time Now(void)
create an ns3::Time instance which contains the current simulation time.
Definition: simulator.cc:287
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1244
@ WIFI_STANDARD_80211a
@ WIFI_PREAMBLE_LONG
address
Definition: first.py:44
stack
Definition: first.py:41
Every class exported by the ns3 library is enclosed in the ns3 namespace.
@ WIFI_MAC_DATA
Callback< R, Ts... > MakeCallback(R(T::*memPtr)(Ts...), OBJ objPtr)
Build Callbacks for class method members which take varying numbers of arguments and potentially retu...
Definition: callback.h:1648
cmd
Definition: second.py:35
STL namespace.
ssid
Definition: third.py:100
wifi
Definition: third.py:96
mobility
Definition: third.py:108
wifiStaNodes
Definition: third.py:88
phy
Definition: third.py:93
void RateCallback(std::string path, DataRate oldRate, DataRate newRate, Mac48Address dest)
static const uint32_t packetSize
void PowerCallback(std::string path, double oldPower, double newPower, Mac48Address dest)
Ptr< PacketSink > sink
Definition: wifi-tcp.cc:56