A Discrete-Event Network Simulator
API
energy-model-with-harvesting-example.cc
Go to the documentation of this file.
1/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
2/*
3 * Copyright (c) 2014 Wireless Communications and Networking Group (WCNG),
4 * University of Rochester, Rochester, NY, USA.
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation;
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 *
19 * Author: Cristiano Tapparello <cristiano.tapparello@rochester.edu>
20 */
21
50#include <iostream>
51#include <fstream>
52#include <vector>
53#include <string>
54#include "ns3/core-module.h"
55#include "ns3/network-module.h"
56#include "ns3/mobility-module.h"
57#include "ns3/config-store-module.h"
58#include "ns3/energy-module.h"
59#include "ns3/internet-module.h"
60#include "ns3/yans-wifi-helper.h"
61#include "ns3/wifi-radio-energy-model-helper.h"
62
63using namespace ns3;
64
65NS_LOG_COMPONENT_DEFINE ("EnergyWithHarvestingExample");
66
67static inline std::string
69{
70 InetSocketAddress iaddr = InetSocketAddress::ConvertFrom (from);
71
72 std::ostringstream oss;
73 oss << "--\nReceived one packet! Socket: " << iaddr.GetIpv4 ()
74 << " port: " << iaddr.GetPort ()
75 << " at time = " << Simulator::Now ().GetSeconds ()
76 << "\n--";
77
78 return oss.str ();
79}
80
86void
88{
89 Ptr<Packet> packet;
90 Address from;
91 while ((packet = socket->RecvFrom (from)))
92 {
93 if (packet->GetSize () > 0)
94 {
96 }
97 }
98}
99
109static void
111 uint32_t pktCount, Time pktInterval)
112{
113 if (pktCount > 0)
114 {
115 socket->Send (Create<Packet> (pktSize));
116 Simulator::Schedule (pktInterval, &GenerateTraffic, socket, pktSize, n,
117 pktCount - 1, pktInterval);
118 }
119 else
120 {
121 socket->Close ();
122 }
123}
124
126void
127RemainingEnergy (double oldValue, double remainingEnergy)
128{
129 NS_LOG_UNCOND (Simulator::Now ().GetSeconds ()
130 << "s Current remaining energy = " << remainingEnergy << "J");
131}
132
134void
135TotalEnergy (double oldValue, double totalEnergy)
136{
137 NS_LOG_UNCOND (Simulator::Now ().GetSeconds ()
138 << "s Total energy consumed by radio = " << totalEnergy << "J");
139}
140
142void
143HarvestedPower (double oldValue, double harvestedPower)
144{
145 NS_LOG_UNCOND (Simulator::Now ().GetSeconds ()
146 << "s Current harvested power = " << harvestedPower << " W");
147}
148
150void
152{
153 NS_LOG_UNCOND (Simulator::Now ().GetSeconds ()
154 << "s Total energy harvested by harvester = "
155 << TotalEnergyHarvested << " J");
156}
157
158
159int
160main (int argc, char *argv[])
161{
162 std::string phyMode ("DsssRate1Mbps");
163 double Prss = -80; // dBm
164 uint32_t PacketSize = 200; // bytes
165 bool verbose = false;
166
167 // simulation parameters
168 uint32_t numPackets = 10000; // number of packets to send
169 double interval = 1; // seconds
170 double startTime = 0.0; // seconds
171 double distanceToRx = 100.0; // meters
172
173 // Energy Harvester variables
174 double harvestingUpdateInterval = 1; // seconds
175
176 CommandLine cmd (__FILE__);
177 cmd.AddValue ("phyMode", "Wifi Phy mode", phyMode);
178 cmd.AddValue ("Prss", "Intended primary RSS (dBm)", Prss);
179 cmd.AddValue ("PacketSize", "size of application packet sent", PacketSize);
180 cmd.AddValue ("numPackets", "Total number of packets to send", numPackets);
181 cmd.AddValue ("startTime", "Simulation start time", startTime);
182 cmd.AddValue ("distanceToRx", "X-Axis distance between nodes", distanceToRx);
183 cmd.AddValue ("verbose", "Turn on all device log components", verbose);
184 cmd.Parse (argc, argv);
185
186 // Convert to time object
187 Time interPacketInterval = Seconds (interval);
188
189 // disable fragmentation for frames below 2200 bytes
190 Config::SetDefault ("ns3::WifiRemoteStationManager::FragmentationThreshold",
191 StringValue ("2200"));
192 // turn off RTS/CTS for frames below 2200 bytes
193 Config::SetDefault ("ns3::WifiRemoteStationManager::RtsCtsThreshold",
194 StringValue ("2200"));
195 // Fix non-unicast data rate to be the same as that of unicast
196 Config::SetDefault ("ns3::WifiRemoteStationManager::NonUnicastMode",
197 StringValue (phyMode));
198
200 c.Create (2); // create 2 nodes
201 NodeContainer networkNodes;
202 networkNodes.Add (c.Get (0));
203 networkNodes.Add (c.Get (1));
204
205 // The below set of helpers will help us to put together the wifi NICs we want
207 if (verbose)
208 {
209 wifi.EnableLogComponents ();
210 }
211 wifi.SetStandard (WIFI_STANDARD_80211b);
212
214 /***************************************************************************/
215 YansWifiPhyHelper wifiPhy;
216
218 YansWifiChannelHelper wifiChannel;
219 wifiChannel.SetPropagationDelay ("ns3::ConstantSpeedPropagationDelayModel");
220 wifiChannel.AddPropagationLoss ("ns3::FriisPropagationLossModel");
221
222 // create wifi channel
223 Ptr<YansWifiChannel> wifiChannelPtr = wifiChannel.Create ();
224 wifiPhy.SetChannel (wifiChannelPtr);
225
227 // Add a MAC and disable rate control
228 WifiMacHelper wifiMac;
229 wifi.SetRemoteStationManager ("ns3::ConstantRateWifiManager", "DataMode",
230 StringValue (phyMode), "ControlMode",
231 StringValue (phyMode));
232 // Set it to ad-hoc mode
233 wifiMac.SetType ("ns3::AdhocWifiMac");
234
236 NetDeviceContainer devices = wifi.Install (wifiPhy, wifiMac, networkNodes);
237
240 Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator> ();
241 positionAlloc->Add (Vector (0.0, 0.0, 0.0));
242 positionAlloc->Add (Vector (2 * distanceToRx, 0.0, 0.0));
243 mobility.SetPositionAllocator (positionAlloc);
244 mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
245 mobility.Install (c);
246
248 /***************************************************************************/
249 /* energy source */
250 BasicEnergySourceHelper basicSourceHelper;
251 // configure energy source
252 basicSourceHelper.Set ("BasicEnergySourceInitialEnergyJ", DoubleValue (1.0));
253 // install source
254 EnergySourceContainer sources = basicSourceHelper.Install (c);
255 /* device energy model */
256 WifiRadioEnergyModelHelper radioEnergyHelper;
257 // configure radio energy model
258 radioEnergyHelper.Set ("TxCurrentA", DoubleValue (0.0174));
259 radioEnergyHelper.Set ("RxCurrentA", DoubleValue (0.0197));
260 // install device model
261 DeviceEnergyModelContainer deviceModels = radioEnergyHelper.Install (devices, sources);
262
263 /* energy harvester */
264 BasicEnergyHarvesterHelper basicHarvesterHelper;
265 // configure energy harvester
266 basicHarvesterHelper.Set ("PeriodicHarvestedPowerUpdateInterval", TimeValue (Seconds (harvestingUpdateInterval)));
267 basicHarvesterHelper.Set ("HarvestablePower", StringValue ("ns3::UniformRandomVariable[Min=0.0|Max=0.1]"));
268 // install harvester on all energy sources
269 EnergyHarvesterContainer harvesters = basicHarvesterHelper.Install (sources);
270 /***************************************************************************/
271
273 InternetStackHelper internet;
274 internet.Install (networkNodes);
275
277 NS_LOG_INFO ("Assign IP Addresses.");
278 ipv4.SetBase ("10.1.1.0", "255.255.255.0");
280
281 TypeId tid = TypeId::LookupByName ("ns3::UdpSocketFactory");
282 Ptr<Socket> recvSink = Socket::CreateSocket (networkNodes.Get (1), tid); // node 1, Destination
283 InetSocketAddress local = InetSocketAddress (Ipv4Address::GetAny (), 80);
284 recvSink->Bind (local);
286
287 Ptr<Socket> source = Socket::CreateSocket (networkNodes.Get (0), tid); // node 0, Source
288 InetSocketAddress remote = InetSocketAddress (Ipv4Address::GetBroadcast (), 80);
289 source->SetAllowBroadcast (true);
290 source->Connect (remote);
291
293 /***************************************************************************/
294 // all traces are connected to node 1 (Destination)
295 // energy source
296 Ptr<BasicEnergySource> basicSourcePtr = DynamicCast<BasicEnergySource> (sources.Get (1));
297 basicSourcePtr->TraceConnectWithoutContext ("RemainingEnergy", MakeCallback (&RemainingEnergy));
298 // device energy model
299 Ptr<DeviceEnergyModel> basicRadioModelPtr =
300 basicSourcePtr->FindDeviceEnergyModels ("ns3::WifiRadioEnergyModel").Get (0);
301 NS_ASSERT (basicRadioModelPtr != 0);
302 basicRadioModelPtr->TraceConnectWithoutContext ("TotalEnergyConsumption", MakeCallback (&TotalEnergy));
303 // energy harvester
304 Ptr<BasicEnergyHarvester> basicHarvesterPtr = DynamicCast<BasicEnergyHarvester> (harvesters.Get (1));
305 basicHarvesterPtr->TraceConnectWithoutContext ("HarvestedPower", MakeCallback (&HarvestedPower));
306 basicHarvesterPtr->TraceConnectWithoutContext ("TotalEnergyHarvested", MakeCallback (&TotalEnergyHarvested));
307 /***************************************************************************/
308
309
311 // start traffic
312 Simulator::Schedule (Seconds (startTime), &GenerateTraffic, source, PacketSize,
313 networkNodes.Get (0), numPackets, interPacketInterval);
314
315 Simulator::Stop (Seconds (10.0));
316 Simulator::Run ();
317
318 for (DeviceEnergyModelContainer::Iterator iter = deviceModels.Begin (); iter != deviceModels.End (); iter ++)
319 {
320 double energyConsumed = (*iter)->GetTotalEnergyConsumption ();
321 NS_LOG_UNCOND ("End of simulation (" << Simulator::Now ().GetSeconds ()
322 << "s) Total energy consumed by radio = " << energyConsumed << "J");
323 NS_ASSERT (energyConsumed <= 1.0);
324 }
325
326 Simulator::Destroy ();
327
328 return 0;
329}
a polymophic address class
Definition: address.h:91
Creates a BasicEnergyHarvester object.
void Set(std::string name, const AttributeValue &v)
Creates a BasicEnergySource object.
void Set(std::string name, const AttributeValue &v)
Parse command-line arguments.
Definition: command-line.h:229
Holds a vector of ns3::DeviceEnergyModel pointers.
std::vector< Ptr< DeviceEnergyModel > >::const_iterator Iterator
Const iterator of DeviceEnergyModel container.
Iterator End(void) const
Get an iterator which refers to the last DeviceEnergyModel pointer in the container.
Iterator Begin(void) const
Get an iterator which refers to the first DeviceEnergyModel pointer in the container.
Ptr< DeviceEnergyModel > Get(uint32_t i) const
Get the i-th Ptr<DeviceEnergyModel> stored in this container.
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:41
Holds a vector of ns3::EnergyHarvester pointers.
Ptr< EnergyHarvester > Get(uint32_t i) const
Get the i-th Ptr<EnergyHarvester> stored in this container.
EnergyHarvesterContainer Install(Ptr< EnergySource > source) const
Holds a vector of ns3::EnergySource pointers.
Ptr< EnergySource > Get(uint32_t i) const
Get the i-th Ptr<EnergySource> stored in this container.
EnergySourceContainer Install(Ptr< Node > node) const
DeviceEnergyModelContainer FindDeviceEnergyModels(TypeId tid)
an Inet address class
uint16_t GetPort(void) const
Ipv4Address GetIpv4(void) const
aggregate IP/TCP/UDP functionality to existing Nodes.
void Install(std::string nodeName) const
Aggregate implementations of the ns3::Ipv4, ns3::Ipv6, ns3::Udp, and ns3::Tcp classes onto the provid...
A helper class to make life easier while doing simple IPv4 address assignment in scripts.
void SetBase(Ipv4Address network, Ipv4Mask mask, Ipv4Address base="0.0.0.1")
Set the base network number, network mask and base address.
Ipv4InterfaceContainer Assign(const NetDeviceContainer &c)
Assign IP addresses to the net devices specified in the container based on the current network prefix...
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.
void Create(uint32_t n)
Create n nodes and append pointers to them to the end of this NodeContainer.
void Add(NodeContainer other)
Append the contents of another NodeContainer to the end of this container.
Ptr< Node > Get(uint32_t i) const
Get the Ptr<Node> stored in this container at a given index.
bool TraceConnectWithoutContext(std::string name, const CallbackBase &cb)
Connect a TraceSource to a Callback without a context.
Definition: object-base.cc:364
uint32_t GetSize(void) const
Returns the the size in bytes of the packet (including the zero-filled initial payload).
Definition: packet.h:856
virtual int Send(Ptr< Packet > p, uint32_t flags)=0
Send data (or dummy data) to the remote host.
virtual Ptr< Packet > RecvFrom(uint32_t maxSize, uint32_t flags, Address &fromAddress)=0
Read a single packet from the socket and retrieve the sender address.
virtual bool SetAllowBroadcast(bool allowBroadcast)=0
Configure whether broadcast datagram transmissions are allowed.
virtual int Connect(const Address &address)=0
Initiate a connection to a remote host.
virtual int Close(void)=0
Close a socket.
void SetRecvCallback(Callback< void, Ptr< Socket > > receivedData)
Notify application when new data is available to be read.
Definition: socket.cc:128
virtual int Bind(const Address &address)=0
Allocate a local endpoint for this socket.
Hold variables of type string.
Definition: string.h:41
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
a unique identifier for an interface.
Definition: type-id.h:59
Vector3D Vector
Vector alias typedef for compatibility with mobility models.
Definition: vector.h:324
helps to create WifiNetDevice objects
Definition: wifi-helper.h:274
create MAC layers for a ns3::WifiNetDevice.
void SetType(std::string type, Args &&... args)
Assign WifiRadioEnergyModel to wifi devices.
void Set(std::string name, const AttributeValue &v) override
manage and create wifi channel objects for the YANS model.
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())
Ptr< YansWifiChannel > Create(void) const
void AddPropagationLoss(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())
Make it easy to create and manage PHY objects for the YANS model.
void SetChannel(Ptr< YansWifiChannel > channel)
void TotalEnergyHarvested(double oldValue, double TotalEnergyHarvested)
Trace function for the total energy harvested by the node.
void HarvestedPower(double oldValue, double harvestedPower)
Trace function for the power harvested by the energy harvester.
void TotalEnergy(double oldValue, double totalEnergy)
Trace function for total energy consumption at node.
void ReceivePacket(Ptr< Socket > socket)
void RemainingEnergy(double oldValue, double remainingEnergy)
Trace function for remaining energy at node.
static void GenerateTraffic(Ptr< Socket > socket, uint32_t pktSize, Ptr< Node > n, uint32_t pktCount, Time pktInterval)
static std::string PrintReceivedPacket(Address &from)
#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 SetDefault(std::string name, const AttributeValue &value)
Definition: config.cc:849
#define NS_LOG_UNCOND(msg)
Output the requested message unconditionally.
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:205
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Definition: log.h:281
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_80211b
devices
Definition: first.py:39
Every class exported by the ns3 library is enclosed in the ns3 namespace.
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
wifi
Definition: third.py:99
mobility
Definition: third.py:107
bool verbose
uint32_t pktSize
packet size used for the simulation (in bytes)
Definition: wifi-bianchi.cc:89