The following sample code illustrates a typical configuration using mostly

default values in the simulator, and infrastructure mode::

  NodeContainer wifiStaNode;

  wifiStaNode.Create (10);   // Create 10 station node objects

  NodeContainer wifiApNode;

  wifiApNode.Create (1);   // Create 1 access point node object

  // Create a channel helper and phy helper, and then create the channel

  YansWifiChannelHelper channel = YansWifiChannelHelper::Default ();

  YansWifiPhyHelper phy = YansWifiPhyHelper::Default ();

  phy.SetChannel (channel.Create ());

  // Create a WifiMacHelper, which is reused across STA and AP configurations

  WifiMacHelper mac;

  // Create a WifiHelper, which will use the above helpers to create

  // and install Wifi devices.  Configure a Wifi standard to use, which

  // will align various parameters in the Phy and Mac to standard defaults.

  WifiHelper wifi;

  wifi.SetStandard (WIFI_PHY_STANDARD_80211n_5GHZ);

  // Declare NetDeviceContainers to hold the container returned by the helper

  NetDeviceContainer wifiStaDevices;

  NetDeviceContainer wifiApDevice;

  // Perform the installation

  mac.SetType ("ns3::StaWifiMac");

  wifiStaDevices = wifi.Install (phy, mac, wifiStaNodes);

  mac.SetType ("ns3::ApWifiMac");

  wifiApDevice = wifi.Install (phy, mac, wifiApNode);

At this point, the 11 nodes have Wi-Fi devices configured, attached to a 

common channel.  The rest of this section describes how additional 

configuration may be performed.

Channel, frequency, and channel width configuration

===================================================

There are a few ``ns3::WifiPhy`` parameters that are related, and cannot

be set completely independently, concerning the frequency and channel width

that the device is tuned to.  These are:

* ``WifiPhyStandard``:  For example, 802.11b, 802.11n, etc.

* ``Frequency``

* ``ChannelWidth``

* ``ChannelNumber``

It is possible to set the above to incompatible combinations (e.g. channel

number 1 with 40 MHz channel width on frequency 4915 MHz).  In addition,

the latter three values above are attributes; it is possible to set them

in a number of ways:

* by setting global configuration default; e.g.

::

  Config::SetDefault ("ns3::WifiPhy::ChannelNumber", UintegerValue (3));

* by setting an attribute value in the helper; e.g.

::

  YansWifiPhyHelper wifiPhyHelper = YansWifiPhyHelper::Default ();

  wifiPhyHelper.Set ("ChannelNumber", UintegerValue (3));

* by setting the WifiHelper::SetStandard (enum WifiPhyStandard) method; and

* by performing post-installation configuration of the option, either

  via a Ptr to the WifiPhy object, or through the Config namespace; e.g.:

::

  Config::Set ("/NodeList/0/DeviceList/*/$ns3::WifiNetDevice/Phy/$ns3::WifiPhy/ChannelNumber", UintegerValue (3));

This section provides guidance on how to configure these settings in

a coherent manner, and what happens if non-standard values are chosen.

WifiHelper::SetStandard()

+++++++++++++++++++++++++

``WifiHelper::SetStandard ()`` is a method to set various parameters

in the Mac and Phy to standard values and some reasonable defaults.

For example, ``SetStandard (WIFI_PHY_STANDARD_80211a)`` will set the

WifiPhy to Channel 36 in the 5 GHz band, among other settings.

The following values for WifiPhyStandard are defined in 

``src/wifi/model/wifi-phy-standard.h``:

::

  /** OFDM PHY for the 5 GHz band (Clause 17) */

  WIFI_PHY_STANDARD_80211a,

  /** DSSS PHY (Clause 15) and HR/DSSS PHY (Clause 18) */

  WIFI_PHY_STANDARD_80211b,

  /** ERP-OFDM PHY (Clause 19, Section 19.5) */

  WIFI_PHY_STANDARD_80211g,

  /** OFDM PHY for the 5 GHz band (Clause 17 with 10 MHz channel bandwidth) */

  WIFI_PHY_STANDARD_80211_10MHZ,

  /** OFDM PHY for the 5 GHz band (Clause 17 with 5 MHz channel bandwidth) */

  WIFI_PHY_STANDARD_80211_5MHZ,

  /** This is intended to be the configuration used in this paper:

   *  Gavin Holland, Nitin Vaidya and Paramvir Bahl, "A Rate-Adaptive

   *  MAC Protocol for Multi-Hop Wireless Networks", in Proc. of

   *  ACM MOBICOM, 2001.

   */

  WIFI_PHY_STANDARD_holland,

  /** HT OFDM PHY for the 2.4 GHz band (clause 20) */

  WIFI_PHY_STANDARD_80211n_2_4GHZ,

  /** HT OFDM PHY for the 5 GHz band (clause 20) */

  WIFI_PHY_STANDARD_80211n_5GHZ,

  /** VHT OFDM PHY (clause 22) */

  WIFI_PHY_STANDARD_80211ac

In addition, a value WIFI_PHY_STANDARD_UNSPECIFIED is defined to indicate

that the user has not set a standard.

By default, the WifiPhy will be initialized to WIFI_PHY_STANDARD_UNSPECIFIED,

when it is created directly by ``CreateObject`` (i.e. not by WifiHelper).

However, the WifiHelper (the typical use case for WifiPhy creation) will 

configure the WIFI_PHY_STANDARD_80211a standard by default.  Other values 

for standards should be passed explicitly to the WifiHelper object.

If user has not already separately configured Frequency or ChannelNumber

when SetStandard is called, the user obtains default values, in addition

(e.g. channel 1 for 802.11b/g, or channel 36 for a/n), in addition to

an appropriate ChannelWidth value for the standard (typically, 20 MHz, but

80 MHz for 802.11ac).

WifiPhy attribute interactions

++++++++++++++++++++++++++++++

Users should keep in mind that the two attributes that matter most

within the model code are ``WifiPhy::Frequency`` and 

``WifiPhy::ChannelWidth``; these are the ones directly used to set

transmission parameters.  ``WifiPhy::ChannelNumber`` and 

``WifiHelper::SetStandard ()`` are convenience shorthands for setting

frequency and channel width.  The ``ns3::WifiPhy`` contains code to

keep these values aligned and to generate runtime errors in some cases

if users set these attributes to incompatible values.

The pair (WifiPhyStandard, ChannelNumber) is an alias for a pair of 

(Frequency/ChannelWidth) items.  Valid combinations are stored in 

a map within WifiPhy that is populated with well-known values but that

can be dynamically extended at runtime.  

WifiPhy::Frequency

++++++++++++++++++

The WifiPhy channel center frequency is set by the attribute ``Frequency``

in the class ``WifiPhy``.  It is expressed in units of MHz.  By default,

this attribute is set to the value 0 to indicate that no value is configured.

Note that this is a change in definition from ns-3.25 and earlier releases,

where this attribute referred to the start of the overall frequency band

on which the channel resides, not the specific channel center frequency.

WifiPhy::ChannelWidth

+++++++++++++++++++++

The WifiPhy channel width is set by the attribute ``ChannelWidth``

in the class ``WifiPhy``.  It is expressed in units of MHz.  By default,

this attribute is set to the value 20.  Allowable values are 5, 10, 20,

22, 40, 80, or 160 (MHz).

WifiPhy::ChannelNumber

++++++++++++++++++++++

Several channel numbers are defined and well-known in practice.  However,

valid channel numbers vary by geographical region around the world, and

there is some overlap between the different standards.

In |ns3|, the class ``WifiPhy`` contains an attribute ``ChannelNumber`` that

