A Discrete-Event Network Simulator
API
wave-helper.cc
Go to the documentation of this file.
1 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * This program is free software; you can redistribute it and/or modify
4  * it under the terms of the GNU General Public License version 2 as
5  * published by the Free Software Foundation;
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software
14  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
15  *
16  * Author: Junling Bu <linlinjavaer@gmail.com>
17  */
18 #include "ns3/wifi-mac.h"
19 #include "ns3/wifi-phy.h"
20 #include "ns3/log.h"
21 #include "ns3/pointer.h"
22 #include "ns3/string.h"
23 #include "ns3/wifi-mode.h"
24 #include "ns3/config.h"
25 #include "ns3/names.h"
26 #include "ns3/abort.h"
27 #include "ns3/ampdu-subframe-header.h"
28 #include "ns3/wave-net-device.h"
29 #include "ns3/minstrel-wifi-manager.h"
30 #include "ns3/radiotap-header.h"
31 #include "ns3/unused.h"
32 #include "wave-mac-helper.h"
33 #include "wave-helper.h"
34 
35 NS_LOG_COMPONENT_DEFINE ("WaveHelper");
36 
37 namespace ns3 {
38 
39 static void
42  std::string context,
44  WifiMode mode,
45  WifiPreamble preamble,
46  uint8_t txLevel)
47 {
48  NS_LOG_FUNCTION (stream << context << p << mode << preamble << txLevel);
49  *stream->GetStream () << "t " << Simulator::Now ().GetSeconds () << " " << context << " " << *p << std::endl;
50 }
51 
52 static void
56  WifiMode mode,
57  WifiPreamble preamble,
58  uint8_t txLevel)
59 {
60  NS_LOG_FUNCTION (stream << p << mode << preamble << txLevel);
61  *stream->GetStream () << "t " << Simulator::Now ().GetSeconds () << " " << *p << std::endl;
62 }
63 
64 static void
67  std::string context,
69  double snr,
70  WifiMode mode,
71  enum WifiPreamble preamble)
72 {
73  NS_LOG_FUNCTION (stream << context << p << snr << mode << preamble);
74  *stream->GetStream () << "r " << Simulator::Now ().GetSeconds () << " " << context << " " << *p << std::endl;
75 }
76 
77 static void
81  double snr,
82  WifiMode mode,
83  enum WifiPreamble preamble)
84 {
85  NS_LOG_FUNCTION (stream << p << snr << mode << preamble);
86  *stream->GetStream () << "r " << Simulator::Now ().GetSeconds () << " " << *p << std::endl;
87 }
88 
89 
90 /****************************** YansWavePhyHelper ***********************************/
91 YansWavePhyHelper
93 {
94  YansWavePhyHelper helper;
95  helper.SetErrorRateModel ("ns3::NistErrorRateModel");
96  return helper;
97 }
98 
99 void
100 YansWavePhyHelper::EnablePcapInternal (std::string prefix, Ptr<NetDevice> nd, bool promiscuous, bool explicitFilename)
101 {
102  //
103  // All of the Pcap enable functions vector through here including the ones
104  // that are wandering through all of devices on perhaps all of the nodes in
105  // the system. We can only deal with devices of type WaveNetDevice.
106  //
107  Ptr<WaveNetDevice> device = nd->GetObject<WaveNetDevice> ();
108  if (device == 0)
109  {
110  NS_LOG_INFO ("YansWavePhyHelper::EnablePcapInternal(): Device " << &device << " not of type ns3::WaveNetDevice");
111  return;
112  }
113 
114  std::vector<Ptr<WifiPhy> > phys = device->GetPhys ();
115  NS_ABORT_MSG_IF (phys.size () == 0, "EnablePcapInternal(): Phy layer in WaveNetDevice must be set");
116 
117  PcapHelper pcapHelper;
118 
119  std::string filename;
120  if (explicitFilename)
121  {
122  filename = prefix;
123  }
124  else
125  {
126  filename = pcapHelper.GetFilenameFromDevice (prefix, device);
127  }
128 
129  Ptr<PcapFileWrapper> file = pcapHelper.CreateFile (filename, std::ios::out, GetPcapDataLinkType ());
130 
131  std::vector<Ptr<WifiPhy> >::iterator i;
132  for (i = phys.begin (); i != phys.end (); ++i)
133  {
134  Ptr<WifiPhy> phy = (*i);
137  }
138 }
139 
140 void
143  std::string prefix,
144  Ptr<NetDevice> nd,
145  bool explicitFilename)
146 {
147  //
148  // All of the ascii enable functions vector through here including the ones
149  // that are wandering through all of devices on perhaps all of the nodes in
150  // the system. We can only deal with devices of type WaveNetDevice.
151  //
152  Ptr<WaveNetDevice> device = nd->GetObject<WaveNetDevice> ();
153  if (device == 0)
154  {
155  NS_LOG_INFO ("EnableAsciiInternal(): Device " << device << " not of type ns3::WaveNetDevice");
156  return;
157  }
158 
159  //
160  // Our trace sinks are going to use packet printing, so we have to make sure
161  // that is turned on.
162  //
164 
165  uint32_t nodeid = nd->GetNode ()->GetId ();
166  uint32_t deviceid = nd->GetIfIndex ();
167  std::ostringstream oss;
168 
169  //
170  // If we are not provided an OutputStreamWrapper, we are expected to create
171  // one using the usual trace filename conventions and write our traces
172  // without a context since there will be one file per context and therefore
173  // the context would be redundant.
174  //
175  if (stream == 0)
176  {
177  //
178  // Set up an output stream object to deal with private ofstream copy
179  // constructor and lifetime issues. Let the helper decide the actual
180  // name of the file given the prefix.
181  //
182  AsciiTraceHelper asciiTraceHelper;
183 
184  std::string filename;
185  if (explicitFilename)
186  {
187  filename = prefix;
188  }
189  else
190  {
191  filename = asciiTraceHelper.GetFilenameFromDevice (prefix, device);
192  }
193 
194  Ptr<OutputStreamWrapper> theStream = asciiTraceHelper.CreateFileStream (filename);
195  //
196  // We could go poking through the phy and the state looking for the
197  // correct trace source, but we can let Config deal with that with
198  // some search cost. Since this is presumably happening at topology
199  // creation time, it doesn't seem much of a price to pay.
200  //
201  oss.str ("");
202  oss << "/NodeList/" << nodeid << "/DeviceList/" << deviceid << "/$ns3::WaveNetDevice/PhyEntities/*/$ns3::WifiPhy/State/RxOk";
204 
205  oss.str ("");
206  oss << "/NodeList/" << nodeid << "/DeviceList/" << deviceid << "/$ns3::WaveNetDevice/PhyEntities/*/$ns3::WifiPhy/State/Tx";
208 
209  return;
210  }
211 
212  //
213  // If we are provided an OutputStreamWrapper, we are expected to use it, and
214  // to provide a context. We are free to come up with our own context if we
215  // want, and use the AsciiTraceHelper Hook*WithContext functions, but for
216  // compatibility and simplicity, we just use Config::Connect and let it deal
217  // with coming up with a context.
218  //
219  oss.str ("");
220  oss << "/NodeList/" << nodeid << "/DeviceList/" << deviceid << "/$ns3::WaveNetDevice/PhyEntities/*/$ns3::WifiPhy/RxOk";
222 
223  oss.str ("");
224  oss << "/NodeList/" << nodeid << "/DeviceList/" << deviceid << "/$ns3::WaveNetDevice/PhyEntities/*/$ns3::WifiPhy/State/Tx";
226 }
227 
228 /********************************** WaveHelper ******************************************/
230 {
231 }
232 
234 {
235 }
236 
239 {
240  WaveHelper helper;
241  // default 7 MAC entities and single PHY device.
243  helper.CreatePhys (1);
244  helper.SetChannelScheduler ("ns3::DefaultChannelScheduler");
245  helper.SetRemoteStationManager ("ns3::ConstantRateWifiManager",
246  "DataMode", StringValue ("OfdmRate6MbpsBW10MHz"),
247  "ControlMode",StringValue ("OfdmRate6MbpsBW10MHz"),
248  "NonUnicastMode", StringValue ("OfdmRate6MbpsBW10MHz"));
249  return helper;
250 }
251 
252 void
253 WaveHelper::CreateMacForChannel (std::vector<uint32_t> channelNumbers)
254 {
255  if (channelNumbers.size () == 0)
256  {
257  NS_FATAL_ERROR ("the WAVE MAC entities is at least one");
258  }
259  for (std::vector<uint32_t>::iterator i = channelNumbers.begin (); i != channelNumbers.end (); ++i)
260  {
262  {
263  NS_FATAL_ERROR ("the channel number " << (*i) << " is not a valid WAVE channel number");
264  }
265  }
266  m_macsForChannelNumber = channelNumbers;
267 }
268 
269 void
270 WaveHelper::CreatePhys (uint32_t phys)
271 {
272  if (phys == 0)
273  {
274  NS_FATAL_ERROR ("the WAVE PHY entities is at least one");
275  }
277  {
278  NS_FATAL_ERROR ("the number of assigned WAVE PHY entities is more than the number of valid WAVE channels");
279  }
280  m_physNumber = phys;
281 }
282 
283 void
285  std::string n0, const AttributeValue &v0,
286  std::string n1, const AttributeValue &v1,
287  std::string n2, const AttributeValue &v2,
288  std::string n3, const AttributeValue &v3,
289  std::string n4, const AttributeValue &v4,
290  std::string n5, const AttributeValue &v5,
291  std::string n6, const AttributeValue &v6,
292  std::string n7, const AttributeValue &v7)
293 {
296  m_stationManager.Set (n0, v0);
297  m_stationManager.Set (n1, v1);
298  m_stationManager.Set (n2, v2);
299  m_stationManager.Set (n3, v3);
300  m_stationManager.Set (n4, v4);
301  m_stationManager.Set (n5, v5);
302  m_stationManager.Set (n6, v6);
303  m_stationManager.Set (n7, v7);
304 }
305 
306 void
308  std::string n0, const AttributeValue &v0,
309  std::string n1, const AttributeValue &v1,
310  std::string n2, const AttributeValue &v2,
311  std::string n3, const AttributeValue &v3,
312  std::string n4, const AttributeValue &v4,
313  std::string n5, const AttributeValue &v5,
314  std::string n6, const AttributeValue &v6,
315  std::string n7, const AttributeValue &v7)
316 {
319  m_channelScheduler.Set (n0, v0);
320  m_channelScheduler.Set (n1, v1);
321  m_channelScheduler.Set (n2, v2);
322  m_channelScheduler.Set (n3, v3);
323  m_channelScheduler.Set (n4, v4);
324  m_channelScheduler.Set (n5, v5);
325  m_channelScheduler.Set (n6, v6);
326  m_channelScheduler.Set (n7, v7);
327 }
328 
330 WaveHelper::Install (const WifiPhyHelper &phyHelper, const WifiMacHelper &macHelper, NodeContainer c) const
331 {
332  try
333  {
334  const QosWaveMacHelper& qosMac = dynamic_cast<const QosWaveMacHelper&> (macHelper);
335  NS_UNUSED (qosMac);
336  }
337  catch (const std::bad_cast &)
338  {
339  NS_FATAL_ERROR ("WifiMacHelper should be the class or subclass of QosWaveMacHelper");
340  }
341 
343  for (NodeContainer::Iterator i = c.Begin (); i != c.End (); ++i)
344  {
345  Ptr<Node> node = *i;
346  Ptr<WaveNetDevice> device = CreateObject<WaveNetDevice> ();
347 
348  device->SetChannelManager (CreateObject<ChannelManager> ());
349  device->SetChannelCoordinator (CreateObject<ChannelCoordinator> ());
350  device->SetVsaManager (CreateObject<VsaManager> ());
352 
353  for (uint32_t j = 0; j != m_physNumber; ++j)
354  {
355  Ptr<WifiPhy> phy = phyHelper.Create (node, device);
358  device->AddPhy (phy);
359  }
360 
361  for (std::vector<uint32_t>::const_iterator k = m_macsForChannelNumber.begin ();
362  k != m_macsForChannelNumber.end (); ++k)
363  {
364  Ptr<WifiMac> wifiMac = macHelper.Create ();
365  Ptr<OcbWifiMac> ocbMac = DynamicCast<OcbWifiMac> (wifiMac);
366  // we use WaveMacLow to replace original MacLow
367  ocbMac->EnableForWave (device);
370  device->AddMac (*k, ocbMac);
371  }
372 
373  device->SetAddress (Mac48Address::Allocate ());
374 
375  node->AddDevice (device);
376  devices.Add (device);
377  }
378  return devices;
379 }
380 
383 {
384  return Install (phy, mac, NodeContainer (node));
385 }
386 
388 WaveHelper::Install (const WifiPhyHelper &phy, const WifiMacHelper &mac, std::string nodeName) const
389 {
390  Ptr<Node> node = Names::Find<Node> (nodeName);
391  return Install (phy, mac, NodeContainer (node));
392 }
393 
394 void
396 {
398 
399  LogComponentEnable ("WaveNetDevice", LOG_LEVEL_ALL);
400  LogComponentEnable ("ChannelCoordinator", LOG_LEVEL_ALL);
401  LogComponentEnable ("ChannelManager", LOG_LEVEL_ALL);
402  LogComponentEnable ("ChannelScheduler", LOG_LEVEL_ALL);
403  LogComponentEnable ("DefaultChannelScheduler", LOG_LEVEL_ALL);
404  LogComponentEnable ("VsaManager", LOG_LEVEL_ALL);
405  LogComponentEnable ("OcbWifiMac", LOG_LEVEL_ALL);
406  LogComponentEnable ("VendorSpecificAction", LOG_LEVEL_ALL);
407  LogComponentEnable ("WaveMacLow", LOG_LEVEL_ALL);
408  LogComponentEnable ("HigherLayerTxVectorTag", LOG_LEVEL_ALL);
409 }
410 
411 int64_t
413 {
414  int64_t currentStream = stream;
415  Ptr<NetDevice> netDevice;
416  for (NetDeviceContainer::Iterator i = c.Begin (); i != c.End (); ++i)
417  {
418  netDevice = (*i);
419  Ptr<WaveNetDevice> wave = DynamicCast<WaveNetDevice> (netDevice);
420  if (wave)
421  {
422  // Handle any random numbers in the PHY objects.
423  std::vector<Ptr<WifiPhy> > phys = wave->GetPhys ();
424  for (std::vector<Ptr<WifiPhy> >::iterator j = phys.begin (); j != phys.end (); ++j)
425  {
426  currentStream += (*j)->AssignStreams (currentStream);
427  }
428 
429  // Handle any random numbers in the MAC objects.
430  std::map<uint32_t, Ptr<OcbWifiMac> > macs = wave->GetMacs ();
431  for ( std::map<uint32_t, Ptr<OcbWifiMac> >::iterator k = macs.begin (); k != macs.end (); ++k)
432  {
433  Ptr<RegularWifiMac> rmac = DynamicCast<RegularWifiMac> (k->second);
434 
435  // Handle any random numbers in the station managers.
436  Ptr<WifiRemoteStationManager> manager = rmac->GetWifiRemoteStationManager ();
437  Ptr<MinstrelWifiManager> minstrel = DynamicCast<MinstrelWifiManager> (manager);
438  if (minstrel)
439  {
440  currentStream += minstrel->AssignStreams (currentStream);
441  }
442 
443  PointerValue ptr;
444  rmac->GetAttribute ("DcaTxop", ptr);
445  Ptr<DcaTxop> dcaTxop = ptr.Get<DcaTxop> ();
446  currentStream += dcaTxop->AssignStreams (currentStream);
447 
448  rmac->GetAttribute ("VO_EdcaTxopN", ptr);
449  Ptr<EdcaTxopN> vo_edcaTxopN = ptr.Get<EdcaTxopN> ();
450  currentStream += vo_edcaTxopN->AssignStreams (currentStream);
451 
452  rmac->GetAttribute ("VI_EdcaTxopN", ptr);
453  Ptr<EdcaTxopN> vi_edcaTxopN = ptr.Get<EdcaTxopN> ();
454  currentStream += vi_edcaTxopN->AssignStreams (currentStream);
455 
456  rmac->GetAttribute ("BE_EdcaTxopN", ptr);
457  Ptr<EdcaTxopN> be_edcaTxopN = ptr.Get<EdcaTxopN> ();
458  currentStream += be_edcaTxopN->AssignStreams (currentStream);
459 
460  rmac->GetAttribute ("BK_EdcaTxopN", ptr);
461  Ptr<EdcaTxopN> bk_edcaTxopN = ptr.Get<EdcaTxopN> ();
462  currentStream += bk_edcaTxopN->AssignStreams (currentStream);
463  }
464  }
465  }
466  return (currentStream - stream);
467 }
468 } // namespace ns3
static void EnableLogComponents(void)
Helper to enable all WaveNetDevice log components with one statement.
Definition: wave-helper.cc:395
Iterator Begin(void) const
Get an iterator which refers to the first NetDevice in the container.
void CreateMacForChannel(std::vector< uint32_t > channelNumbers)
Definition: wave-helper.cc:253
ObjectFactory m_channelScheduler
Definition: wave-helper.h:246
Ptr< T > Get(void) const
Definition: pointer.h:194
Manage ASCII trace files for device models.
Definition: trace-helper.h:161
#define NS_LOG_FUNCTION(parameters)
If log level LOG_FUNCTION is enabled, this macro will output all input parameters separated by "...
static std::vector< uint32_t > GetWaveChannels(void)
tuple devices
Definition: first.py:32
int64_t AssignStreams(NetDeviceContainer c, int64_t stream)
Assign a fixed random variable stream number to the random variables used by the Phy and Mac aspects ...
Definition: wave-helper.cc:412
static void AsciiPhyReceiveSinkWithoutContext(Ptr< OutputStreamWrapper > stream, Ptr< const Packet > p, double snr, WifiMode mode, enum WifiPreamble preamble)
Definition: wave-helper.cc:78
virtual void SetWifiRemoteStationManager(Ptr< WifiRemoteStationManager > stationManager)
std::vector< Ptr< Node > >::const_iterator Iterator
Node container iterator.
Hold variables of type string.
Definition: string.h:41
Hold a value for an Attribute.
Definition: attribute.h:68
Manage pcap files for device models.
Definition: trace-helper.h:38
create PHY objects
Definition: wifi-helper.h:48
Callback< R > MakeBoundCallback(R(*fnPtr)(TX), ARG a1)
Make Callbacks with one bound argument.
Definition: callback.h:1686
void ConfigureStandard(enum WifiPhyStandard standard)
Definition: wifi-mac.cc:290
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:201
static bool IsWaveChannel(uint32_t channelNumber)
void SetTypeId(TypeId tid)
Set the TypeId of the Objects to be created by this factory.
#define NS_UNUSED(x)
Mark a local variable as unused.
Definition: unused.h:36
OFDM PHY for the 5 GHz band (Clause 17 with 10 MHz channel bandwidth)
This class holds together multiple, ns3::WifiPhy, and ns3::OcbWifiMac (including ns3::WifiRemoteStati...
Iterator End(void) const
Get an iterator which indicates past-the-last Node in the container.
static void AsciiPhyReceiveSinkWithContext(Ptr< OutputStreamWrapper > stream, std::string context, Ptr< const Packet > p, double snr, WifiMode mode, enum WifiPreamble preamble)
Definition: wave-helper.cc:65
static WaveHelper Default(void)
Definition: wave-helper.cc:238
void EnableForWave(Ptr< WaveNetDevice > device)
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Definition: log.h:244
#define NS_FATAL_ERROR(msg)
Report a fatal error with a message and terminate.
Definition: fatal-error.h:162
Ptr< OutputStreamWrapper > CreateFileStream(std::string filename, std::ios::openmode filemode=std::ios::out)
Create and initialize an output stream object we'll use to write the traced bits. ...
std::string GetFilenameFromDevice(std::string prefix, Ptr< NetDevice > device, bool useObjectNames=true)
Let the ascii trace helper figure out a reasonable filename to use for an ascii trace file associated...
virtual NetDeviceContainer Install(const WifiPhyHelper &phy, const WifiMacHelper &mac, NodeContainer c) const
Definition: wave-helper.cc:330
virtual void SetAddress(Address address)
Set the address of this interface.
represent a single transmission modeA WifiMode is implemented by a single integer which is used to lo...
Definition: wifi-mode.h:99
WifiPreamble
The type of preamble to be used by an IEEE 802.11 transmission.
Definition: wifi-preamble.h:30
double GetSeconds(void) const
Get an approximation of the time stored in this instance in the indicated unit.
Definition: nstime.h:341
void SetRemoteStationManager(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())
Definition: wave-helper.cc:284
This queue contains packets for a particular access class.
Definition: edca-txop-n.h:86
static void PcapSniffTxEvent(Ptr< PcapFileWrapper > file, Ptr< const Packet > packet, uint16_t channelFreqMhz, uint16_t channelNumber, uint32_t rate, WifiPreamble preamble, WifiTxVector txVector, struct mpduInfo aMpdu)
Definition: wifi-helper.cc:141
static uint32_t GetNumberOfWaveChannels(void)
std::string GetFilenameFromDevice(std::string prefix, Ptr< NetDevice > device, bool useObjectNames=true)
Let the pcap helper figure out a reasonable filename to use for a pcap file associated with a device...
Definition: trace-helper.cc:80
std::vector< uint32_t > m_macsForChannelNumber
Definition: wave-helper.h:247
void LogComponentEnable(char const *name, enum LogLevel level)
Enable the logging output associated with that log component.
Definition: log.cc:351
tuple phy
Definition: third.py:86
static Mac48Address Allocate(void)
Allocate a new Mac48Address.
static void EnablePrinting(void)
Enable printing packets metadata.
Definition: packet.cc:535
virtual void EnablePcapInternal(std::string prefix, Ptr< NetDevice > nd, bool promiscuous, bool explicitFilename)
Enable pcap output the indicated net device.
Definition: wave-helper.cc:100
Ptr< Object > Create(void) const
Create an Object instance of the configured TypeId.
void Add(NetDeviceContainer other)
Append the contents of another NetDeviceContainer to the end of this container.
void SetChannelScheduler(Ptr< ChannelScheduler > channelScheduler)
helps to create WaveNetDevice objects
Definition: wave-helper.h:110
virtual ~WaveHelper()
Definition: wave-helper.cc:233
void SetChannelManager(Ptr< ChannelManager > channelManager)
holds a vector of ns3::NetDevice pointers
void SetChannelScheduler(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())
Definition: wave-helper.cc:307
void ConnectWithoutContext(std::string path, const CallbackBase &cb)
Definition: config.cc:824
int64_t AssignStreams(int64_t stream)
Assign a fixed random variable stream number to the random variables used by this model...
tuple mac
Definition: third.py:92
virtual void SetChannelNumber(uint16_t id)
Set channel number.
Definition: wifi-phy.cc:1275
hold a list of per-remote-station state.
virtual void EnableAsciiInternal(Ptr< OutputStreamWrapper > stream, std::string prefix, Ptr< NetDevice > nd, bool explicitFilename)
Enable ascii trace output on the indicated net device.
Definition: wave-helper.cc:141
void Connect(std::string path, const CallbackBase &cb)
Definition: config.cc:835
static uint32_t GetCch(void)
bool TraceConnectWithoutContext(std::string name, const CallbackBase &cb)
Connect a TraceSource to a Callback without a context.
Definition: object-base.cc:299
std::map< uint32_t, Ptr< OcbWifiMac > > GetMacs(void) const
Every class exported by the ns3 library is enclosed in the ns3 namespace.
keep track of a set of node pointers.
Hold objects of type Ptr.
Definition: pointer.h:36
void CreatePhys(uint32_t phys)
Definition: wave-helper.cc:270
Iterator Begin(void) const
Get an iterator which refers to the first Node in the container.
void Set(std::string name, const AttributeValue &value)
Set an attribute to be set during construction.
create MAC layers for a ns3::WifiNetDevice.
To trace WaveNetDevice, we have to overwrite the trace functions of class YansWifiPhyHelper.
Definition: wave-helper.h:39
static Time Now(void)
Return the current simulation virtual time.
Definition: simulator.cc:224
void SetErrorRateModel(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())
Definition: wifi-helper.cc:118
virtual Ptr< WifiMac > Create(void) const
std::vector< Ptr< WifiPhy > > GetPhys(void) const
virtual void ConfigureStandard(enum WifiPhyStandard standard)
Configure the PHY-level parameters for different Wi-Fi standard.
Definition: wifi-phy.cc:1026
void AddPhy(Ptr< WifiPhy > phy)
ObjectFactory m_stationManager
Definition: wave-helper.h:245
Instantiate subclasses of ns3::Object.
static void EnableLogComponents(void)
Helper to enable all WifiNetDevice log components with one statement.
Definition: wifi-helper.cc:752
virtual Ptr< WifiPhy > Create(Ptr< Node > node, Ptr< NetDevice > device) const =0
uint32_t AddDevice(Ptr< NetDevice > device)
Associate a NetDevice to this node.
Definition: node.cc:128
#define NS_ABORT_MSG_IF(cond, msg)
Abnormal program termination if a condition is true, with a message.
Definition: abort.h:108
static YansWavePhyHelper Default(void)
Create a phy helper in a default working state.
Definition: wave-helper.cc:92
void SetVsaManager(Ptr< VsaManager > vsaManager)
std::vector< Ptr< NetDevice > >::const_iterator Iterator
NetDevice container iterator.
void AddMac(uint32_t channelNumber, Ptr< OcbWifiMac > mac)
Print everything.
Definition: log.h:112
void SetChannelCoordinator(Ptr< ChannelCoordinator > channelCoordinator)
Iterator End(void) const
Get an iterator which indicates past-the-last NetDevice in the container.
handle packet fragmentation and retransmissions.
Definition: dca-txop.h:67
static void PcapSniffRxEvent(Ptr< PcapFileWrapper > file, Ptr< const Packet > packet, uint16_t channelFreqMhz, uint16_t channelNumber, uint32_t rate, WifiPreamble preamble, WifiTxVector txVector, struct mpduInfo aMpdu, struct signalNoiseDbm signalNoise)
Definition: wifi-helper.cc:333
PcapHelper::DataLinkType GetPcapDataLinkType(void) const
Get the data link type of PCAP traces to be used.
Definition: wifi-helper.cc:549
static void AsciiPhyTransmitSinkWithContext(Ptr< OutputStreamWrapper > stream, std::string context, Ptr< const Packet > p, WifiMode mode, WifiPreamble preamble, uint8_t txLevel)
Definition: wave-helper.cc:40
std::ostream * GetStream(void)
Return a pointer to an ostream previously set in the wrapper.
This class will assign channel access for requests from higher layers.
uint32_t m_physNumber
Definition: wave-helper.h:248
static void AsciiPhyTransmitSinkWithoutContext(Ptr< OutputStreamWrapper > stream, Ptr< const Packet > p, WifiMode mode, WifiPreamble preamble, uint8_t txLevel)
Definition: wave-helper.cc:53