d4/d99/wifi-80211e-txop_8cc_source.html

/*

 * Copyright (c) 2016 Sébastien Deronne

 *

 * SPDX-License-Identifier: GPL-2.0-only

 *

 * Author: Sébastien Deronne <sebastien.deronne@gmail.com>

 */


#include "ns3/command-line.h"

#include "ns3/internet-stack-helper.h"

#include "ns3/ipv4-address-helper.h"

#include "ns3/log.h"

#include "ns3/mobility-helper.h"

#include "ns3/on-off-helper.h"

#include "ns3/pointer.h"

#include "ns3/qos-txop.h"

#include "ns3/ssid.h"

#include "ns3/string.h"

#include "ns3/udp-client-server-helper.h"

#include "ns3/udp-server.h"

#include "ns3/wifi-mac.h"

#include "ns3/wifi-net-device.h"

#include "ns3/yans-wifi-channel.h"

#include "ns3/yans-wifi-helper.h"


// This is an example that illustrates 802.11 QoS for different Access Categories.

// It defines 4 independent Wi-Fi networks (working on different logical channels

// on the same "ns3::YansWifiPhy" channel object).

// Each network contains one access point and one station. Each station continuously

// transmits data packets to its respective AP.

//

// Network topology (numbers in parentheses are channel numbers):

//

//  BSS A (36)        BSS B (40)       BSS C (44)        BSS D (48)

//   *      *          *      *         *      *          *      *

//   |      |          |      |         |      |          |      |

//  AP A   STA A      AP B   STA B     AP C   STA C      AP D   STA D

//

// The configuration is the following on the 4 networks:

// - STA A sends AC_BE traffic to AP A with default AC_BE TXOP value of 0 (1 MSDU);

// - STA B sends AC_BE traffic to AP B with non-default AC_BE TXOP of 4096 us;

// - STA C sends AC_VI traffic to AP C with default AC_VI TXOP of 4096 us;

// - STA D sends AC_VI traffic to AP D with non-default AC_VI TXOP value of 0 (1 MSDU);

//

// The user can select the distance between the stations and the APs, can enable/disable the RTS/CTS

// mechanism and can choose the payload size and the simulation duration. Example: ./ns3 run

// "wifi-80211e-txop --distance=10 --simulationTime=20s --payloadSize=1000"

//

// The output prints the throughput measured for the 4 cases/networks described above. When TXOP is

// enabled, results show increased throughput since the channel is granted for a longer duration.

// TXOP is enabled by default for AC_VI and AC_VO, so that they can use the channel for a longer

// duration than AC_BE and AC_BK.


using namespace ns3;


NS_LOG_COMPONENT_DEFINE("80211eTxop");


/**

 * Keeps the maximum duration among all TXOPs

 */


struct TxopDurationTracer

{

    /**

     * Callback connected to TXOP duration trace source.

     *

     * \param startTime TXOP start time

     * \param duration TXOP duration

     * \param linkId the ID of the link

     */

    void Trace(Time startTime, Time duration, uint8_t linkId);

    Time m_max{Seconds(0)}; //!< maximum TXOP duration

};


void


TxopDurationTracer::Trace(Time startTime, Time duration, uint8_t linkId)

{

    if (duration > m_max)

    {

        m_max = duration;

    }

}


int

main(int argc, char* argv[])