is, by default, set to the value 0.  The value 0 indicates that no

channel number has been set by the user.

In |ns3|, a ChannelNumber may be defined or unknown.  These terms

are not found in the code; they are just used to describe behavoir herein.

If a ChannelNumber is defined, it means that WifiPhy has stored a

map of ChannelNumber to the center frequency and channel width commonly

known for that channel in practice.  For example:

* Channel 1, when IEEE 802.11b is configured, corresponds to a channel

  width of 22 MHz and a center frequency of 2412 MHz.  

* Channel 36, when IEEE 802.11n is configured at 5GHz, corresponds to 

  a channel width of 20 MHz and a center frequency of 5180 MHz.  

The following channel numbers are well-defined for 2.4 GHz standards:

* channels 1-14 with ChannelWidth of 22 MHz for 802.11b

* channels 1-14 with ChannelWidth of 20 MHz for 802.11n-2.4GHz and 802.11g

The following channel numbers are well-defined for 5 GHz standards:

+------------------+-------------------------------------------+

| ``ChannelWidth`` | ``ChannelNumber``                         |

+------------------+-------------------------------------------+

| 20 MHz           | 36, 40, 44, 48, 52, 56, 60, 64, 100,      |

|                  | 104, 108, 112, 116, 120, 124,             |

|                  | 128, 132, 136, 140, 144,                  |

|                  | 149, 153, 161, 165, 169                   |

+------------------+-------------------------------------------+

| 40 MHz           | 38, 46, 54, 62, 102, 110, 118, 126,       |

|                  | 134, 142, 151, 159                        |

+------------------+-------------------------------------------+

| 80 MHz           | 42, 58, 106, 122, 138, 155                |

+------------------+-------------------------------------------+

| 160 MHz          | 50, 114                                   |

+------------------+-------------------------------------------+

| 10 MHz (802.11p) | 172, 174, 176, 178, 180, 182, 184         |

+------------------+-------------------------------------------+

The channel number may be set either before or after creation of the

WifiPhy object.  

If an unknown channel number (other than zero) is configured, the

simulator will exit with an error; for instance, such as:

::

  Ptr<WifiPhy> wifiPhy = ...;

  wifiPhy->SetAttribute ("ChannelNumber", UintegerValue (1321));

The known channel numbers are defined in the implementation file

``src/wifi/model/wifi-phy.cc``.  Of course, this file may be edited

by users to extend to additional channel numbers.  Below, we describe 

how new channel numbers may be defined dynamically at run-time.

If a known channel number is configured against an incorrect value

of the WifiPhyStandard, the simulator will exit with an error; for instance,

such as:

::

  WifiHelper wifi;

  wifi.SetStandard (WIFI_PHY_STANDARD_80211n_5GHZ);

  ...

  Ptr<WifiPhy> wifiPhy = ...;

  wifiPhy->SetAttribute ("ChannelNumber", UintegerValue (14));

In the above, while channel number 14 is well-defined in practice for 802.11b

only, it is for 2.4 GHz band, not 5 GHz band.

Defining a new channel number

+++++++++++++++++++++++++++++

Users may define their own channel number so that they can later refer to

the channel by number.  

The method is ``WifiPhy::DefineChannelNumber ()`` and it takes the following

arguments:

* uint16_t channelNumber

* enum WifiPhyStandard standard

* uint32_t frequency

* uint32_t channelWidth

The pair of (channelNumber, standard) are used as an index to a map that

returns a Frequency and ChannelWidth.  By calling this method, one can

dynamically add members to the map.  For instance, let's suppose that you

previously configured WIFI_PHY_STANDARD_80211a, and wanted to deine a new

channel number '34' of width 20 MHz and at center frequency 5160 MHz.

If you try to simply configure ChannelNumber to the value 34, it will fail,

since 34 is undefined.  However, you can use DefineChannelNumber as follows:

::

  Ptr<WifiPhy> wifiPhy = ...;

  wifiPhy->DefineChannelNumber (34, WIFI_PHY_STANDARD_80211a, 5160, 20);

and then later you can refer to channel number 34 in your program, which

will configure a center operating frequency of 5160 MHz and a width of

20 MHz.

The steps can be repeated to explicitly configure the same channel for

multiple standards:

::

  wifiPhy->DefineChannelNumber (34, WIFI_PHY_STANDARD_80211a, 5160, 20);

  wifiPhy->DefineChannelNumber (34, WIFI_PHY_STANDARD_80211n_5GHZ, 5160, 20);

or for a wildcard, unspecified standard:

::

  wifiPhy->DefineChannelNumber (34, WIFI_PHY_STANDARD_UNSPECIFIED, 5160, 20);

Order of operation issues

+++++++++++++++++++++++++

Depending on the default values used and the order of operation in setting

the values for the standard, channel width, frequency, and channel number,

different configurations can be obtained.   Below are some common use cases.

* **(accepting the standard defaults):**  If a user has not already 

  separately configured frequency or channel number when 

  ``WifiHelper::SetStandard ()`` is called, the user gets default values 

  (e.g. channel 1 for 802.11b/g or channel 36 for a/n, with 20 MHz 

  channel widths)

* **(overwriting the standard channel):**  If the user has previously 

  configured (e.g. via SetDefault) either frequency or channel number when 

  SetStandard is called, and the frequency or channel number are appropriate 

  for the standard being configured, they are not overwritten

* **(changing the standard channel after Install):**  The user may also call

  ``WifiHelper::SetStandard ()`` after ``Install ()`` and either configure

  the frequency to something different, or configure the channel number

  to something different.  Note that if the channel number is undefined

  for the standard that was previously set, an error will occur.  

* **(changing to non-standard frequency):**  If the user configures a 

  frequency outside the standardized frequency range for the current 

  WifiPhyStandard, this is OK.  This allows users to experiment with 

  wifi on e.g. whitespace frequencies but still use SetStandard to set 

  all of the other configuration details.

* **(interaction between channel number and frequency):**  If the user 

  the user sets Frequency to a different value than the currently configured

  ChannelNumber (or if ChannelNumber is zero), then the ChannelNumber is 

  set to a new channel number if known, or to zero if unknown. 

  * *example:*  ChannelNumber previously set to 36, user sets Frequency to 5200, then ChannelNumber gets automatically set to 40

  * *example:*  ChannelNumber set to 36, user later sets Frequency to 5185, ChannelNumber gets reset to 0

In summary, ChannelNumber and Frequency follow each other.  ChannelNumber

sets both Frequency and ChannelWidth if the channel number has been defined

for the standard.  Setting ChannelWidth has no effect on Frequency or

ChannelNumber.  Setting Frequency will set ChannelNumber to either the

defined value for that Wi-Fi standard, or to the value 0 if undefined.

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * Copyright (c) 2016 Tom Henderson

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 * Author: Tom Henderson <tomh@tomh.org>

 */

#include <string>

#include "ns3/core-module.h"

#include "ns3/config-store-module.h"

#include "ns3/network-module.h"

#include "ns3/wifi-module.h"

// This example shows (and tests) some possible configurations for

// the Wi-Fi physical layer, particularly the interaction between

// WifiHelper.SetStandard () and the physical layer channel number,

// center frequency, and channel width.

using namespace ns3;

NS_LOG_COMPONENT_DEFINE ("WifiPhyConfigurationExample");

Ptr<YansWifiPhy>

GetYansWifiPhyPtr (const NetDeviceContainer &nc)

{

  Ptr<WifiNetDevice> wnd = nc.Get (0)->GetObject<WifiNetDevice> ();

  Ptr<WifiPhy> wp = wnd->GetPhy ();

  return wp->GetObject<YansWifiPhy> ();

}

