A Discrete-Event Network Simulator
API
wave-helper.cc
Go to the documentation of this file.
1/*
2 * This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License version 2 as
4 * published by the Free Software Foundation;
5 *
6 * This program is distributed in the hope that it will be useful,
7 * but WITHOUT ANY WARRANTY; without even the implied warranty of
8 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
9 * GNU General Public License for more details.
10 *
11 * You should have received a copy of the GNU General Public License
12 * along with this program; if not, write to the Free Software
13 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
14 *
15 * Author: Junling Bu <linlinjavaer@gmail.com>
16 */
17
18#include "wave-helper.h"
19
20#include "wave-mac-helper.h"
21
22#include "ns3/abort.h"
23#include "ns3/config.h"
24#include "ns3/log.h"
25#include "ns3/minstrel-wifi-manager.h"
26#include "ns3/names.h"
27#include "ns3/pointer.h"
28#include "ns3/qos-txop.h"
29#include "ns3/radiotap-header.h"
30#include "ns3/string.h"
31#include "ns3/wave-net-device.h"
32
33NS_LOG_COMPONENT_DEFINE("WaveHelper");
34
35namespace ns3
36{
37
47static void
49 std::string context,
51 WifiMode mode [[maybe_unused]],
52 WifiPreamble preamble [[maybe_unused]],
53 uint8_t txLevel [[maybe_unused]])
54{
55 NS_LOG_FUNCTION(stream << context << p << mode << preamble << txLevel);
56 *stream->GetStream() << "t " << Simulator::Now().GetSeconds() << " " << context << " " << *p
57 << std::endl;
58}
59
68static void
71 WifiMode mode,
72 WifiPreamble preamble,
73 uint8_t txLevel)
74{
75 NS_LOG_FUNCTION(stream << p << mode << preamble << txLevel);
76 *stream->GetStream() << "t " << Simulator::Now().GetSeconds() << " " << *p << std::endl;
77}
78
88static void
90 std::string context,
92 double snr,
93 WifiMode mode,
94 WifiPreamble preamble)
95{
96 NS_LOG_FUNCTION(stream << context << p << snr << mode << preamble);
97 *stream->GetStream() << "r " << Simulator::Now().GetSeconds() << " " << context << " " << *p
98 << std::endl;
99}
100
109static void
112 double snr,
113 WifiMode mode,
114 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/****************************** YansWavePhyHelper ***********************************/
121YansWavePhyHelper
123{
124 YansWavePhyHelper helper;
125 helper.SetErrorRateModel("ns3::NistErrorRateModel");
126 return helper;
127}
128
129void
132 bool /* promiscuous */,
133 bool explicitFilename)
134{
135 //
136 // All of the Pcap enable functions vector through here including the ones
137 // that are wandering through all of devices on perhaps all of the nodes in
138 // the system. We can only deal with devices of type WaveNetDevice.
139 //
140 Ptr<WaveNetDevice> device = nd->GetObject<WaveNetDevice>();
141 if (!device)
142 {
143 NS_LOG_INFO("YansWavePhyHelper::EnablePcapInternal(): Device "
144 << &device << " not of type ns3::WaveNetDevice");
145 return;
146 }
147
148 std::vector<Ptr<WifiPhy>> phys = device->GetPhys();
149 NS_ABORT_MSG_IF(phys.empty(), "EnablePcapInternal(): Phy layer in WaveNetDevice must be set");
150
151 PcapHelper pcapHelper;
152
153 std::string filename;
154 if (explicitFilename)
155 {
156 filename = prefix;
157 }
158 else
159 {
160 filename = pcapHelper.GetFilenameFromDevice(prefix, device);
161 }
162
164 pcapHelper.CreateFile(filename, std::ios::out, GetPcapDataLinkType());
165
166 std::vector<Ptr<WifiPhy>>::iterator i;
167 for (i = phys.begin(); i != phys.end(); ++i)
168 {
169 Ptr<WifiPhy> phy = (*i);
170 phy->TraceConnectWithoutContext(
171 "MonitorSnifferTx",
173 phy->TraceConnectWithoutContext(
174 "MonitorSnifferRx",
176 }
177}
178
179void
181 std::string prefix,
183 bool explicitFilename)
184{
185 //
186 // All of the ascii enable functions vector through here including the ones
187 // that are wandering through all of devices on perhaps all of the nodes in
188 // the system. We can only deal with devices of type WaveNetDevice.
189 //
190 Ptr<WaveNetDevice> device = nd->GetObject<WaveNetDevice>();
191 if (!device)
192 {
193 NS_LOG_INFO("EnableAsciiInternal(): Device " << device
194 << " not of type ns3::WaveNetDevice");
195 return;
196 }
197
198 //
199 // Our trace sinks are going to use packet printing, so we have to make sure
200 // that is turned on.
201 //
203
204 uint32_t nodeid = nd->GetNode()->GetId();
205 uint32_t deviceid = nd->GetIfIndex();
206 std::ostringstream oss;
207
208 //
209 // If we are not provided an OutputStreamWrapper, we are expected to create
210 // one using the usual trace filename conventions and write our traces
211 // without a context since there will be one file per context and therefore
212 // the context would be redundant.
213 //
214 if (!stream)
215 {
216 //
217 // Set up an output stream object to deal with private ofstream copy
218 // constructor and lifetime issues. Let the helper decide the actual
219 // name of the file given the prefix.
220 //
221 AsciiTraceHelper asciiTraceHelper;
222
223 std::string filename;
224 if (explicitFilename)
225 {
226 filename = prefix;
227 }
228 else
229 {
230 filename = asciiTraceHelper.GetFilenameFromDevice(prefix, device);
231 }
232
233 Ptr<OutputStreamWrapper> theStream = asciiTraceHelper.CreateFileStream(filename);
234 //
235 // We could go poking through the phy and the state looking for the
236 // correct trace source, but we can let Config deal with that with
237 // some search cost. Since this is presumably happening at topology
238 // creation time, it doesn't seem much of a price to pay.
239 //
240 oss.str("");
241 oss << "/NodeList/" << nodeid << "/DeviceList/" << deviceid
242 << "/$ns3::WaveNetDevice/PhyEntities/*/$ns3::WifiPhy/State/RxOk";
244 oss.str(),
246
247 oss.str("");
248 oss << "/NodeList/" << nodeid << "/DeviceList/" << deviceid
249 << "/$ns3::WaveNetDevice/PhyEntities/*/$ns3::WifiPhy/State/Tx";
251 oss.str(),
253
254 return;
255 }
256
257 //
258 // If we are provided an OutputStreamWrapper, we are expected to use it, and
259 // to provide a context. We are free to come up with our own context if we
260 // want, and use the AsciiTraceHelper Hook*WithContext functions, but for
261 // compatibility and simplicity, we just use Config::Connect and let it deal
262 // with coming up with a context.
263 //
264 oss.str("");
265 oss << "/NodeList/" << nodeid << "/DeviceList/" << deviceid
266 << "/$ns3::WaveNetDevice/PhyEntities/*/$ns3::WifiPhy/RxOk";
268
269 oss.str("");
270 oss << "/NodeList/" << nodeid << "/DeviceList/" << deviceid
271 << "/$ns3::WaveNetDevice/PhyEntities/*/$ns3::WifiPhy/State/Tx";
273}
274
275/********************************** WaveHelper ******************************************/
277{
278}
279
281{
282}
283
286{
287 WaveHelper helper;
288 // default 7 MAC entities and single PHY device.
290 helper.CreatePhys(1);
291 helper.SetChannelScheduler("ns3::DefaultChannelScheduler");
292 helper.SetRemoteStationManager("ns3::ConstantRateWifiManager",
293 "DataMode",
294 StringValue("OfdmRate6MbpsBW10MHz"),
295 "ControlMode",
296 StringValue("OfdmRate6MbpsBW10MHz"),
297 "NonUnicastMode",
298 StringValue("OfdmRate6MbpsBW10MHz"));
299 return helper;
300}
301
302void
303WaveHelper::CreateMacForChannel(std::vector<uint32_t> channelNumbers)
304{
305 if (channelNumbers.empty())
306 {
307 NS_FATAL_ERROR("the WAVE MAC entities is at least one");
308 }
309 for (std::vector<uint32_t>::iterator i = channelNumbers.begin(); i != channelNumbers.end(); ++i)
310 {
312 {
313 NS_FATAL_ERROR("the channel number " << (*i) << " is not a valid WAVE channel number");
314 }
315 }
316 m_macsForChannelNumber = channelNumbers;
317}
318
319void
321{
322 if (phys == 0)
323 {
324 NS_FATAL_ERROR("the WAVE PHY entities is at least one");
325 }
327 {
328 NS_FATAL_ERROR("the number of assigned WAVE PHY entities is more than the number of valid "
329 "WAVE channels");
330 }
331 m_physNumber = phys;
332}
333
336 const WifiMacHelper& macHelper,
337 NodeContainer c) const
338{
339 try
340 {
341 const QosWaveMacHelper& qosMac [[maybe_unused]] =
342 dynamic_cast<const QosWaveMacHelper&>(macHelper);
343 }
344 catch (const std::bad_cast&)
345 {
346 NS_FATAL_ERROR("WifiMacHelper should be the class or subclass of QosWaveMacHelper");
347 }
348
350 for (NodeContainer::Iterator i = c.Begin(); i != c.End(); ++i)
351 {
352 Ptr<Node> node = *i;
353 Ptr<WaveNetDevice> device = CreateObject<WaveNetDevice>();
354
355 device->SetChannelManager(CreateObject<ChannelManager>());
356 device->SetChannelCoordinator(CreateObject<ChannelCoordinator>());
357 device->SetVsaManager(CreateObject<VsaManager>());
359
360 for (uint32_t j = 0; j != m_physNumber; ++j)
361 {
362 std::vector<Ptr<WifiPhy>> phys = phyHelper.Create(node, device);
363 NS_ABORT_IF(phys.size() != 1);
364 phys[0]->ConfigureStandard(WIFI_STANDARD_80211p);
365 phys[0]->SetOperatingChannel(
367 device->AddPhy(phys[0]);
368 }
369
370 for (std::vector<uint32_t>::const_iterator k = m_macsForChannelNumber.begin();
371 k != m_macsForChannelNumber.end();
372 ++k)
373 {
374 Ptr<WifiMac> wifiMac = macHelper.Create(device, WIFI_STANDARD_80211p);
375 Ptr<OcbWifiMac> ocbMac = DynamicCast<OcbWifiMac>(wifiMac);
378 ocbMac->EnableForWave(device);
379 device->AddMac(*k, ocbMac);
380 }
381
383
384 node->AddDevice(device);
385 devices.Add(device);
386 }
387 return devices;
388}
389
392{
393 return Install(phy, mac, NodeContainer(node));
394}
395
397WaveHelper::Install(const WifiPhyHelper& phy, const WifiMacHelper& mac, std::string nodeName) const
398{
399 Ptr<Node> node = Names::Find<Node>(nodeName);
400 return Install(phy, mac, NodeContainer(node));
401}
402
403void
405{
407
408 LogComponentEnable("WaveNetDevice", LOG_LEVEL_ALL);
409 LogComponentEnable("ChannelCoordinator", LOG_LEVEL_ALL);
410 LogComponentEnable("ChannelManager", LOG_LEVEL_ALL);
411 LogComponentEnable("ChannelScheduler", LOG_LEVEL_ALL);
412 LogComponentEnable("DefaultChannelScheduler", LOG_LEVEL_ALL);
413 LogComponentEnable("VsaManager", LOG_LEVEL_ALL);
414 LogComponentEnable("OcbWifiMac", LOG_LEVEL_ALL);
415 LogComponentEnable("VendorSpecificAction", LOG_LEVEL_ALL);
416 LogComponentEnable("WaveFrameExchangeManager", LOG_LEVEL_ALL);
417 LogComponentEnable("HigherLayerTxVectorTag", LOG_LEVEL_ALL);
418}
419
420int64_t
422{
423 int64_t currentStream = stream;
424 Ptr<NetDevice> netDevice;
425 for (NetDeviceContainer::Iterator i = c.Begin(); i != c.End(); ++i)
426 {
427 netDevice = (*i);
428 Ptr<WaveNetDevice> wave = DynamicCast<WaveNetDevice>(netDevice);
429 if (wave)
430 {
431 // Handle any random numbers in the PHY objects.
432 std::vector<Ptr<WifiPhy>> phys = wave->GetPhys();
433 for (std::vector<Ptr<WifiPhy>>::iterator j = phys.begin(); j != phys.end(); ++j)
434 {
435 currentStream += (*j)->AssignStreams(currentStream);
436 }
437
438 // Handle any random numbers in the MAC objects.
439 std::map<uint32_t, Ptr<OcbWifiMac>> macs = wave->GetMacs();
440 for (std::map<uint32_t, Ptr<OcbWifiMac>>::iterator k = macs.begin(); k != macs.end();
441 ++k)
442 {
443 // Handle any random numbers in the station managers.
444 Ptr<WifiRemoteStationManager> manager = k->second->GetWifiRemoteStationManager();
445 Ptr<MinstrelWifiManager> minstrel = DynamicCast<MinstrelWifiManager>(manager);
446 if (minstrel)
447 {
448 currentStream += minstrel->AssignStreams(currentStream);
449 }
450
451 PointerValue ptr;
452 k->second->GetAttribute("Txop", ptr);
453 Ptr<Txop> txop = ptr.Get<Txop>();
454 currentStream += txop->AssignStreams(currentStream);
455
456 k->second->GetAttribute("VO_Txop", ptr);
457 Ptr<QosTxop> vo_txop = ptr.Get<QosTxop>();
458 currentStream += vo_txop->AssignStreams(currentStream);
459
460 k->second->GetAttribute("VI_Txop", ptr);
461 Ptr<QosTxop> vi_txop = ptr.Get<QosTxop>();
462 currentStream += vi_txop->AssignStreams(currentStream);
463
464 k->second->GetAttribute("BE_Txop", ptr);
465 Ptr<QosTxop> be_txop = ptr.Get<QosTxop>();
466 currentStream += be_txop->AssignStreams(currentStream);
467
468 k->second->GetAttribute("BK_Txop", ptr);
469 Ptr<QosTxop> bk_txop = ptr.Get<QosTxop>();
470 currentStream += bk_txop->AssignStreams(currentStream);
471 }
472 }
473 }
474 return (currentStream - stream);
475}
476} // namespace ns3
Manage ASCII trace files for device models.
Definition: trace-helper.h:173
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 std::vector< uint32_t > GetWaveChannels()
static uint32_t GetNumberOfWaveChannels()
static uint32_t GetCch()
static bool IsWaveChannel(uint32_t channelNumber)
This class will assign channel access for requests from higher layers.
static Mac48Address Allocate()
Allocate a new Mac48Address.
holds a vector of ns3::NetDevice pointers
std::vector< Ptr< NetDevice > >::const_iterator Iterator
NetDevice container iterator.
Iterator Begin() const
Get an iterator which refers to the first NetDevice in the container.
Iterator End() const
Get an iterator which indicates past-the-last NetDevice in the container.
keep track of a set of node pointers.
std::vector< Ptr< Node > >::const_iterator Iterator
Node container iterator.
Iterator End() const
Get an iterator which indicates past-the-last Node in the container.
Iterator Begin() const
Get an iterator which refers to the first Node in the container.
uint32_t AddDevice(Ptr< NetDevice > device)
Associate a NetDevice to this node.
Definition: node.cc:138
Ptr< Object > Create() const
Create an Object instance of the configured TypeId.
void EnableForWave(Ptr< WaveNetDevice > device)
std::ostream * GetStream()
Return a pointer to an ostream previously set in the wrapper.
static void EnablePrinting()
Enable printing packets metadata.
Definition: packet.cc:596
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:79
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() const
Definition: pointer.h:206
Handle packet fragmentation and retransmissions for QoS data frames as well as MSDU aggregation (A-MS...
Definition: qos-txop.h:73
Qos Wave Mac Helper class.
static Time Now()
Return the current simulation virtual time.
Definition: simulator.cc:199
Hold variables of type string.
Definition: string.h:56
double GetSeconds() const
Get an approximation of the time stored in this instance in the indicated unit.
Definition: nstime.h:402
Handle packet fragmentation and retransmissions for data and management frames.
Definition: txop.h:71
int64_t AssignStreams(int64_t stream)
Assign a fixed random variable stream number to the random variables used by this model.
Definition: txop.cc:536
helps to create WaveNetDevice objects
Definition: wave-helper.h:116
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:421
virtual ~WaveHelper()
Definition: wave-helper.cc:280
std::vector< uint32_t > m_macsForChannelNumber
MACs for channel number.
Definition: wave-helper.h:214
virtual NetDeviceContainer Install(const WifiPhyHelper &phy, const WifiMacHelper &mac, NodeContainer c) const
Definition: wave-helper.cc:335
static void EnableLogComponents()
Helper to enable all WaveNetDevice log components with one statement.
Definition: wave-helper.cc:404
uint32_t m_physNumber
Phy number.
Definition: wave-helper.h:215
void CreateMacForChannel(std::vector< uint32_t > channelNumbers)
Definition: wave-helper.cc:303
void SetChannelScheduler(std::string type, Ts &&... args)
Definition: wave-helper.h:231
void SetRemoteStationManager(std::string type, Ts &&... args)
Definition: wave-helper.h:224
ObjectFactory m_channelScheduler
channel scheduler
Definition: wave-helper.h:213
ObjectFactory m_stationManager
station manager
Definition: wave-helper.h:212
void CreatePhys(uint32_t phys)
Definition: wave-helper.cc:320
static WaveHelper Default()
Definition: wave-helper.cc:285
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 SetAddress(Address address) override
Set the address of this interface.
void SetChannelScheduler(Ptr< ChannelScheduler > channelScheduler)
void SetVsaManager(Ptr< VsaManager > vsaManager)
const std::vector< Ptr< WifiPhy > > & GetPhys() const override
std::map< uint32_t, Ptr< OcbWifiMac > > GetMacs() const
void SetChannelManager(Ptr< ChannelManager > channelManager)
static void EnableLogComponents()
Helper to enable all WifiNetDevice log components with one statement.
Definition: wifi-helper.cc:880
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:852
represent a single transmission mode
Definition: wifi-mode.h:50
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:550
PcapHelper::DataLinkType GetPcapDataLinkType() const
Get the data link type of PCAP traces to be used.
Definition: wifi-helper.cc:562
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:218
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:187
virtual std::vector< Ptr< WifiPhy > > Create(Ptr< Node > node, Ptr< WifiNetDevice > device) const =0
std::tuple< uint8_t, uint16_t, int, uint8_t > ChannelTuple
Tuple identifying an operating channel.
Definition: wifi-phy.h:870
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:42
void EnablePcapInternal(std::string prefix, Ptr< NetDevice > nd, bool promiscuous, bool explicitFilename) override
Enable pcap output the indicated net device.
Definition: wave-helper.cc:130
void EnableAsciiInternal(Ptr< OutputStreamWrapper > stream, std::string prefix, Ptr< NetDevice > nd, bool explicitFilename) override
Enable ascii trace output on the indicated net device.
Definition: wave-helper.cc:180
static YansWavePhyHelper Default()
Create a phy helper in a default working state.
Definition: wave-helper.cc:122
void Connect(std::string path, const CallbackBase &cb)
Definition: config.cc:975
void ConnectWithoutContext(std::string path, const CallbackBase &cb)
Definition: config.cc:951
#define NS_FATAL_ERROR(msg)
Report a fatal error with a message and terminate.
Definition: fatal-error.h:179
#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:76
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:202
#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:275
auto MakeBoundCallback(R(*fnPtr)(Args...), BArgs &&... bargs)
Make Callbacks with varying number of bound arguments.
Definition: callback.h:768
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.
void LogComponentEnable(const std::string &name, LogLevel level)
Enable the logging output associated with that log component.
Definition: log.cc:305
static void AsciiPhyReceiveSinkWithoutContext(Ptr< OutputStreamWrapper > stream, Ptr< const Packet > p, double snr, WifiMode mode, WifiPreamble preamble)
ASCII Phy receive sink without context.
Definition: wave-helper.cc:110
@ LOG_LEVEL_ALL
Print everything.
Definition: log.h:116
static void AsciiPhyReceiveSinkWithContext(Ptr< OutputStreamWrapper > stream, std::string context, Ptr< const Packet > p, double snr, WifiMode mode, WifiPreamble preamble)
ASCII Phy receive sink with context.
Definition: wave-helper.cc:89
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:48
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:69
mac
Definition: third.py:85
phy
Definition: third.py:82