{

    uint32_t payloadSize{1472}; // bytes

    Time simulationTime{"10s"};

    meter_u distance{5};

    bool enablePcap{false};

    bool verifyResults{false}; // used for regression

    Time txopLimit{"4096us"};


    CommandLine cmd(__FILE__);

    cmd.AddValue("payloadSize", "Payload size in bytes", payloadSize);

    cmd.AddValue("simulationTime", "Simulation time", simulationTime);

    cmd.AddValue("distance",

                 "Distance in meters between the station and the access point",

                 distance);

    cmd.AddValue("enablePcap", "Enable/disable pcap file generation", enablePcap);

    cmd.AddValue("verifyResults",

                 "Enable/disable results verification at the end of the simulation",

                 verifyResults);

    cmd.Parse(argc, argv);


    NodeContainer wifiStaNodes;

    wifiStaNodes.Create(4);

    NodeContainer wifiApNodes;

    wifiApNodes.Create(4);


    YansWifiChannelHelper channel = YansWifiChannelHelper::Default();

    YansWifiPhyHelper phy;

    phy.SetPcapDataLinkType(WifiPhyHelper::DLT_IEEE802_11_RADIO);

    phy.SetChannel(channel.Create());


    WifiHelper wifi;

    wifi.SetStandard(WIFI_STANDARD_80211a);

    wifi.SetRemoteStationManager("ns3::IdealWifiManager");

    WifiMacHelper mac;


    NetDeviceContainer staDeviceA;

    NetDeviceContainer staDeviceB;

    NetDeviceContainer staDeviceC;

    NetDeviceContainer staDeviceD;

    NetDeviceContainer apDeviceA;

    NetDeviceContainer apDeviceB;

    NetDeviceContainer apDeviceC;

    NetDeviceContainer apDeviceD;

    Ssid ssid;


    // Network A

    ssid = Ssid("network-A");

    phy.Set("ChannelSettings", StringValue("{36, 20, BAND_5GHZ, 0}"));

    mac.SetType("ns3::StaWifiMac", "QosSupported", BooleanValue(true), "Ssid", SsidValue(ssid));

    staDeviceA = wifi.Install(phy, mac, wifiStaNodes.Get(0));


    mac.SetType("ns3::ApWifiMac",

                "QosSupported",

                BooleanValue(true),

                "Ssid",

                SsidValue(ssid),

                "EnableBeaconJitter",

                BooleanValue(false));

    apDeviceA = wifi.Install(phy, mac, wifiApNodes.Get(0));


    // Network B

    ssid = Ssid("network-B");

    phy.Set("ChannelSettings", StringValue("{40, 20, BAND_5GHZ, 0}"));

    mac.SetType("ns3::StaWifiMac", "QosSupported", BooleanValue(true), "Ssid", SsidValue(ssid));


    staDeviceB = wifi.Install(phy, mac, wifiStaNodes.Get(1));


    mac.SetType("ns3::ApWifiMac",

                "QosSupported",

                BooleanValue(true),

                "Ssid",

                SsidValue(ssid),

                "EnableBeaconJitter",

                BooleanValue(false));

    apDeviceB = wifi.Install(phy, mac, wifiApNodes.Get(1));


    // Modify EDCA configuration (TXOP limit) for AC_BE

    Ptr<NetDevice> dev = wifiApNodes.Get(1)->GetDevice(0);

    Ptr<WifiNetDevice> wifi_dev = DynamicCast<WifiNetDevice>(dev);

    Ptr<WifiMac> wifi_mac = wifi_dev->GetMac();

    PointerValue ptr;

    Ptr<QosTxop> edca;

    wifi_mac->GetAttribute("BE_Txop", ptr);

    edca = ptr.Get<QosTxop>();

    edca->SetTxopLimit(txopLimit);


    // Trace TXOP duration for BE on STA1

    dev = wifiStaNodes.Get(1)->GetDevice(0);

    wifi_dev = DynamicCast<WifiNetDevice>(dev);

    wifi_mac = wifi_dev->GetMac();

    wifi_mac->GetAttribute("BE_Txop", ptr);

    edca = ptr.Get<QosTxop>();

    TxopDurationTracer beTxopTracer;

    edca->TraceConnectWithoutContext("TxopTrace",

                                     MakeCallback(&TxopDurationTracer::Trace, &beTxopTracer));


    // Network C

    ssid = Ssid("network-C");

    phy.Set("ChannelSettings", StringValue("{44, 20, BAND_5GHZ, 0}"));

    mac.SetType("ns3::StaWifiMac", "QosSupported", BooleanValue(true), "Ssid", SsidValue(ssid));


    staDeviceC = wifi.Install(phy, mac, wifiStaNodes.Get(2));


    mac.SetType("ns3::ApWifiMac",

                "QosSupported",

                BooleanValue(true),

                "Ssid",

                SsidValue(ssid),

                "EnableBeaconJitter",

                BooleanValue(false));

    apDeviceC = wifi.Install(phy, mac, wifiApNodes.Get(2));


    // Trace TXOP duration for VI on STA2

    dev = wifiStaNodes.Get(2)->GetDevice(0);

    wifi_dev = DynamicCast<WifiNetDevice>(dev);

    wifi_mac = wifi_dev->GetMac();

    wifi_mac->GetAttribute("VI_Txop", ptr);

    edca = ptr.Get<QosTxop>();

    TxopDurationTracer viTxopTracer;

    edca->TraceConnectWithoutContext("TxopTrace",

                                     MakeCallback(&TxopDurationTracer::Trace, &viTxopTracer));


    // Network D

    ssid = Ssid("network-D");

    phy.Set("ChannelSettings", StringValue("{48, 20, BAND_5GHZ, 0}"));

    mac.SetType("ns3::StaWifiMac", "QosSupported", BooleanValue(true), "Ssid", SsidValue(ssid));


    staDeviceD = wifi.Install(phy, mac, wifiStaNodes.Get(3));


    mac.SetType("ns3::ApWifiMac",

                "QosSupported",

                BooleanValue(true),

                "Ssid",

                SsidValue(ssid),

                "EnableBeaconJitter",

                BooleanValue(false));

    apDeviceD = wifi.Install(phy, mac, wifiApNodes.Get(3));


    // Modify EDCA configuration (TXOP limit) for AC_VO

    dev = wifiApNodes.Get(3)->GetDevice(0);

    wifi_dev = DynamicCast<WifiNetDevice>(dev);

    wifi_mac = wifi_dev->GetMac();

    wifi_mac->GetAttribute("VI_Txop", ptr);

    edca = ptr.Get<QosTxop>();

    edca->SetTxopLimit(MicroSeconds(0));


    /* Setting mobility model */

    MobilityHelper mobility;

    Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator>();

    mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");


    // Set position for APs

    positionAlloc->Add(Vector(0.0, 0.0, 0.0));

    positionAlloc->Add(Vector(10.0, 0.0, 0.0));

    positionAlloc->Add(Vector(20.0, 0.0, 0.0));

    positionAlloc->Add(Vector(30.0, 0.0, 0.0));

    // Set position for STAs

    positionAlloc->Add(Vector(distance, 0.0, 0.0));

    positionAlloc->Add(Vector(10 + distance, 0.0, 0.0));

    positionAlloc->Add(Vector(20 + distance, 0.0, 0.0));

    positionAlloc->Add(Vector(30 + distance, 0.0, 0.0));

    // Remark: while we set these positions 10 meters apart, the networks do not interact

    // and the only variable that affects transmission performance is the distance.


    mobility.SetPositionAllocator(positionAlloc);

    mobility.Install(wifiApNodes);

    mobility.Install(wifiStaNodes);


    /* Internet stack */

    InternetStackHelper stack;

    stack.Install(wifiApNodes);

    stack.Install(wifiStaNodes);


    Ipv4AddressHelper address;

    address.SetBase("192.168.1.0", "255.255.255.0");

    Ipv4InterfaceContainer StaInterfaceA;

    StaInterfaceA = address.Assign(staDeviceA);

    Ipv4InterfaceContainer ApInterfaceA;

    ApInterfaceA = address.Assign(apDeviceA);


    address.SetBase("192.168.2.0", "255.255.255.0");

    Ipv4InterfaceContainer StaInterfaceB;

    StaInterfaceB = address.Assign(staDeviceB);

    Ipv4InterfaceContainer ApInterfaceB;

    ApInterfaceB = address.Assign(apDeviceB);


    address.SetBase("192.168.3.0", "255.255.255.0");

    Ipv4InterfaceContainer StaInterfaceC;

    StaInterfaceC = address.Assign(staDeviceC);

    Ipv4InterfaceContainer ApInterfaceC;

    ApInterfaceC = address.Assign(apDeviceC);


    address.SetBase("192.168.4.0", "255.255.255.0");

    Ipv4InterfaceContainer StaInterfaceD;

    StaInterfaceD = address.Assign(staDeviceD);

    Ipv4InterfaceContainer ApInterfaceD;

    ApInterfaceD = address.Assign(apDeviceD);


    /* Setting applications */

    uint16_t port = 5001;

    UdpServerHelper serverA(port);

    ApplicationContainer serverAppA = serverA.Install(wifiApNodes.Get(0));

    serverAppA.Start(Seconds(0.0));

    serverAppA.Stop(simulationTime + Seconds(1.0));


    InetSocketAddress destA(ApInterfaceA.GetAddress(0), port);


    OnOffHelper clientA("ns3::UdpSocketFactory", destA);

    clientA.SetAttribute("OnTime", StringValue("ns3::ConstantRandomVariable[Constant=1]"));

    clientA.SetAttribute("OffTime", StringValue("ns3::ConstantRandomVariable[Constant=0]"));

    clientA.SetAttribute("DataRate", StringValue("100000kb/s"));

    clientA.SetAttribute("PacketSize", UintegerValue(payloadSize));

    clientA.SetAttribute("Tos", UintegerValue(0x70)); // AC_BE


    ApplicationContainer clientAppA = clientA.Install(wifiStaNodes.Get(0));

    clientAppA.Start(Seconds(1.0));

    clientAppA.Stop(simulationTime + Seconds(1.0));


    UdpServerHelper serverB(port);

    ApplicationContainer serverAppB = serverB.Install(wifiApNodes.Get(1));

    serverAppB.Start(Seconds(0.0));

    serverAppB.Stop(simulationTime + Seconds(1.0));


    InetSocketAddress destB(ApInterfaceB.GetAddress(0), port);


    OnOffHelper clientB("ns3::UdpSocketFactory", destB);

    clientB.SetAttribute("OnTime", StringValue("ns3::ConstantRandomVariable[Constant=1]"));

    clientB.SetAttribute("OffTime", StringValue("ns3::ConstantRandomVariable[Constant=0]"));

    clientB.SetAttribute("DataRate", StringValue("100000kb/s"));

    clientB.SetAttribute("PacketSize", UintegerValue(payloadSize));

    clientB.SetAttribute("Tos", UintegerValue(0x70)); // AC_BE


    ApplicationContainer clientAppB = clientB.Install(wifiStaNodes.Get(1));

    clientAppB.Start(Seconds(1.0));

    clientAppB.Stop(simulationTime + Seconds(1.0));


    UdpServerHelper serverC(port);

    ApplicationContainer serverAppC = serverC.Install(wifiApNodes.Get(2));

    serverAppC.Start(Seconds(0.0));

    serverAppC.Stop(simulationTime + Seconds(1.0));


    InetSocketAddress destC(ApInterfaceC.GetAddress(0), port);


    OnOffHelper clientC("ns3::UdpSocketFactory", destC);

    clientC.SetAttribute("OnTime", StringValue("ns3::ConstantRandomVariable[Constant=1]"));

    clientC.SetAttribute("OffTime", StringValue("ns3::ConstantRandomVariable[Constant=0]"));

    clientC.SetAttribute("DataRate", StringValue("100000kb/s"));

    clientC.SetAttribute("PacketSize", UintegerValue(payloadSize));

    clientC.SetAttribute("Tos", UintegerValue(0xb8)); // AC_VI


    ApplicationContainer clientAppC = clientC.Install(wifiStaNodes.Get(2));

    clientAppC.Start(Seconds(1.0));

    clientAppC.Stop(simulationTime + Seconds(1.0));


    UdpServerHelper serverD(port);

    ApplicationContainer serverAppD = serverD.Install(wifiApNodes.Get(3));

    serverAppD.Start(Seconds(0.0));

    serverAppD.Stop(simulationTime + Seconds(1.0));


    InetSocketAddress destD(ApInterfaceD.GetAddress(0), port);


    OnOffHelper clientD("ns3::UdpSocketFactory", destD);

    clientD.SetAttribute("OnTime", StringValue("ns3::ConstantRandomVariable[Constant=1]"));

    clientD.SetAttribute("OffTime", StringValue("ns3::ConstantRandomVariable[Constant=0]"));

    clientD.SetAttribute("DataRate", StringValue("100000kb/s"));

    clientD.SetAttribute("PacketSize", UintegerValue(payloadSize));

    clientD.SetAttribute("Tos", UintegerValue(0xb8)); // AC_VI


    ApplicationContainer clientAppD = clientD.Install(wifiStaNodes.Get(3));

    clientAppD.Start(Seconds(1.0));

    clientAppD.Stop(simulationTime + Seconds(1.0));


    if (enablePcap)

    {

        phy.EnablePcap("AP_A", apDeviceA.Get(0));

        phy.EnablePcap("STA_A", staDeviceA.Get(0));

        phy.EnablePcap("AP_B", apDeviceB.Get(0));

        phy.EnablePcap("STA_B", staDeviceB.Get(0));

        phy.EnablePcap("AP_C", apDeviceC.Get(0));

        phy.EnablePcap("STA_C", staDeviceC.Get(0));

        phy.EnablePcap("AP_D", apDeviceD.Get(0));

        phy.EnablePcap("STA_D", staDeviceD.Get(0));

    }


    Simulator::Stop(simulationTime + Seconds(1.0));

    Simulator::Run();


    /* Show results */

    double totalPacketsThroughA = DynamicCast<UdpServer>(serverAppA.Get(0))->GetReceived();

    double totalPacketsThroughB = DynamicCast<UdpServer>(serverAppB.Get(0))->GetReceived();

    double totalPacketsThroughC = DynamicCast<UdpServer>(serverAppC.Get(0))->GetReceived();

    double totalPacketsThroughD = DynamicCast<UdpServer>(serverAppD.Get(0))->GetReceived();


    Simulator::Destroy();


    auto throughput = totalPacketsThroughA * payloadSize * 8 / simulationTime.GetMicroSeconds();

    std::cout << "AC_BE with default TXOP limit (0ms): " << '\n'

              << "  Throughput = " << throughput << " Mbit/s" << '\n';

    if (verifyResults && (throughput < 28 || throughput > 29))

    {

        NS_LOG_ERROR("Obtained throughput " << throughput << " is not in the expected boundaries!");

        exit(1);

    }


    throughput = totalPacketsThroughB * payloadSize * 8 / simulationTime.GetMicroSeconds();

    std::cout << "AC_BE with non-default TXOP limit (4.096ms): " << '\n'

              << "  Throughput = " << throughput << " Mbit/s" << '\n';

    if (verifyResults && (throughput < 36.5 || throughput > 37))

    {

        NS_LOG_ERROR("Obtained throughput " << throughput << " is not in the expected boundaries!");

        exit(1);

    }

    std::cout << "  Maximum TXOP duration = " << beTxopTracer.m_max.GetMicroSeconds() << " us"

              << '\n';

    if (verifyResults &&

        (beTxopTracer.m_max < MicroSeconds(3008) || beTxopTracer.m_max > txopLimit))

    {

        NS_LOG_ERROR("Maximum TXOP duration " << beTxopTracer.m_max

                                              << " is not in the expected boundaries!");

        exit(1);

    }


    throughput = totalPacketsThroughC * payloadSize * 8 / simulationTime.GetMicroSeconds();

    std::cout << "AC_VI with default TXOP limit (4.096ms): " << '\n'

              << "  Throughput = " << throughput << " Mbit/s" << '\n';

    if (verifyResults && (throughput < 36.5 || throughput > 37.5))

    {

        NS_LOG_ERROR("Obtained throughput " << throughput << " is not in the expected boundaries!");

        exit(1);

    }

    std::cout << "  Maximum TXOP duration = " << viTxopTracer.m_max.GetMicroSeconds() << " us"

              << '\n';

    if (verifyResults &&

        (viTxopTracer.m_max < MicroSeconds(3008) || viTxopTracer.m_max > txopLimit))

    {

        NS_LOG_ERROR("Maximum TXOP duration " << viTxopTracer.m_max

                                              << " is not in the expected boundaries!");

        exit(1);

    }


    throughput = totalPacketsThroughD * payloadSize * 8 / simulationTime.GetMicroSeconds();

    std::cout << "AC_VI with non-default TXOP limit (0ms): " << '\n'

              << "  Throughput = " << throughput << " Mbit/s" << '\n';

    if (verifyResults && (throughput < 31.5 || throughput > 32.5))

    {

        NS_LOG_ERROR("Obtained throughput " << throughput << " is not in the expected boundaries!");

        exit(1);

    }


    return 0;

}