void

PrintAttributesIfEnabled (bool enabled)

{

  if (enabled)

    {

      ConfigStore outputConfig;

      outputConfig.ConfigureAttributes ();

    }

}

int main (int argc, char *argv[])

{

  uint32_t testCase = 0;

  bool printAttributes = false;

  CommandLine cmd;

  cmd.AddValue ("testCase", "Test case", testCase);

  cmd.AddValue ("printAttributes", "If true, print out attributes", printAttributes);

  cmd.Parse (argc, argv);

  NodeContainer wifiStaNode;

  wifiStaNode.Create (1);

  NodeContainer wifiApNode;

  wifiApNode.Create (1);

  YansWifiChannelHelper channel = YansWifiChannelHelper::Default ();

  YansWifiPhyHelper phy = YansWifiPhyHelper::Default ();

  phy.SetChannel (channel.Create ());

  WifiHelper wifi;

  // Configure and declare other generic components of this example

  Ssid ssid;

  ssid = Ssid ("wifi-phy-configuration");

  WifiMacHelper macSta;

  macSta.SetType ("ns3::StaWifiMac",

                  "Ssid", SsidValue (ssid),

                  "ActiveProbing", BooleanValue (false));

  WifiMacHelper macAp;

  macAp.SetType ("ns3::ApWifiMac",

                 "Ssid", SsidValue (ssid),

                 "BeaconInterval", TimeValue (MicroSeconds (102400)),

                 "BeaconGeneration", BooleanValue (true));

  NetDeviceContainer staDevice;

  NetDeviceContainer apDevice;

  Ptr<YansWifiPhy> phySta;

  Config::SetDefault ("ns3::ConfigStore::Filename", StringValue ("output-attributes-" + std::to_string (testCase) + ".txt"));

  Config::SetDefault ("ns3::ConfigStore::FileFormat", StringValue ("RawText"));

  Config::SetDefault ("ns3::ConfigStore::Mode", StringValue ("Save"));

  switch (testCase)

  {

    case 0:

      // Default configuration, without WifiHelper::SetStandard or WifiHelper

      phySta = CreateObject<YansWifiPhy> ();

      // The default results in an invalid configuration of channel 0,

      // width 20, and frequency 0 MHz

      NS_ASSERT (phySta->GetChannelNumber () == 0);

      NS_ASSERT (phySta->GetChannelWidth () == 20);

      NS_ASSERT (phySta->GetFrequency () == 0);

      PrintAttributesIfEnabled (printAttributes);

      break;

    // The following cases test the setting of WifiPhyStandard alone;

    // i.e. without further channel number/width/frequency configuration

    case 1:

      // By default, WifiHelper will use WIFI_PHY_STANDARD_80211a

      staDevice = wifi.Install (phy, macSta, wifiStaNode.Get(0));

      apDevice = wifi.Install (phy, macAp, wifiApNode.Get(0));

      phySta = GetYansWifiPhyPtr (staDevice);

      // We expect channel 36, width 20, frequency 5180

      NS_ASSERT (phySta->GetChannelNumber () == 36);

      NS_ASSERT (phySta->GetChannelWidth () == 20);

      NS_ASSERT (phySta->GetFrequency () == 5180);

      PrintAttributesIfEnabled (printAttributes);

      break;

    case 2:

      wifi.SetStandard (WIFI_PHY_STANDARD_80211b);

      staDevice = wifi.Install (phy, macSta, wifiStaNode.Get(0));

      apDevice = wifi.Install (phy, macAp, wifiApNode.Get(0));

      phySta = GetYansWifiPhyPtr (staDevice);

      // We expect channel 1, width 22, frequency 2412

      NS_ASSERT (phySta->GetChannelNumber () == 1);

      NS_ASSERT (phySta->GetChannelWidth () == 22);

      NS_ASSERT (phySta->GetFrequency () == 2412);

      PrintAttributesIfEnabled (printAttributes);

      break;

    case 3:

      wifi.SetStandard (WIFI_PHY_STANDARD_80211g);

      staDevice = wifi.Install (phy, macSta, wifiStaNode.Get(0));

      apDevice = wifi.Install (phy, macAp, wifiApNode.Get(0));

      phySta = GetYansWifiPhyPtr (staDevice);

      // We expect channel 1, width 20, frequency 2412

      NS_ASSERT (phySta->GetChannelNumber () == 1);

      NS_ASSERT (phySta->GetChannelWidth () == 20);

      NS_ASSERT (phySta->GetFrequency () == 2412);

      PrintAttributesIfEnabled (printAttributes);

      break;

    case 4:

      wifi.SetStandard (WIFI_PHY_STANDARD_80211n_5GHZ);

      staDevice = wifi.Install (phy, macSta, wifiStaNode.Get(0));

      apDevice = wifi.Install (phy, macAp, wifiApNode.Get(0));

      phySta = GetYansWifiPhyPtr (staDevice);

      // We expect channel 36, width 20, frequency 5180

      NS_ASSERT (phySta->GetChannelNumber () == 36);

      NS_ASSERT (phySta->GetChannelWidth () == 20);

      NS_ASSERT (phySta->GetFrequency () == 5180);

      PrintAttributesIfEnabled (printAttributes);

      break;

    case 5:

      wifi.SetStandard (WIFI_PHY_STANDARD_80211n_2_4GHZ);

      staDevice = wifi.Install (phy, macSta, wifiStaNode.Get(0));

      apDevice = wifi.Install (phy, macAp, wifiApNode.Get(0));

      phySta = GetYansWifiPhyPtr (staDevice);

      // We expect channel 1, width 20, frequency 2412

      NS_ASSERT (phySta->GetChannelNumber () == 1);

      NS_ASSERT (phySta->GetChannelWidth () == 20);

      NS_ASSERT (phySta->GetFrequency () == 2412);

      PrintAttributesIfEnabled (printAttributes);

      break;

    case 6:

      wifi.SetStandard (WIFI_PHY_STANDARD_80211ac);

      staDevice = wifi.Install (phy, macSta, wifiStaNode.Get(0));

      apDevice = wifi.Install (phy, macAp, wifiApNode.Get(0));

      phySta = GetYansWifiPhyPtr (staDevice);

      // We expect channel 42, width 80, frequency 5210

      NS_ASSERT (phySta->GetChannelNumber () == 42);

      NS_ASSERT (phySta->GetChannelWidth () == 80);

      NS_ASSERT (phySta->GetFrequency () == 5210);

      PrintAttributesIfEnabled (printAttributes);

      break;

    case 7:

      wifi.SetStandard (WIFI_PHY_STANDARD_80211_10MHZ);

      staDevice = wifi.Install (phy, macSta, wifiStaNode.Get(0));

      apDevice = wifi.Install (phy, macAp, wifiApNode.Get(0));

      phySta = GetYansWifiPhyPtr (staDevice);

      // We expect channel 172, width 10, frequency 5860

      NS_ASSERT (phySta->GetChannelNumber () == 172);

      NS_ASSERT (phySta->GetChannelWidth () == 10);

      NS_ASSERT (phySta->GetFrequency () == 5860);

      PrintAttributesIfEnabled (printAttributes);

      break;

    case 8:

      wifi.SetStandard (WIFI_PHY_STANDARD_80211_5MHZ);

      staDevice = wifi.Install (phy, macSta, wifiStaNode.Get(0));

      apDevice = wifi.Install (phy, macAp, wifiApNode.Get(0));

      phySta = GetYansWifiPhyPtr (staDevice);

      // We expect channel 0, width 5, frequency 5860

      // Channel 0 because 5MHz channels are not officially defined

      NS_ASSERT (phySta->GetChannelNumber () == 0);

      NS_ASSERT (phySta->GetChannelWidth () == 5);

      NS_ASSERT (phySta->GetFrequency () == 5860);

      PrintAttributesIfEnabled (printAttributes);

      break;

    case 9:

      wifi.SetStandard (WIFI_PHY_STANDARD_holland);

      staDevice = wifi.Install (phy, macSta, wifiStaNode.Get(0));

      apDevice = wifi.Install (phy, macAp, wifiApNode.Get(0));

      phySta = GetYansWifiPhyPtr (staDevice);

      // We expect channel 36, width 20, frequency 5180

      NS_ASSERT (phySta->GetChannelNumber () == 36);

      NS_ASSERT (phySta->GetChannelWidth () == 20);

      NS_ASSERT (phySta->GetFrequency () == 5180);

      PrintAttributesIfEnabled (printAttributes);

      break;

    case 10:

      wifi.SetStandard (WIFI_PHY_STANDARD_80211n_5GHZ);

      phy.Set ("ChannelNumber", UintegerValue(44));

      staDevice = wifi.Install (phy, macSta, wifiStaNode.Get(0));

      apDevice = wifi.Install (phy, macAp, wifiApNode.Get(0));

      phySta = GetYansWifiPhyPtr (staDevice);

      // We expect channel 44, width 20, frequency 5220

      NS_ASSERT (phySta->GetChannelNumber () == 44);

      NS_ASSERT (phySta->GetChannelWidth () == 20);

      NS_ASSERT (phySta->GetFrequency () == 5220);

      PrintAttributesIfEnabled (printAttributes);

      break;

    case 11:

      wifi.SetStandard (WIFI_PHY_STANDARD_80211n_5GHZ);

      phy.Set ("ChannelNumber", UintegerValue(44));

      staDevice = wifi.Install (phy, macSta, wifiStaNode.Get(0));

      apDevice = wifi.Install (phy, macAp, wifiApNode.Get(0));

      phySta = GetYansWifiPhyPtr (staDevice);

      // Post-install reconfiguration to channel number 40

      Config::Set ("/NodeList/0/DeviceList/*/$ns3::WifiNetDevice/Phy/$ns3::YansWifiPhy/ChannelNumber", UintegerValue(40));

      Config::Set ("/NodeList/1/DeviceList/*/$ns3::WifiNetDevice/Phy/$ns3::YansWifiPhy/ChannelNumber", UintegerValue(40));

      // We expect channel 40, width 20, frequency 5200

      NS_ASSERT (phySta->GetChannelNumber () == 40);

      NS_ASSERT (phySta->GetChannelWidth () == 20);

      NS_ASSERT (phySta->GetFrequency () == 5200);

      PrintAttributesIfEnabled (printAttributes);

      break;

    case 12:

      wifi.SetStandard (WIFI_PHY_STANDARD_80211n_5GHZ);

      phy.Set ("ChannelNumber", UintegerValue (44));

      staDevice = wifi.Install (phy, macSta, wifiStaNode.Get(0));

      apDevice = wifi.Install (phy, macAp, wifiApNode.Get(0));

      phySta = GetYansWifiPhyPtr (staDevice);

      // Post-install reconfiguration to channel width 40 MHz

      Config::Set ("/NodeList/0/DeviceList/*/$ns3::WifiNetDevice/Phy/$ns3::YansWifiPhy/ChannelWidth", UintegerValue(40));

      Config::Set ("/NodeList/1/DeviceList/*/$ns3::WifiNetDevice/Phy/$ns3::YansWifiPhy/ChannelWidth", UintegerValue(40));

      // Although channel 44 is configured originally for 20 MHz, we 

      // allow it to be used for 40 MHz here

      NS_ASSERT (phySta->GetChannelNumber () == 44);

      NS_ASSERT (phySta->GetChannelWidth () == 40);

      NS_ASSERT (phySta->GetFrequency () == 5220);

      PrintAttributesIfEnabled (printAttributes);

      break;

    case 13:

      Config::SetDefault ("ns3::WifiPhy::ChannelNumber", UintegerValue (44));

      wifi.SetStandard (WIFI_PHY_STANDARD_80211n_5GHZ);

      staDevice = wifi.Install (phy, macSta, wifiStaNode.Get(0));

      apDevice = wifi.Install (phy, macAp, wifiApNode.Get(0));

      phySta = GetYansWifiPhyPtr (staDevice);

      // Post-install reconfiguration to channel width 40 MHz

      Config::Set ("/NodeList/0/DeviceList/*/$ns3::WifiNetDevice/Phy/$ns3::YansWifiPhy/ChannelWidth", UintegerValue(40));

      Config::Set ("/NodeList/1/DeviceList/*/$ns3::WifiNetDevice/Phy/$ns3::YansWifiPhy/ChannelWidth", UintegerValue(40));

      // Although channel 44 is configured originally for 20 MHz, we 

      // allow it to be used for 40 MHz here

      NS_ASSERT (phySta->GetChannelNumber () == 44);

      NS_ASSERT (phySta->GetChannelWidth () == 40);

      NS_ASSERT (phySta->GetFrequency () == 5220);

      PrintAttributesIfEnabled (printAttributes);

      break;

    case 14:

      // Test that setting Frequency to a non-standard value will zero the

      // channel number

      Config::SetDefault ("ns3::WifiPhy::Frequency", UintegerValue (5281));

      wifi.SetStandard (WIFI_PHY_STANDARD_80211n_5GHZ);

      staDevice = wifi.Install (phy, macSta, wifiStaNode.Get(0));

      apDevice = wifi.Install (phy, macAp, wifiApNode.Get(0));

      phySta = GetYansWifiPhyPtr (staDevice);

      // We expect channel number to be zero since frequency doesn't match

      NS_ASSERT (phySta->GetChannelNumber () == 0);

      NS_ASSERT (phySta->GetChannelWidth () == 20);

      NS_ASSERT (phySta->GetFrequency () == 5281);

      PrintAttributesIfEnabled (printAttributes);

      break;

    case 15:

      // Test that setting Frequency to a standard value will set the

      // channel number correctly

      Config::SetDefault ("ns3::WifiPhy::Frequency", UintegerValue (5500));

      wifi.SetStandard (WIFI_PHY_STANDARD_80211n_5GHZ);

      staDevice = wifi.Install (phy, macSta, wifiStaNode.Get (0));

      apDevice = wifi.Install (phy, macAp, wifiApNode.Get (0));

      phySta = GetYansWifiPhyPtr (staDevice);

      // We expect channel number to be 100 due to frequency 5500

      NS_ASSERT (phySta->GetChannelNumber () == 100);

      NS_ASSERT (phySta->GetChannelWidth () == 20);

      NS_ASSERT (phySta->GetFrequency () == 5500);

      PrintAttributesIfEnabled (printAttributes);

      break;

    case 16:

      // Define a new channel number

      wifi.SetStandard (WIFI_PHY_STANDARD_80211n_5GHZ);

      staDevice = wifi.Install (phy, macSta, wifiStaNode.Get (0));

      apDevice = wifi.Install (phy, macAp, wifiApNode.Get (0));

      phySta = GetYansWifiPhyPtr (staDevice);

      // This case will error exit due to invalid channel number unless

      // we provide the DefineChannelNumber() below

      phySta->DefineChannelNumber (99, WIFI_PHY_STANDARD_80211n_5GHZ, 5185, 40);

      phySta->SetAttribute ("ChannelNumber", UintegerValue (99));

      PrintAttributesIfEnabled (printAttributes);

      break;

    case 17:

      // Test how channel number behaves when frequency is non-standard

      wifi.SetStandard (WIFI_PHY_STANDARD_80211n_5GHZ);

      staDevice = wifi.Install (phy, macSta, wifiStaNode.Get(0));

      apDevice = wifi.Install (phy, macAp, wifiApNode.Get(0));

      phySta = GetYansWifiPhyPtr (staDevice);

      phySta->SetAttribute ("Frequency", UintegerValue (5181));

      // We expect channel number to be 0 due to unknown center frequency 5181

      NS_ASSERT (phySta->GetChannelNumber () == 0);

      NS_ASSERT (phySta->GetChannelWidth () == 20);

      NS_ASSERT (phySta->GetFrequency () == 5181);

      phySta->SetAttribute ("Frequency", UintegerValue (5180));

      // We expect channel number to be 36 due to known center frequency 5180

      NS_ASSERT (phySta->GetChannelNumber () == 36);

      NS_ASSERT (phySta->GetChannelWidth () == 20);

      NS_ASSERT (phySta->GetFrequency () == 5180);

      phySta->SetAttribute ("Frequency", UintegerValue (5179));

      // We expect channel number to be 0 due to unknown center frequency 5179

      NS_ASSERT (phySta->GetChannelNumber () == 0);

      NS_ASSERT (phySta->GetChannelWidth () == 20);

      NS_ASSERT (phySta->GetFrequency () == 5179);

      phySta->SetAttribute ("ChannelNumber", UintegerValue (36));

      NS_ASSERT (phySta->GetChannelNumber () == 36);

      NS_ASSERT (phySta->GetChannelWidth () == 20);

      NS_ASSERT (phySta->GetFrequency () == 5180);

      PrintAttributesIfEnabled (printAttributes);

      break;

    case 18:

      // Set both channel and frequency to consistent values

      wifi.SetStandard (WIFI_PHY_STANDARD_80211n_5GHZ);

      staDevice = wifi.Install (phy, macSta, wifiStaNode.Get(0));

      apDevice = wifi.Install (phy, macAp, wifiApNode.Get(0));

      phySta = GetYansWifiPhyPtr (staDevice);

      phySta->SetAttribute ("Frequency", UintegerValue (5200));

      phySta->SetAttribute ("ChannelNumber", UintegerValue (40));

      NS_ASSERT (phySta->GetChannelNumber () == 40);

      NS_ASSERT (phySta->GetChannelWidth () == 20);

      NS_ASSERT (phySta->GetFrequency () == 5200);

      // Set both channel and frequency to inconsistent values

      phySta->SetAttribute ("Frequency", UintegerValue (5200));

      phySta->SetAttribute ("ChannelNumber", UintegerValue (36));

      // We expect channel number to be 36 

      NS_ASSERT (phySta->GetChannelNumber () == 36);

      NS_ASSERT (phySta->GetChannelWidth () == 20);

      NS_ASSERT (phySta->GetFrequency () == 5180);

      phySta->SetAttribute ("ChannelNumber", UintegerValue (36));

      phySta->SetAttribute ("Frequency", UintegerValue (5200));

      // We expect channel number to be 40 

      NS_ASSERT (phySta->GetChannelNumber () == 40);

      NS_ASSERT (phySta->GetChannelWidth () == 20);

      NS_ASSERT (phySta->GetFrequency () == 5200);

      phySta->SetAttribute ("Frequency", UintegerValue (5179));

      phySta->SetAttribute ("ChannelNumber", UintegerValue (36));

      // We expect channel number to be 36 

      NS_ASSERT (phySta->GetChannelNumber () == 36);

      NS_ASSERT (phySta->GetChannelWidth () == 20);

      NS_ASSERT (phySta->GetFrequency () == 5180);

      phySta->SetAttribute ("ChannelNumber", UintegerValue (36));

      phySta->SetAttribute ("Frequency", UintegerValue (5179));

      // We expect channel number to be 0 

      NS_ASSERT (phySta->GetChannelNumber () == 0);

      NS_ASSERT (phySta->GetChannelWidth () == 20);

      NS_ASSERT (phySta->GetFrequency () == 5179);

      PrintAttributesIfEnabled (printAttributes);

      break;

    default:

      std::cerr << "Invalid testcase number " << testCase << std::endl;

      exit (1);

      break;

  }

  // No need to Simulator::Run (); this is a configuration example

  Simulator::Destroy ();

}

    obj = bld.create_ns3_program('wifi-phy-configuration',

        ['core', 'network', 'config-store', 'wifi'])

    obj.source = 'wifi-phy-configuration.cc'

