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 //
138 Ptr<WaveNetDevice> device = nd->GetObject<WaveNetDevice> ();
139 if (!device)
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 //
183 Ptr<WaveNetDevice> device = nd->GetObject<WaveNetDevice> ();
184 if (!device)
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)
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
315WaveHelper::Install (const WifiPhyHelper &phyHelper, const WifiMacHelper &macHelper, NodeContainer c) const
316{
317 try
318 {
319 [[maybe_unused]] const QosWaveMacHelper& qosMac = dynamic_cast<const QosWaveMacHelper&> (macHelper);
320 }
321 catch (const std::bad_cast &)
322 {
323 NS_FATAL_ERROR ("WifiMacHelper should be the class or subclass of QosWaveMacHelper");
324 }
325
327 for (NodeContainer::Iterator i = c.Begin (); i != c.End (); ++i)
328 {
329 Ptr<Node> node = *i;
330 Ptr<WaveNetDevice> device = CreateObject<WaveNetDevice> ();
331
332 device->SetChannelManager (CreateObject<ChannelManager> ());
333 device->SetChannelCoordinator (CreateObject<ChannelCoordinator> ());
334 device->SetVsaManager (CreateObject<VsaManager> ());
336
337 for (uint32_t j = 0; j != m_physNumber; ++j)
338 {
339 std::vector<Ptr<WifiPhy>> phys = phyHelper.Create (node, device);
340 NS_ABORT_IF (phys.size () != 1);
341 phys[0]->ConfigureStandard (WIFI_STANDARD_80211p);
342 phys[0]->SetOperatingChannel (WifiPhy::ChannelTuple {ChannelManager::GetCch (), 0,
344 device->AddPhy (phys[0]);
345 }
346
347 for (std::vector<uint32_t>::const_iterator k = m_macsForChannelNumber.begin ();
348 k != m_macsForChannelNumber.end (); ++k)
349 {
350 Ptr<WifiMac> wifiMac = macHelper.Create (device, WIFI_STANDARD_80211p);
351 Ptr<OcbWifiMac> ocbMac = DynamicCast<OcbWifiMac> (wifiMac);
353 ocbMac->EnableForWave (device);
354 device->AddMac (*k, ocbMac);
355 }
356
358
359 node->AddDevice (device);
360 devices.Add (device);
361 }
362 return devices;
363}
364
367{
368 return Install (phy, mac, NodeContainer (node));
369}
370
372WaveHelper::Install (const WifiPhyHelper &phy, const WifiMacHelper &mac, std::string nodeName) const
373{
374 Ptr<Node> node = Names::Find<Node> (nodeName);
375 return Install (phy, mac, NodeContainer (node));
376}
377
378void
380{
382
383 LogComponentEnable ("WaveNetDevice", LOG_LEVEL_ALL);
384 LogComponentEnable ("ChannelCoordinator", LOG_LEVEL_ALL);
385 LogComponentEnable ("ChannelManager", LOG_LEVEL_ALL);
386 LogComponentEnable ("ChannelScheduler", LOG_LEVEL_ALL);
387 LogComponentEnable ("DefaultChannelScheduler", LOG_LEVEL_ALL);
388 LogComponentEnable ("VsaManager", LOG_LEVEL_ALL);
389 LogComponentEnable ("OcbWifiMac", LOG_LEVEL_ALL);
390 LogComponentEnable ("VendorSpecificAction", LOG_LEVEL_ALL);
391 LogComponentEnable ("WaveFrameExchangeManager", LOG_LEVEL_ALL);
392 LogComponentEnable ("HigherLayerTxVectorTag", LOG_LEVEL_ALL);
393}
394
395int64_t
397{
398 int64_t currentStream = stream;
399 Ptr<NetDevice> netDevice;
400 for (NetDeviceContainer::Iterator i = c.Begin (); i != c.End (); ++i)
401 {
402 netDevice = (*i);
403 Ptr<WaveNetDevice> wave = DynamicCast<WaveNetDevice> (netDevice);
404 if (wave)
405 {
406 // Handle any random numbers in the PHY objects.
407 std::vector<Ptr<WifiPhy> > phys = wave->GetPhys ();
408 for (std::vector<Ptr<WifiPhy> >::iterator j = phys.begin (); j != phys.end (); ++j)
409 {
410 currentStream += (*j)->AssignStreams (currentStream);
411 }
412
413 // Handle any random numbers in the MAC objects.
414 std::map<uint32_t, Ptr<OcbWifiMac> > macs = wave->GetMacs ();
415 for ( std::map<uint32_t, Ptr<OcbWifiMac> >::iterator k = macs.begin (); k != macs.end (); ++k)
416 {
417 // Handle any random numbers in the station managers.
418 Ptr<WifiRemoteStationManager> manager = k->second->GetWifiRemoteStationManager ();
419 Ptr<MinstrelWifiManager> minstrel = DynamicCast<MinstrelWifiManager> (manager);
420 if (minstrel)
421 {
422 currentStream += minstrel->AssignStreams (currentStream);
423 }
424
425 PointerValue ptr;
426 k->second->GetAttribute ("Txop", ptr);
427 Ptr<Txop> txop = ptr.Get<Txop> ();
428 currentStream += txop->AssignStreams (currentStream);
429
430 k->second->GetAttribute ("VO_Txop", ptr);
431 Ptr<QosTxop> vo_txop = ptr.Get<QosTxop> ();
432 currentStream += vo_txop->AssignStreams (currentStream);
433
434 k->second->GetAttribute ("VI_Txop", ptr);
435 Ptr<QosTxop> vi_txop = ptr.Get<QosTxop> ();
436 currentStream += vi_txop->AssignStreams (currentStream);
437
438 k->second->GetAttribute ("BE_Txop", ptr);
439 Ptr<QosTxop> be_txop = ptr.Get<QosTxop> ();
440 currentStream += be_txop->AssignStreams (currentStream);
441
442 k->second->GetAttribute ("BK_Txop", ptr);
443 Ptr<QosTxop> bk_txop = ptr.Get<QosTxop> ();
444 currentStream += bk_txop->AssignStreams (currentStream);
445 }
446 }
447 }
448 return (currentStream - stream);
449}
450} // 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.
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.
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 AddDevice(Ptr< NetDevice > device)
Associate a NetDevice to this node.
Definition: node.cc:130
Ptr< Object > Create(void) const
Create an Object instance of the configured TypeId.
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:380
Handle packet fragmentation and retransmissions for data and management frames.
Definition: txop.h:67
int64_t AssignStreams(int64_t stream)
Assign a fixed random variable stream number to the random variables used by this model.
Definition: txop.cc:517
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:396
virtual ~WaveHelper()
Definition: wave-helper.cc:264
std::vector< uint32_t > m_macsForChannelNumber
MACs for channel number.
Definition: wave-helper.h:208
virtual NetDeviceContainer Install(const WifiPhyHelper &phy, const WifiMacHelper &mac, NodeContainer c) const
Definition: wave-helper.cc:315
uint32_t m_physNumber
Phy number.
Definition: wave-helper.h:209
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:379
void SetChannelScheduler(std::string type, Ts &&... args)
Definition: wave-helper.h:224
static WaveHelper Default(void)
Definition: wave-helper.cc:269
void SetRemoteStationManager(std::string type, Ts &&... args)
Definition: wave-helper.h:218
ObjectFactory m_channelScheduler
channel scheduler
Definition: wave-helper.h:207
ObjectFactory m_stationManager
station manager
Definition: wave-helper.h:206
void CreatePhys(uint32_t phys)
Definition: wave-helper.cc:301
This class holds together multiple, ns3::WifiPhy, and ns3::OcbWifiMac (including ns3::WifiRemoteStati...
const std::vector< Ptr< WifiPhy > > & GetPhys(void) const
void AddPhy(Ptr< WifiPhy > phy)
void SetChannelCoordinator(Ptr< ChannelCoordinator > channelCoordinator)
void AddMac(uint32_t channelNumber, Ptr< OcbWifiMac > mac)
void SetChannelScheduler(Ptr< ChannelScheduler > channelScheduler)
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:853
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:804
represent a single transmission mode
Definition: wifi-mode.h:48
create PHY objects
Definition: wifi-helper.h:49
void SetErrorRateModel(std::string type, Args &&... args)
Helper function used to set the error rate model.
Definition: wifi-helper.h:531
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:220
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:186
virtual std::vector< Ptr< WifiPhy > > Create(Ptr< Node > node, Ptr< WifiNetDevice > device) const =0
PcapHelper::DataLinkType GetPcapDataLinkType(void) const
Get the data link type of PCAP traces to be used.
Definition: wifi-helper.cc:557
std::tuple< uint8_t, uint16_t, int, uint8_t > ChannelTuple
Tuple identifying an operating channel.
Definition: wifi-phy.h:839
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_ABORT_IF(cond)
Abnormal program termination if a condition is true.
Definition: abort.h:77
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:206
#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:282
auto MakeBoundCallback(R(*fnPtr)(Args...), BArgs... bargs)
Make Callbacks with varying number of bound arguments.
Definition: callback.h:714
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:35
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:117
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:87
phy
Definition: third.py:84