double

ns3::ApplicationContainer
holds a vector of ns3::Application pointers.
Definition application-container.h:33

ns3::ApplicationContainer::Start
void Start(Time start) const
Start all of the Applications in this container at the start time given as a parameter.
Definition application-container.cc:81

ns3::ApplicationContainer::Get
Ptr< Application > Get(uint32_t i) const
Get the Ptr<Application> stored in this container at a given index.
Definition application-container.cc:53

ns3::ApplicationContainer::Stop
void Stop(Time stop) const
Arrange for all of the Applications in this container to Stop() at the Time given as a parameter.
Definition application-container.cc:103

ns3::BooleanValue
Definition boolean.h:26

ns3::CommandLine
Parse command-line arguments.
Definition command-line.h:221

ns3::InetSocketAddress
an Inet address class
Definition inet-socket-address.h:31

ns3::InternetStackHelper
aggregate IP/TCP/UDP functionality to existing Nodes.
Definition internet-stack-helper.h:81

ns3::Ipv4AddressHelper
A helper class to make life easier while doing simple IPv4 address assignment in scripts.
Definition ipv4-address-helper.h:38

ns3::Ipv4InterfaceContainer
holds a vector of std::pair of Ptr<Ipv4> and interface index.
Definition ipv4-interface-container.h:45