#include "ns3/fatal-error.h"

/**

 * This table maintains the mapping of valid ChannelNumber to

 * Frequency/ChannelWidth pairs.  If you want to make a channel applicable

 * to all standards, then you may use the WIFI_PHY_STANDARD_UNSPECIFIED

 * standard to represent this, as a wildcard.  If you want to limit the 

 * configuration of a particular channel/frequency/width to a particular 

 * standard(s), then you can specify one or more such bindings. 

 */

WifiPhy::ChannelToFrequencyWidthMap WifiPhy::m_channelToFrequencyWidth =

{

  // 802.11b uses width of 22, while OFDM modes use width of 20

  { std::make_pair (1, WIFI_PHY_STANDARD_80211b), std::make_pair (2412, 22) },

  { std::make_pair (1, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (2412, 20) },

  { std::make_pair (2, WIFI_PHY_STANDARD_80211b), std::make_pair (2417, 22) },

  { std::make_pair (2, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (2417, 20) },

  { std::make_pair (3, WIFI_PHY_STANDARD_80211b), std::make_pair (2422, 22) },

  { std::make_pair (3, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (2422, 20) },

  { std::make_pair (4, WIFI_PHY_STANDARD_80211b), std::make_pair (2427, 22) },

  { std::make_pair (4, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (2427, 20) },

  { std::make_pair (5, WIFI_PHY_STANDARD_80211b), std::make_pair (2432, 22) },

  { std::make_pair (5, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (2432, 20) },

  { std::make_pair (6, WIFI_PHY_STANDARD_80211b), std::make_pair (2437, 22) },

  { std::make_pair (6, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (2437, 20) },

  { std::make_pair (7, WIFI_PHY_STANDARD_80211b), std::make_pair (2442, 22) },

  { std::make_pair (7, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (2442, 20) },

  { std::make_pair (8, WIFI_PHY_STANDARD_80211b), std::make_pair (2447, 22) },

  { std::make_pair (8, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (2447, 20) },

  { std::make_pair (9, WIFI_PHY_STANDARD_80211b), std::make_pair (2452, 22) },

  { std::make_pair (9, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (2452, 20) },

  { std::make_pair (10, WIFI_PHY_STANDARD_80211b), std::make_pair (2457, 22) },

  { std::make_pair (10, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (2457, 20) },

  { std::make_pair (11, WIFI_PHY_STANDARD_80211b), std::make_pair (2462, 22) },

  { std::make_pair (11, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (2462, 20) },

  { std::make_pair (12, WIFI_PHY_STANDARD_80211b), std::make_pair (2467, 22) },

  { std::make_pair (12, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (2467, 20) },

  { std::make_pair (13, WIFI_PHY_STANDARD_80211b), std::make_pair (2472, 22) },

  { std::make_pair (13, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (2472, 20) },

  // Only defined for 802.11b

  { std::make_pair (14, WIFI_PHY_STANDARD_80211b), std::make_pair (2484, 22) },

  // Now the 5GHz channels; UNSPECIFIED for 802.11a/n channels, but limited

  // to 802.11ac for the 80/160 MHz channels

  // 20 MHz channels

  { std::make_pair (36, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5180, 20) },

  { std::make_pair (40, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5200, 20) },

  { std::make_pair (44, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5220, 20) },

  { std::make_pair (48, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5240, 20) },

  { std::make_pair (52, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5260, 20) },

  { std::make_pair (56, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5280, 20) },

  { std::make_pair (60, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5300, 20) },

  { std::make_pair (64, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5320, 20) },

  { std::make_pair (100, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5500, 20) },

  { std::make_pair (104, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5520, 20) },

  { std::make_pair (108, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5540, 20) },

  { std::make_pair (112, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5560, 20) },

  { std::make_pair (116, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5580, 20) },

  { std::make_pair (120, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5600, 20) },

  { std::make_pair (124, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5620, 20) },

  { std::make_pair (128, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5640, 20) },

  { std::make_pair (132, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5660, 20) },

  { std::make_pair (136, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5680, 20) },

  { std::make_pair (140, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5700, 20) },

  { std::make_pair (144, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5720, 20) },

  { std::make_pair (149, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5745, 20) },

  { std::make_pair (153, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5765, 20) },

  { std::make_pair (157, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5785, 20) },

  { std::make_pair (161, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5805, 20) },

  { std::make_pair (165, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5825, 20) },

  // 40 MHz channels

  { std::make_pair (38, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5190, 40) },

  { std::make_pair (46, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5230, 40) },

  { std::make_pair (54, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5230, 40) },

  { std::make_pair (62, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5310, 40) },

  { std::make_pair (102, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5510, 40) },

  { std::make_pair (110, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5550, 40) },

  { std::make_pair (118, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5590, 40) },

  { std::make_pair (126, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5590, 40) },

  { std::make_pair (134, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5670, 40) },

  { std::make_pair (142, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5710, 40) },

  { std::make_pair (151, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5755, 40) },

  { std::make_pair (159, WIFI_PHY_STANDARD_UNSPECIFIED), std::make_pair (5795, 40) },

  // 80 MHz channels

  { std::make_pair (42, WIFI_PHY_STANDARD_80211ac), std::make_pair (5210, 80) },

  { std::make_pair (58, WIFI_PHY_STANDARD_80211ac), std::make_pair (5290, 80) },

  { std::make_pair (106, WIFI_PHY_STANDARD_80211ac), std::make_pair (5530, 80) },

  { std::make_pair (122, WIFI_PHY_STANDARD_80211ac), std::make_pair (5610, 80) },

  { std::make_pair (138, WIFI_PHY_STANDARD_80211ac), std::make_pair (5690, 80) },

  { std::make_pair (155, WIFI_PHY_STANDARD_80211ac), std::make_pair (5775, 80) },

  // 160 MHz channels

  { std::make_pair (50, WIFI_PHY_STANDARD_80211ac), std::make_pair (5250, 160) },

  { std::make_pair (114, WIFI_PHY_STANDARD_80211ac), std::make_pair (5570, 160) },

  // 802.11p (10 MHz channels at the 5.855-5.925 band 

  { std::make_pair (172, WIFI_PHY_STANDARD_80211_10MHZ), std::make_pair (5860, 10) },

  { std::make_pair (174, WIFI_PHY_STANDARD_80211_10MHZ), std::make_pair (5870, 10) },

  { std::make_pair (176, WIFI_PHY_STANDARD_80211_10MHZ), std::make_pair (5880, 10) },

  { std::make_pair (178, WIFI_PHY_STANDARD_80211_10MHZ), std::make_pair (5890, 10) },

  { std::make_pair (180, WIFI_PHY_STANDARD_80211_10MHZ), std::make_pair (5900, 10) },

  { std::make_pair (182, WIFI_PHY_STANDARD_80211_10MHZ), std::make_pair (5910, 10) },

  { std::make_pair (184, WIFI_PHY_STANDARD_80211_10MHZ), std::make_pair (5920, 10) }

};

    .AddAttribute ("Frequency",

                   "The operating center frequency (MHz)",

                   UintegerValue (0),

                   MakeUintegerAccessor (&WifiPhy::GetFrequency,

                                         &WifiPhy::SetFrequency),

                   MakeUintegerChecker<uint32_t> ())

    .AddAttribute ("ChannelWidth",

                   "Whether 5MHz, 10MHz, 20MHz, 22MHz, 40MHz, 80 MHz or 160 MHz.",

                   UintegerValue (20),

                   MakeUintegerAccessor (&WifiPhy::GetChannelWidth,

                                         &WifiPhy::SetChannelWidth),

                   MakeUintegerChecker<uint32_t> ())

    .AddAttribute ("ChannelNumber",

                   "If set to non-zero defined value, will control Frequency and ChannelWidth assignment",

                   UintegerValue (0),

                   MakeUintegerAccessor (&WifiPhy::SetChannelNumber,

                                         &WifiPhy::GetChannelNumber),

                   MakeUintegerChecker<uint16_t> ())

  : m_standard (WIFI_PHY_STANDARD_UNSPECIFIED),

    m_channelCenterFrequency (0),

    m_channelNumber (1)

void

WifiPhy::ConfigureDefaultsForStandard (enum WifiPhyStandard standard)

{

  NS_LOG_FUNCTION (this << standard);

  switch (standard)

    {

    case WIFI_PHY_STANDARD_80211a:

      SetChannelWidth (20);

      SetFrequency (5180);

      // Channel number should be aligned by SetFrequency () to 36

      NS_ASSERT (GetChannelNumber () == 36);

      break;

    case WIFI_PHY_STANDARD_80211b:

      SetChannelWidth (22);

      SetFrequency (2412);

      // Channel number should be aligned by SetFrequency () to 1

      NS_ASSERT (GetChannelNumber () == 1);

      break;

    case WIFI_PHY_STANDARD_80211g:

      SetChannelWidth (20);

      SetFrequency (2412);

      // Channel number should be aligned by SetFrequency () to 1

      NS_ASSERT (GetChannelNumber () == 1);

      break;

    case WIFI_PHY_STANDARD_80211_10MHZ:

      SetChannelWidth (10);

      SetFrequency (5860);

      // Channel number should be aligned by SetFrequency () to 172

      NS_ASSERT (GetChannelNumber () == 172);

      break;

    case WIFI_PHY_STANDARD_80211_5MHZ:

      SetChannelWidth (5);

      SetFrequency (5860);

      // Channel number should be aligned by SetFrequency () to 0 

      NS_ASSERT (GetChannelNumber () == 0);

      break;

    case WIFI_PHY_STANDARD_holland:

      SetChannelWidth (20);

      SetFrequency (5180);

      // Channel number should be aligned by SetFrequency () to 36

      NS_ASSERT (GetChannelNumber () == 36);

      break;

    case WIFI_PHY_STANDARD_80211n_2_4GHZ:

      SetChannelWidth (20);

      SetFrequency (2412);

      // Channel number should be aligned by SetFrequency () to 1

      NS_ASSERT (GetChannelNumber () == 1);

      break;

    case WIFI_PHY_STANDARD_80211n_5GHZ:

      SetChannelWidth (20);

      SetFrequency (5180);

      // Channel number should be aligned by SetFrequency () to 36

      NS_ASSERT (GetChannelNumber () == 36);

      break;

    case WIFI_PHY_STANDARD_80211ac:

      SetChannelWidth (80);

      SetFrequency (5210);

      // Channel number should be aligned by SetFrequency () to 42

      NS_ASSERT (GetChannelNumber () == 42);

      break;

    case WIFI_PHY_STANDARD_UNSPECIFIED:

      NS_LOG_WARN ("Configuring unspecified standard; performing no action");

      break;

    default:

      NS_ASSERT (false);

      break;

    }

}

bool 

WifiPhy::DefineChannelNumber (uint16_t channelNumber, enum WifiPhyStandard standard, uint32_t frequency, uint32_t channelWidth)

{

  NS_LOG_FUNCTION (this << channelNumber << standard << frequency << channelWidth);

  ChannelNumberStandardPair p = std::make_pair (channelNumber, standard);

  ChannelToFrequencyWidthMap::const_iterator it;

  it = m_channelToFrequencyWidth.find (p);

  if (it != m_channelToFrequencyWidth.end ())

    {

      NS_LOG_DEBUG ("channel number/standard already defined; returning false");

      return false;

    }

  FrequencyWidthPair f = std::make_pair (frequency, channelWidth);

  m_channelToFrequencyWidth[p] = f;

  return true;

}

uint16_t 

WifiPhy::FindChannelNumberForFrequencyWidth (uint32_t frequency, uint32_t width) const

{

  NS_LOG_FUNCTION (this << frequency << width);

  bool found = false;

  FrequencyWidthPair f = std::make_pair (frequency, width);

  ChannelToFrequencyWidthMap::const_iterator it = m_channelToFrequencyWidth.begin ();

  while (it != m_channelToFrequencyWidth.end ())

    {

      if (it->second == f)

        {

           found = true;

           break;

        }

      ++it;

    }

  if (found)

    {

      NS_LOG_DEBUG ("Found, returning " << it->first.first);

      return (it->first.first);

    }

  else

    {

      NS_LOG_DEBUG ("Not found, returning 0");

      return 0;

    }

}

void

WifiPhy::ConfigureChannelForStandard (enum WifiPhyStandard standard)

{

  NS_LOG_FUNCTION (this << standard);

  // If the user has configured both Frequency and ChannelNumber, Frequency

  // takes precedence 

  if (GetFrequency () != 0)

    {

      // If Frequency is already set, then see whether a ChannelNumber can

      // be found that matches Frequency and ChannelWidth.  If so, configure 

      // the ChannelNumber to that channel number.  If not, set 

      // ChannelNumber to zero.

      NS_LOG_DEBUG ("Frequency set; checking whether a channel number corresponds");

      uint32_t channelNumberSearched = FindChannelNumberForFrequencyWidth (GetFrequency (), GetChannelWidth ());

      if (channelNumberSearched)

        {

          NS_LOG_DEBUG ("Channel number found; setting to " << channelNumberSearched);

          SetChannelNumber (channelNumberSearched);

        }

      else

        {

          NS_LOG_DEBUG ("Channel number not found; setting to zero");

          SetChannelNumber (0);

        }

    }

  else if (GetChannelNumber () != 0)

    {

      // If the channel number is known for this particular standard or for 

      // the unspecified standard, configure using the known values;

      // otherwise, this is a configuration error

      NS_LOG_DEBUG ("Configuring for channel number " << GetChannelNumber ());

      ChannelNumberStandardPair p = std::make_pair (GetChannelNumber (), standard);

      FrequencyWidthPair f;

      ChannelToFrequencyWidthMap::const_iterator it;

      it = m_channelToFrequencyWidth.find (p);

      if (it != m_channelToFrequencyWidth.end ())

        {

          f = m_channelToFrequencyWidth[p];

        }

      else

        {

          // the specific pair of number/standard is not known

          NS_LOG_DEBUG ("Falling back to check WIFI_PHY_STANDARD_UNSPECIFIED");

          ChannelNumberStandardPair p2 = std::make_pair (GetChannelNumber (), WIFI_PHY_STANDARD_UNSPECIFIED);

          it = m_channelToFrequencyWidth.find (p2);

        }

      if (it == m_channelToFrequencyWidth.end())

        {

          NS_FATAL_ERROR ("Error, ChannelNumber " << GetChannelNumber () << " is unknown for this standard");

        }

      else

        {

          NS_LOG_DEBUG ("Setting frequency to " << f.first << "; width to " << f.second);

          SetFrequency (f.first);

          SetChannelWidth (f.second);

        }

    }

}

void

WifiPhy::ConfigureStandard (enum WifiPhyStandard standard)

{

  NS_LOG_FUNCTION (this << standard);

  m_standard = standard;

  if (GetFrequency () == 0 && GetChannelNumber () == 0)

    {

      ConfigureDefaultsForStandard (standard);

    }

  else

    {

      // The user has configured either (or both) Frequency or ChannelNumber

      ConfigureChannelForStandard (standard);

    }

}

void

WifiPhy::SetFrequency (uint32_t frequency)

{

  NS_LOG_FUNCTION (this << frequency);

  // If the user has configured both Frequency and ChannelNumber, Frequency

  // takes precedence 

  if (GetFrequency () == frequency)

    {

      NS_LOG_DEBUG ("No frequency change requested");

      return;

    }

  if (frequency == 0)

    {

      DoFrequencySwitch (0);

      NS_LOG_DEBUG ("Setting frequency and channel number to zero");

      m_channelCenterFrequency = 0;

      m_channelNumber = 0;

      return;

    }

  // See if there corresponds a channel number to the requested frequency.

  uint16_t nch = FindChannelNumberForFrequencyWidth (frequency, GetChannelWidth ());

  if (nch != 0)

    {

      NS_LOG_DEBUG ("Setting frequency " << frequency << " corresponds to channel " << nch);

      if (DoFrequencySwitch (frequency))

        {

          NS_LOG_DEBUG ("Channel frequency switched to " << frequency << "; channel number to " << nch);

          m_channelCenterFrequency = frequency;

          m_channelNumber = nch;

        }

    else

        {

          NS_LOG_DEBUG ("Suppressing reassignment of frequency");

        }

    }

  else

    {

      NS_LOG_DEBUG ("Channel number is unknown for frequency " << frequency);

      if (DoFrequencySwitch (frequency))

        {

          NS_LOG_DEBUG ("Channel frequency switched to " << frequency << "; channel number to " << 0);

          m_channelCenterFrequency = frequency;

          m_channelNumber = 0;

        }

    else

        {

          NS_LOG_DEBUG ("Suppressing reassignment of frequency");

        }

    }

}

uint32_t

WifiPhy::GetFrequency (void) const

{

  return m_channelCenterFrequency;

}

void

WifiPhy::SetChannelWidth (uint32_t channelwidth)

{

  NS_ASSERT_MSG (channelwidth == 5 || channelwidth == 10 || channelwidth == 20 || channelwidth == 22 || channelwidth == 40 || channelwidth == 80 || channelwidth == 160, "wrong channel width value");

  m_channelWidth = channelwidth;

  AddSupportedChannelWidth (channelwidth);

}

uint32_t

WifiPhy::GetChannelWidth (void) const

{

  return m_channelWidth;

}

void

WifiPhy::AddSupportedChannelWidth (uint32_t width)

{

  NS_LOG_FUNCTION (this << width);

  for (std::vector<uint32_t>::size_type i = 0; i != m_supportedChannelWidthSet.size (); i++)

    {

      if (m_supportedChannelWidthSet[i] == width)

        {

          return;

        }

    }

  m_supportedChannelWidthSet.push_back (width);

}

std::vector<uint32_t> 

WifiPhy::GetSupportedChannelWidthSet (void) const

{

  return m_supportedChannelWidthSet;

}

void

WifiPhy::SetChannelNumber (uint16_t nch)

{

  NS_LOG_FUNCTION (this << nch);

  if (GetChannelNumber () == nch)

    {

      NS_LOG_DEBUG ("No channel change requested");

      return;

    }

  if (nch == 0)

    {

      DoChannelSwitch (nch);

      m_channelNumber = 0;

      return;

    }

  ChannelNumberStandardPair p = std::make_pair (nch, m_standard);

  FrequencyWidthPair f = m_channelToFrequencyWidth[p];

  if (f.first == 0 && m_standard != WIFI_PHY_STANDARD_UNSPECIFIED)

    {

      // the specific pair of number/standard is not known

      NS_LOG_DEBUG ("Falling back to check WIFI_PHY_STANDARD_UNSPECIFIED");

      ChannelNumberStandardPair p2 = std::make_pair (nch, WIFI_PHY_STANDARD_UNSPECIFIED);

      f = m_channelToFrequencyWidth[p2];

    }

  if (f.first == 0)

    {

      NS_FATAL_ERROR ("Error, ChannelNumber " << nch << " is unknown for this standard");

    }

  if (DoChannelSwitch (nch))

    {

      m_channelNumber = nch;

      NS_LOG_DEBUG ("Setting frequency to " << f.first << "; width to " << f.second);

      m_channelCenterFrequency = f.first;

      SetChannelWidth (f.second);

    }

  else

    {

      NS_LOG_DEBUG ("Suppressing reassignment of channel number");

    }

}

uint16_t

WifiPhy::GetChannelNumber (void) const

{

  return m_channelNumber;

}

bool

WifiPhy::DoChannelSwitch (uint16_t nch)

{

  return true;

}

bool

WifiPhy::DoFrequencySwitch (uint32_t frequency)

{

  return true;

}

#include <map>

#include "wifi-phy-standard.h"

   * This method may fail to take action if the Phy model determines that

   * the channel number cannot be switched for some reason (e.g. sleep state)

   * The default implementation does nothing and returns true.  This method 

   * is typically called internally by SetChannelNumber ().

   *

   * \brief Perform any actions necessary when user changes channel number

   * \param id channel number to try to switch to

   * \return true if WifiPhy can actually change the number; false if not

   * \see SetChannelNumber

   */

  virtual bool DoChannelSwitch (uint16_t id);

  /**

   * The default implementation does nothing and returns true.  This method

   * is typically called internally by SetFrequency ().

   *

   * \brief Perform any actions necessary when user changes frequency

   * \param frequency frequency to try to switch to

   * \return true if WifiPhy can actually change the frequency; false if not

   * \see SetFrequency

   */

  virtual bool DoFrequencySwitch (uint32_t frequency);

  /**

   * Configure the PHY-level parameters for different Wi-Fi standard.

   * This method is called when defaults for each standard must be 

   * selected.

   *

   * \param standard the Wi-Fi standard

   */

  virtual void ConfigureDefaultsForStandard (enum WifiPhyStandard standard);

  /**

   * Configure the PHY-level parameters for different Wi-Fi standard.

   * This method is called when the Frequency or ChannelNumber attributes

   * are set by the user.  If the Frequency or ChannelNumber are valid for

   * the standard, they are used instead.

   *

   * \param standard the Wi-Fi standard

   */

  virtual void ConfigureChannelForStandard (enum WifiPhyStandard standard);

  /**

   * Look for 

   * \param frequency The center frequency to use

   * \param width The channel width to use

   * \return the channel number if found, zero if not

   */

  uint16_t FindChannelNumberForFrequencyWidth (uint32_t frequency, uint32_t width) const;

  /**

  enum WifiPhyStandard m_standard;     //!< WifiPhyStandard

  uint32_t m_channelCenterFrequency;   //!< Center frequency in MHz

  uint32_t m_channelWidth;             //!< Channel width

  typedef std::map<ChannelNumberStandardPair,FrequencyWidthPair> ChannelToFrequencyWidthMap;

  static ChannelToFrequencyWidthMap m_channelToFrequencyWidth;

  std::vector<uint32_t> m_supportedChannelWidthSet; //!< Supported channel width

  uint16_t             m_channelNumber;  //!< Operating channel number

bool

YansWifiPhy::DoChannelSwitch (uint16_t nch)

{

  if (!m_initialized)

    {

      //this is not channel switch, this is initialization

      NS_LOG_DEBUG ("start at channel " << nch);

      return true;

    }

  NS_ASSERT (!IsStateSwitching ());

  switch (m_state->GetState ())

    {

    case YansWifiPhy::RX:

      NS_LOG_DEBUG ("drop packet because of channel switching while reception");

      m_endPlcpRxEvent.Cancel ();

      m_endRxEvent.Cancel ();

      goto switchChannel;

      break;

    case YansWifiPhy::TX:

      NS_LOG_DEBUG ("channel switching postponed until end of current transmission");

      Simulator::Schedule (GetDelayUntilIdle (), &WifiPhy::SetChannelNumber, this, nch);

      break;

    case YansWifiPhy::CCA_BUSY:

    case YansWifiPhy::IDLE:

      goto switchChannel;

      break;

    case YansWifiPhy::SLEEP:

      NS_LOG_DEBUG ("channel switching ignored in sleep mode");

      break;

    default:

      NS_ASSERT (false);

      break;

    }

  return false;

switchChannel:

  NS_LOG_DEBUG ("switching channel " << GetChannelNumber () << " -> " << nch);

  m_state->SwitchToChannelSwitching (m_channelSwitchDelay);

  m_interference.EraseEvents ();

  /*

   * Needed here to be able to correctly sensed the medium for the first

   * time after the switching. The actual switching is not performed until

   * after m_channelSwitchDelay. Packets received during the switching

   * state are added to the event list and are employed later to figure

   * out the state of the medium after the switching.

   */

  return true;

}

bool

YansWifiPhy::DoFrequencySwitch (uint32_t frequency)

{

  if (!m_initialized)

    {

      //this is not channel switch, this is initialization

      NS_LOG_DEBUG ("start at frequency " << frequency);

      return true;

    }

  NS_ASSERT (!IsStateSwitching ());

  switch (m_state->GetState ())

    {

    case YansWifiPhy::RX:

      NS_LOG_DEBUG ("drop packet because of channel/frequency switching while reception");

      m_endPlcpRxEvent.Cancel ();

      m_endRxEvent.Cancel ();

      goto switchFrequency;

      break;

    case YansWifiPhy::TX:

      NS_LOG_DEBUG ("channel/frequency switching postponed until end of current transmission");

      Simulator::Schedule (GetDelayUntilIdle (), &WifiPhy::SetFrequency, this, frequency);

      break;

    case YansWifiPhy::CCA_BUSY:

    case YansWifiPhy::IDLE:

      goto switchFrequency;

      break;

    case YansWifiPhy::SLEEP:

      NS_LOG_DEBUG ("frequency switching ignored in sleep mode");

      break;

    default:

      NS_ASSERT (false);

      break;

    }

  return false;

switchFrequency:

  NS_LOG_DEBUG ("switching frequency " << GetFrequency () << " -> " << frequency);

  m_state->SwitchToChannelSwitching (m_channelSwitchDelay);

  m_interference.EraseEvents ();

  /*

   * Needed here to be able to correctly sensed the medium for the first

   * time after the switching. The actual switching is not performed until

   * after m_channelSwitchDelay. Packets received during the switching

   * state are added to the event list and are employed later to figure

   * out the state of the medium after the switching.

   */

  return true;

}

  WifiPhy::ConfigureStandard (standard); // set up base class