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
19#include "ns3/log.h"
20#include "ns3/pointer.h"
21#include "ns3/string.h"
22#include "ns3/config.h"
23#include "ns3/names.h"
24#include "ns3/abort.h"
25#include "ns3/wave-net-device.h"
26#include "ns3/qos-txop.h"
27#include "ns3/minstrel-wifi-manager.h"
28#include "ns3/radiotap-header.h"
29#include "wave-mac-helper.h"
30#include "wave-helper.h"
31
32NS_LOG_COMPONENT_DEFINE ("WaveHelper");
33
34namespace ns3 {
35
45static void
48 std::string context,
50 WifiMode mode,
51 WifiPreamble preamble,
52 uint8_t txLevel)
53{
54 NS_LOG_FUNCTION (stream << context << p << mode << preamble << txLevel);
55 *stream->GetStream () << "t " << Simulator::Now ().GetSeconds () << " " << context << " " << *p << std::endl;
56}
57
66static void
70 WifiMode mode,
71 WifiPreamble preamble,
72 uint8_t txLevel)
73{
74 NS_LOG_FUNCTION (stream << p << mode << preamble << txLevel);
75 *stream->GetStream () << "t " << Simulator::Now ().GetSeconds () << " " << *p << std::endl;
76}
77
87static void
90 std::string context,
92 double snr,
93 WifiMode mode,
94 enum WifiPreamble preamble)
95{
96 NS_LOG_FUNCTION (stream << context << p << snr << mode << preamble);
97 *stream->GetStream () << "r " << Simulator::Now ().GetSeconds () << " " << context << " " << *p << std::endl;
98}
99
108static void
112 double snr,
113 WifiMode mode,
114 enum WifiPreamble preamble)
115{
116 NS_LOG_FUNCTION (stream << p << snr << mode << preamble);
117 *stream->GetStream () << "r " << Simulator::Now ().GetSeconds () << " " << *p << std::endl;
118}
119
120
121/****************************** YansWavePhyHelper ***********************************/
122YansWavePhyHelper
124{
125 YansWavePhyHelper helper;
126 helper.SetErrorRateModel ("ns3::NistErrorRateModel");
127 return helper;
128}
129
130void
131YansWavePhyHelper::EnablePcapInternal (std::string prefix, Ptr<NetDevice> nd, bool promiscuous, bool explicitFilename)
132{
133 //
134 // All of the Pcap enable functions vector through here including the ones
135 // that are wandering through all of devices on perhaps all of the nodes in
136 // the system. We can only deal with devices of type WaveNetDevice.
137 //
139 if (device == 0)
140 {
141 NS_LOG_INFO ("YansWavePhyHelper::EnablePcapInternal(): Device " << &device << " not of type ns3::WaveNetDevice");
142 return;
143 }
144
145 std::vector<Ptr<WifiPhy> > phys = device->GetPhys ();
146 NS_ABORT_MSG_IF (phys.size () == 0, "EnablePcapInternal(): Phy layer in WaveNetDevice must be set");
147
148 PcapHelper pcapHelper;
149
150 std::string filename;
151 if (explicitFilename)
152 {
153 filename = prefix;
154 }
155 else
156 {
157 filename = pcapHelper.GetFilenameFromDevice (prefix, device);
158 }
159
160 Ptr<PcapFileWrapper> file = pcapHelper.CreateFile (filename, std::ios::out, GetPcapDataLinkType ());
161
162 std::vector<Ptr<WifiPhy> >::iterator i;
163 for (i = phys.begin (); i != phys.end (); ++i)
164 {
165 Ptr<WifiPhy> phy = (*i);
166 phy->TraceConnectWithoutContext ("MonitorSnifferTx", MakeBoundCallback (&YansWavePhyHelper::PcapSniffTxEvent, file));
167 phy->TraceConnectWithoutContext ("MonitorSnifferRx", MakeBoundCallback (&YansWavePhyHelper::PcapSniffRxEvent, file));
168 }
169}
170
171void
174 std::string prefix,
176 bool explicitFilename)
177{
178 //
179 // All of the ascii enable functions vector through here including the ones
180 // that are wandering through all of devices on perhaps all of the nodes in
181 // the system. We can only deal with devices of type WaveNetDevice.
182 //
184 if (device == 0)
185 {
186 NS_LOG_INFO ("EnableAsciiInternal(): Device " << device << " not of type ns3::WaveNetDevice");
187 return;
188 }
189
190 //
191 // Our trace sinks are going to use packet printing, so we have to make sure
192 // that is turned on.
193 //
195
196 uint32_t nodeid = nd->GetNode ()->GetId ();
197 uint32_t deviceid = nd->GetIfIndex ();
198 std::ostringstream oss;
199
200 //
201 // If we are not provided an OutputStreamWrapper, we are expected to create
202 // one using the usual trace filename conventions and write our traces
203 // without a context since there will be one file per context and therefore
204 // the context would be redundant.
205 //
206 if (stream == 0)
207 {
208 //
209 // Set up an output stream object to deal with private ofstream copy
210 // constructor and lifetime issues. Let the helper decide the actual
211 // name of the file given the prefix.
212 //
213 AsciiTraceHelper asciiTraceHelper;
214
215 std::string filename;
216 if (explicitFilename)
217 {
218 filename = prefix;
219 }
220 else
221 {
222 filename = asciiTraceHelper.GetFilenameFromDevice (prefix, device);
223 }
224
225 Ptr<OutputStreamWrapper> theStream = asciiTraceHelper.CreateFileStream (filename);
226 //
227 // We could go poking through the phy and the state looking for the
228 // correct trace source, but we can let Config deal with that with
229 // some search cost. Since this is presumably happening at topology
230 // creation time, it doesn't seem much of a price to pay.
231 //
232 oss.str ("");
233 oss << "/NodeList/" << nodeid << "/DeviceList/" << deviceid << "/$ns3::WaveNetDevice/PhyEntities/*/$ns3::WifiPhy/State/RxOk";
235
236 oss.str ("");
237 oss << "/NodeList/" << nodeid << "/DeviceList/" << deviceid << "/$ns3::WaveNetDevice/PhyEntities/*/$ns3::WifiPhy/State/Tx";
239
240 return;
241 }
242
243 //
244 // If we are provided an OutputStreamWrapper, we are expected to use it, and
245 // to provide a context. We are free to come up with our own context if we
246 // want, and use the AsciiTraceHelper Hook*WithContext functions, but for
247 // compatibility and simplicity, we just use Config::Connect and let it deal
248 // with coming up with a context.
249 //
250 oss.str ("");
251 oss << "/NodeList/" << nodeid << "/DeviceList/" << deviceid << "/$ns3::WaveNetDevice/PhyEntities/*/$ns3::WifiPhy/RxOk";
253
254 oss.str ("");
255 oss << "/NodeList/" << nodeid << "/DeviceList/" << deviceid << "/$ns3::WaveNetDevice/PhyEntities/*/$ns3::WifiPhy/State/Tx";
257}
258
259/********************************** WaveHelper ******************************************/
261{
262}
263
265{
266}
267
270{
271 WaveHelper helper;
272 // default 7 MAC entities and single PHY device.
274 helper.CreatePhys (1);
275 helper.SetChannelScheduler ("ns3::DefaultChannelScheduler");
276 helper.SetRemoteStationManager ("ns3::ConstantRateWifiManager",
277 "DataMode", StringValue ("OfdmRate6MbpsBW10MHz"),
278 "ControlMode",StringValue ("OfdmRate6MbpsBW10MHz"),
279 "NonUnicastMode", StringValue ("OfdmRate6MbpsBW10MHz"));
280 return helper;
281}
282
283void
284WaveHelper::CreateMacForChannel (std::vector<uint32_t> channelNumbers)
285{
286 if (channelNumbers.size () == 0)
287 {
288 NS_FATAL_ERROR ("the WAVE MAC entities is at least one");
289 }
290 for (std::vector<uint32_t>::iterator i = channelNumbers.begin (); i != channelNumbers.end (); ++i)
291 {
293 {
294 NS_FATAL_ERROR ("the channel number " << (*i) << " is not a valid WAVE channel number");
295 }
296 }
297 m_macsForChannelNumber = channelNumbers;
298}
299
300void
302{
303 if (phys == 0)
304 {
305 NS_FATAL_ERROR ("the WAVE PHY entities is at least one");
306 }
308 {
309 NS_FATAL_ERROR ("the number of assigned WAVE PHY entities is more than the number of valid WAVE channels");
310 }
311 m_physNumber = phys;
312}
313
314void
316 std::string n0, const AttributeValue &v0,
317 std::string n1, const AttributeValue &v1,
318 std::string n2, const AttributeValue &v2,
319 std::string n3, const AttributeValue &v3,
320 std::string n4, const AttributeValue &v4,
321 std::string n5, const AttributeValue &v5,
322 std::string n6, const AttributeValue &v6,
323 std::string n7, const AttributeValue &v7)
324{
327 m_stationManager.Set (n0, v0);
328 m_stationManager.Set (n1, v1);
329 m_stationManager.Set (n2, v2);
330 m_stationManager.Set (n3, v3);
331 m_stationManager.Set (n4, v4);
332 m_stationManager.Set (n5, v5);
333 m_stationManager.Set (n6, v6);
334 m_stationManager.Set (n7, v7);
335}
336
337void
339 std::string n0, const AttributeValue &v0,
340 std::string n1, const AttributeValue &v1,
341 std::string n2, const AttributeValue &v2,
342 std::string n3, const AttributeValue &v3,
343 std::string n4, const AttributeValue &v4,
344 std::string n5, const AttributeValue &v5,
345 std::string n6, const AttributeValue &v6,
346 std::string n7, const AttributeValue &v7)
347{
350 m_channelScheduler.Set (n0, v0);
351 m_channelScheduler.Set (n1, v1);
352 m_channelScheduler.Set (n2, v2);
353 m_channelScheduler.Set (n3, v3);
354 m_channelScheduler.Set (n4, v4);
355 m_channelScheduler.Set (n5, v5);
356 m_channelScheduler.Set (n6, v6);
357 m_channelScheduler.Set (n7, v7);
358}
359
361WaveHelper::Install (const WifiPhyHelper &phyHelper, const WifiMacHelper &macHelper, NodeContainer c) const
362{
363 try
364 {
365 [[maybe_unused]] const QosWaveMacHelper& qosMac = dynamic_cast<const QosWaveMacHelper&> (macHelper);
366 }
367 catch (const std::bad_cast &)
368 {
369 NS_FATAL_ERROR ("WifiMacHelper should be the class or subclass of QosWaveMacHelper");
370 }
371
373 for (NodeContainer::Iterator i = c.Begin (); i != c.End (); ++i)
374 {
375 Ptr<Node> node = *i;
376 Ptr<WaveNetDevice> device = CreateObject<WaveNetDevice> ();
377
378 device->SetChannelManager (CreateObject<ChannelManager> ());
379 device->SetChannelCoordinator (CreateObject<ChannelCoordinator> ());
380 device->SetVsaManager (CreateObject<VsaManager> ());
382
383 for (uint32_t j = 0; j != m_physNumber; ++j)
384 {
385 Ptr<WifiPhy> phy = phyHelper.Create (node, device);
386 phy->ConfigureStandard (WIFI_STANDARD_80211p);
387 phy->SetOperatingChannel (WifiPhy::ChannelTuple {ChannelManager::GetCch (), 0,
389 device->AddPhy (phy);
390 }
391
392 for (std::vector<uint32_t>::const_iterator k = m_macsForChannelNumber.begin ();
393 k != m_macsForChannelNumber.end (); ++k)
394 {
395 Ptr<WifiMac> wifiMac = macHelper.Create (device, WIFI_STANDARD_80211p);
396 Ptr<OcbWifiMac> ocbMac = DynamicCast<OcbWifiMac> (wifiMac);
398 ocbMac->EnableForWave (device);
399 device->AddMac (*k, ocbMac);
400 }
401
403
404 node->AddDevice (device);
405 devices.Add (device);
406 }
407 return devices;
408}
409
412{
413 return Install (phy, mac, NodeContainer (node));
414}
415
417WaveHelper::Install (const WifiPhyHelper &phy, const WifiMacHelper &mac, std::string nodeName) const
418{
419 Ptr<Node> node = Names::Find<Node> (nodeName);
420 return Install (phy, mac, NodeContainer (node));
421}
422
423void
425{
427
428 LogComponentEnable ("WaveNetDevice", LOG_LEVEL_ALL);
429 LogComponentEnable ("ChannelCoordinator", LOG_LEVEL_ALL);
430 LogComponentEnable ("ChannelManager", LOG_LEVEL_ALL);
431 LogComponentEnable ("ChannelScheduler", LOG_LEVEL_ALL);
432 LogComponentEnable ("DefaultChannelScheduler", LOG_LEVEL_ALL);
433 LogComponentEnable ("VsaManager", LOG_LEVEL_ALL);
434 LogComponentEnable ("OcbWifiMac", LOG_LEVEL_ALL);
435 LogComponentEnable ("VendorSpecificAction", LOG_LEVEL_ALL);
436 LogComponentEnable ("WaveFrameExchangeManager", LOG_LEVEL_ALL);
437 LogComponentEnable ("HigherLayerTxVectorTag", LOG_LEVEL_ALL);
438}
439
440int64_t
442{
443 int64_t currentStream = stream;
444 Ptr<NetDevice> netDevice;
445 for (NetDeviceContainer::Iterator i = c.Begin (); i != c.End (); ++i)
446 {
447 netDevice = (*i);
448 Ptr<WaveNetDevice> wave = DynamicCast<WaveNetDevice> (netDevice);
449 if (wave)
450 {
451 // Handle any random numbers in the PHY objects.
452 std::vector<Ptr<WifiPhy> > phys = wave->GetPhys ();
453 for (std::vector<Ptr<WifiPhy> >::iterator j = phys.begin (); j != phys.end (); ++j)
454 {
455 currentStream += (*j)->AssignStreams (currentStream);
456 }
457
458 // Handle any random numbers in the MAC objects.
459 std::map<uint32_t, Ptr<OcbWifiMac> > macs = wave->GetMacs ();
460 for ( std::map<uint32_t, Ptr<OcbWifiMac> >::iterator k = macs.begin (); k != macs.end (); ++k)
461 {
462 // Handle any random numbers in the station managers.
463 Ptr<WifiRemoteStationManager> manager = k->second->GetWifiRemoteStationManager ();
464 Ptr<MinstrelWifiManager> minstrel = DynamicCast<MinstrelWifiManager> (manager);
465 if (minstrel)
466 {
467 currentStream += minstrel->AssignStreams (currentStream);
468 }
469
470 PointerValue ptr;
471 k->second->GetAttribute ("Txop", ptr);
472 Ptr<Txop> txop = ptr.Get<Txop> ();
473 currentStream += txop->AssignStreams (currentStream);
474
475 k->second->GetAttribute ("VO_Txop", ptr);
476 Ptr<QosTxop> vo_txop = ptr.Get<QosTxop> ();
477 currentStream += vo_txop->AssignStreams (currentStream);
478
479 k->second->GetAttribute ("VI_Txop", ptr);
480 Ptr<QosTxop> vi_txop = ptr.Get<QosTxop> ();
481 currentStream += vi_txop->AssignStreams (currentStream);
482
483 k->second->GetAttribute ("BE_Txop", ptr);
484 Ptr<QosTxop> be_txop = ptr.Get<QosTxop> ();
485 currentStream += be_txop->AssignStreams (currentStream);
486
487 k->second->GetAttribute ("BK_Txop", ptr);
488 Ptr<QosTxop> bk_txop = ptr.Get<QosTxop> ();
489 currentStream += bk_txop->AssignStreams (currentStream);
490 }
491 }
492 }
493 return (currentStream - stream);
494}
495} // namespace ns3
Manage ASCII trace files for device models.
Definition: trace-helper.h:163
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...
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.
Hold a value for an Attribute.
Definition: attribute.h:69
static uint32_t GetNumberOfWaveChannels(void)
static std::vector< uint32_t > GetWaveChannels(void)
static uint32_t GetCch(void)
static bool IsWaveChannel(uint32_t channelNumber)
This class will assign channel access for requests from higher layers.
static Mac48Address Allocate(void)
Allocate a new Mac48Address.
holds a vector of ns3::NetDevice pointers
std::vector< Ptr< NetDevice > >::const_iterator Iterator
NetDevice container iterator.
Iterator End(void) const
Get an iterator which indicates past-the-last NetDevice in the container.
Iterator Begin(void) const
Get an iterator which refers to the first NetDevice in the container.
virtual uint32_t GetIfIndex(void) const =0
virtual Ptr< Node > GetNode(void) const =0
keep track of a set of node pointers.
std::vector< Ptr< Node > >::const_iterator Iterator
Node container iterator.
Iterator Begin(void) const
Get an iterator which refers to the first Node in the container.
Iterator End(void) const
Get an iterator which indicates past-the-last Node in the container.
uint32_t GetId(void) const
Definition: node.cc:109
uint32_t AddDevice(Ptr< NetDevice > device)
Associate a NetDevice to this node.
Definition: node.cc:130
Instantiate subclasses of ns3::Object.
void Set(const std::string &name, const AttributeValue &value, Args &&... args)
Set an attribute to be set during construction.
Ptr< Object > Create(void) const
Create an Object instance of the configured TypeId.
void SetTypeId(TypeId tid)
Set the TypeId of the Objects to be created by this factory.
Ptr< T > GetObject(void) const
Get a pointer to the requested aggregated Object.
Definition: object.h:470
void EnableForWave(Ptr< WaveNetDevice > device)
std::ostream * GetStream(void)
Return a pointer to an ostream previously set in the wrapper.
static void EnablePrinting(void)
Enable printing packets metadata.
Definition: packet.cc:572
Manage pcap files for device models.
Definition: trace-helper.h:39
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
Ptr< PcapFileWrapper > CreateFile(std::string filename, std::ios::openmode filemode, DataLinkType dataLinkType, uint32_t snapLen=std::numeric_limits< uint32_t >::max(), int32_t tzCorrection=0)
Create and initialize a pcap file.
Definition: trace-helper.cc:49
Hold objects of type Ptr<T>.
Definition: pointer.h:37
Ptr< T > Get(void) const
Definition: pointer.h:201
Handle packet fragmentation and retransmissions for QoS data frames as well as MSDU aggregation (A-MS...
Definition: qos-txop.h:72
Qos Wave Mac Helper class.
static Time Now(void)
Return the current simulation virtual time.
Definition: simulator.cc:195
Hold variables of type string.
Definition: string.h:41
double GetSeconds(void) const
Get an approximation of the time stored in this instance in the indicated unit.
Definition: nstime.h:379
Handle packet fragmentation and retransmissions for data and management frames.
Definition: txop.h:65
int64_t AssignStreams(int64_t stream)
Assign a fixed random variable stream number to the random variables used by this model.
Definition: txop.cc:309
helps to create WaveNetDevice objects
Definition: wave-helper.h:114
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:441
virtual ~WaveHelper()
Definition: wave-helper.cc:264
std::vector< uint32_t > m_macsForChannelNumber
MACs for channel number.
Definition: wave-helper.h:250
virtual NetDeviceContainer Install(const WifiPhyHelper &phy, const WifiMacHelper &mac, NodeContainer c) const
Definition: wave-helper.cc:361
uint32_t m_physNumber
Phy number.
Definition: wave-helper.h:251
void CreateMacForChannel(std::vector< uint32_t > channelNumbers)
Definition: wave-helper.cc:284
static void EnableLogComponents(void)
Helper to enable all WaveNetDevice log components with one statement.
Definition: wave-helper.cc:424
static WaveHelper Default(void)
Definition: wave-helper.cc:269
ObjectFactory m_channelScheduler
channel scheduler
Definition: wave-helper.h:249
ObjectFactory m_stationManager
station manager
Definition: wave-helper.h:248
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:315
void CreatePhys(uint32_t phys)
Definition: wave-helper.cc:301
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:338
This class holds together multiple, ns3::WifiPhy, and ns3::OcbWifiMac (including ns3::WifiRemoteStati...
void AddPhy(Ptr< WifiPhy > phy)
void SetChannelCoordinator(Ptr< ChannelCoordinator > channelCoordinator)
void AddMac(uint32_t channelNumber, Ptr< OcbWifiMac > mac)
void SetChannelScheduler(Ptr< ChannelScheduler > channelScheduler)
std::vector< Ptr< WifiPhy > > GetPhys(void) const
std::map< uint32_t, Ptr< OcbWifiMac > > GetMacs(void) const
void SetVsaManager(Ptr< VsaManager > vsaManager)
void SetChannelManager(Ptr< ChannelManager > channelManager)
virtual void SetAddress(Address address)
Set the address of this interface.
static void EnableLogComponents(void)
Helper to enable all WifiNetDevice log components with one statement.
Definition: wifi-helper.cc:792
create MAC layers for a ns3::WifiNetDevice.
virtual Ptr< WifiMac > Create(Ptr< WifiNetDevice > device, WifiStandard standard) const
void SetWifiRemoteStationManager(Ptr< WifiRemoteStationManager > stationManager)
Definition: wifi-mac.cc:750
represent a single transmission mode
Definition: wifi-mode.h:48
create PHY objects
Definition: wifi-helper.h:48
void SetErrorRateModel(std::string type, Args &&... args)
Helper function used to set the error rate model.
Definition: wifi-helper.h:440
virtual Ptr< WifiPhy > Create(Ptr< Node > node, Ptr< WifiNetDevice > device) const =0
static void PcapSniffRxEvent(Ptr< PcapFileWrapper > file, Ptr< const Packet > packet, uint16_t channelFreqMhz, WifiTxVector txVector, MpduInfo aMpdu, SignalNoiseDbm signalNoise, uint16_t staId=SU_STA_ID)
Definition: wifi-helper.cc:200
static void PcapSniffTxEvent(Ptr< PcapFileWrapper > file, Ptr< const Packet > packet, uint16_t channelFreqMhz, WifiTxVector txVector, MpduInfo aMpdu, uint16_t staId=SU_STA_ID)
Definition: wifi-helper.cc:166
PcapHelper::DataLinkType GetPcapDataLinkType(void) const
Get the data link type of PCAP traces to be used.
Definition: wifi-helper.cc:537
std::tuple< uint8_t, uint16_t, int, uint8_t > ChannelTuple
Tuple identifying an operating channel.
Definition: wifi-phy.h:833
hold a list of per-remote-station state.
To trace WaveNetDevice, we have to overwrite the trace functions of class YansWifiPhyHelper.
Definition: wave-helper.h:41
static YansWavePhyHelper Default(void)
Create a phy helper in a default working state.
Definition: wave-helper.cc:123
virtual void EnablePcapInternal(std::string prefix, Ptr< NetDevice > nd, bool promiscuous, bool explicitFilename)
Enable pcap output the indicated net device.
Definition: wave-helper.cc:131
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:172
void Connect(std::string path, const CallbackBase &cb)
Definition: config.cc:920
void ConnectWithoutContext(std::string path, const CallbackBase &cb)
Definition: config.cc:901
#define NS_FATAL_ERROR(msg)
Report a fatal error with a message and terminate.
Definition: fatal-error.h:165
#define NS_ABORT_MSG_IF(cond, msg)
Abnormal program termination if a condition is true, with a message.
Definition: abort.h:108
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:205
#define NS_LOG_FUNCTION(parameters)
If log level LOG_FUNCTION is enabled, this macro will output all input parameters separated by ",...
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Definition: log.h:281
Callback< R > MakeBoundCallback(R(*fnPtr)(TX), ARG a1)
Make Callbacks with one bound argument.
Definition: callback.h:1709
WifiPreamble
The type of preamble to be used by an IEEE 802.11 transmission.
@ WIFI_STANDARD_80211p
@ WIFI_PHY_BAND_5GHZ
The 5 GHz band.
Definition: wifi-phy-band.h:37
devices
Definition: first.py:39
Every class exported by the ns3 library is enclosed in the ns3 namespace.
static void AsciiPhyReceiveSinkWithContext(Ptr< OutputStreamWrapper > stream, std::string context, Ptr< const Packet > p, double snr, WifiMode mode, enum WifiPreamble preamble)
ASCII Phy receive sink with context.
Definition: wave-helper.cc:88
static void AsciiPhyReceiveSinkWithoutContext(Ptr< OutputStreamWrapper > stream, Ptr< const Packet > p, double snr, WifiMode mode, enum WifiPreamble preamble)
ASCII Phy receive sink without context.
Definition: wave-helper.cc:109
@ LOG_LEVEL_ALL
Print everything.
Definition: log.h:116
void LogComponentEnable(char const *name, enum LogLevel level)
Enable the logging output associated with that log component.
Definition: log.cc:361
static void AsciiPhyTransmitSinkWithContext(Ptr< OutputStreamWrapper > stream, std::string context, Ptr< const Packet > p, WifiMode mode, WifiPreamble preamble, uint8_t txLevel)
ASCII Phy transmit sink with context.
Definition: wave-helper.cc:46
static void AsciiPhyTransmitSinkWithoutContext(Ptr< OutputStreamWrapper > stream, Ptr< const Packet > p, WifiMode mode, WifiPreamble preamble, uint8_t txLevel)
ASCII Phy transmit sink without context.
Definition: wave-helper.cc:67
mac
Definition: third.py:96
phy
Definition: third.py:93