ns3::Ipv4InterfaceContainer::GetAddress
Ipv4Address GetAddress(uint32_t i, uint32_t j=0) const
Definition ipv4-interface-container.cc:49

ns3::MobilityHelper
Helper class used to assign positions and mobility models to nodes.
Definition mobility-helper.h:33

ns3::NetDeviceContainer
holds a vector of ns3::NetDevice pointers
Definition net-device-container.h:32

ns3::NetDeviceContainer::Get
Ptr< NetDevice > Get(uint32_t i) const
Get the Ptr<NetDevice> stored in this container at a given index.
Definition net-device-container.cc:56

ns3::NodeContainer
keep track of a set of node pointers.
Definition node-container.h:29

ns3::NodeContainer::Create
void Create(uint32_t n)
Create n nodes and append pointers to them to the end of this NodeContainer.
Definition node-container.cc:73

ns3::NodeContainer::Get
Ptr< Node > Get(uint32_t i) const
Get the Ptr<Node> stored in this container at a given index.
Definition node-container.cc:67

ns3::Node::GetDevice
Ptr< NetDevice > GetDevice(uint32_t index) const
Retrieve the index-th NetDevice associated to this node.
Definition node.cc:138

ns3::OnOffHelper
A helper to make it easier to instantiate an ns3::OnOffApplication on a set of nodes.
Definition on-off-helper.h:26

ns3::PointerValue
AttributeValue implementation for Pointer.

ns3::PointerValue::Get
Ptr< T > Get() const
Definition pointer.h:223

ns3::Ptr
Smart pointer class similar to boost::intrusive_ptr.
Definition mpi-test-fixtures.h:37

ns3::QosTxop
Handles the packet queue and stores DCF/EDCA access parameters (one Txop per AC).
Definition qos-txop.h:52

ns3::Simulator::Destroy
static void Destroy()
Execute the events scheduled with ScheduleDestroy().
Definition simulator.cc:131

ns3::Simulator::Run
static void Run()
Run the simulation.
Definition simulator.cc:167

ns3::Simulator::Stop
static void Stop()
Tell the Simulator the calling event should be the last one executed.
Definition simulator.cc:175

ns3::Ssid
The IEEE 802.11 SSID Information Element.
Definition ssid.h:25

ns3::SsidValue
Definition ssid.h:85

ns3::StringValue
Hold variables of type string.
Definition string.h:45

ns3::Time
Simulation virtual time values and global simulation resolution.
Definition nstime.h:94

ns3::UdpServerHelper
Create a server application which waits for input UDP packets and uses the information carried into t...
Definition udp-client-server-helper.h:28

ns3::UintegerValue
Hold an unsigned integer type.
Definition uinteger.h:34

ns3::WifiHelper
helps to create WifiNetDevice objects
Definition wifi-helper.h:392

ns3::WifiMacHelper
create MAC layers for a ns3::WifiNetDevice.
Definition wifi-mac-helper.h:40

ns3::WifiPhyHelper::DLT_IEEE802_11_RADIO
@ DLT_IEEE802_11_RADIO
Include Radiotap link layer information.
Definition wifi-helper.h:168

ns3::YansWifiChannelHelper
manage and create wifi channel objects for the YANS model.
Definition yans-wifi-helper.h:28

ns3::YansWifiChannelHelper::Default
static YansWifiChannelHelper Default()
Create a channel helper in a default working state.
Definition yans-wifi-helper.cc:33

ns3::YansWifiPhyHelper
Make it easy to create and manage PHY objects for the YANS model.
Definition yans-wifi-helper.h:109

uint32_t

port
uint16_t port
Definition dsdv-manet.cc:33

NS_LOG_ERROR
#define NS_LOG_ERROR(msg)
Use NS_LOG to output a message of level LOG_ERROR.
Definition log.h:243

NS_LOG_COMPONENT_DEFINE
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition log.h:191

ns3::CreateObject
Ptr< T > CreateObject(Args &&... args)
Create an object by type, with varying number of constructor parameters.
Definition object.h:619

ns3::MicroSeconds
Time MicroSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition nstime.h:1332

ns3::Seconds
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition nstime.h:1308

ns3::WIFI_STANDARD_80211a
@ WIFI_STANDARD_80211a
Definition wifi-standards.h:31

first.address
address
Definition first.py:36

first.stack
stack
Definition first.py:33

ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.

ns3::MakeCallback
Callback< R, Args... > MakeCallback(R(T::*memPtr)(Args...), OBJ objPtr)
Build Callbacks for class method members which take varying numbers of arguments and potentially retu...
Definition callback.h:684

ns3::DynamicCast
Ptr< T1 > DynamicCast(const Ptr< T2 > &p)
Cast a Ptr.
Definition ptr.h:580

second.cmd
cmd
Definition second.py:29

third.ssid
ssid
Definition third.py:82

third.channel
channel
Definition third.py:77

third.mac
mac
Definition third.py:81

third.wifi
wifi
Definition third.py:84

third.mobility
mobility
Definition third.py:92

third.wifiStaNodes
wifiStaNodes
Definition third.py:73

third.phy
phy
Definition third.py:78

TxopDurationTracer
Keeps the maximum duration among all TXOPs.
Definition wifi-80211e-txop.cc:62

TxopDurationTracer::Trace
void Trace(Time startTime, Time duration, uint8_t linkId)
Callback connected to TXOP duration trace source.
Definition wifi-80211e-txop.cc:75

TxopDurationTracer::m_max
Time m_max
maximum TXOP duration
Definition wifi-80211e-txop.cc:71

throughput
std::ofstream throughput
Definition tcp-bbr-example.cc:58