A Discrete-Event Network Simulator
API
wifi-test-interference-helper.cc
Go to the documentation of this file.
1 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * Copyright (c) 2015
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License version 2 as
7  * published by the Free Software Foundation;
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17  *
18  * Author: S├ębastien Deronne <sebastien.deronne@gmail.com>
19  */
20 
21 //
22 // This script is used to verify the behavior of InterferenceHelper.
23 //
24 // The scenario consists of two IEEE 802.11 hidden stations and an access point.
25 // The two stations have both a packet to transmit to the access point.
26 //
27 //
28 // (xA,0,0) (0,0,0) (xB,0,0)
29 //
30 // * -----> * <----- *
31 // | | |
32 // STA A AP STA B
33 //
34 //
35 // The program can be configured at run-time by passing command-line arguments.
36 // It enables to configure the delay between the transmission from station A
37 // and the transmission from station B (--delay option). It is also possible to
38 // select the tx power level (--txPowerA and --txPowerB options), the packet size
39 // (--packetSizeA and --packetSizeB options) and the modulation (--txModeA and
40 // --txModeB options) used for the respective transmissions.
41 //
42 // By default, IEEE 802.11a with long preamble type is considered, but those
43 // parameters can be also picked among other IEEE 802.11 flavors and preamble
44 // types available in the simulator (--standard and --preamble options).
45 // Note that the program checks the consistency between the selected standard
46 // the selected preamble type.
47 //
48 // The output of the program displays InterfenceHelper and SpectrumWifiPhy trace
49 // logs associated to the chosen scenario.
50 //
51 
52 #include "ns3/log.h"
53 #include "ns3/node.h"
54 #include "ns3/packet.h"
55 #include "ns3/config.h"
56 #include "ns3/double.h"
57 #include "ns3/simulator.h"
58 #include "ns3/command-line.h"
59 #include "ns3/single-model-spectrum-channel.h"
60 #include "ns3/spectrum-wifi-phy.h"
61 #include "ns3/propagation-loss-model.h"
62 #include "ns3/propagation-delay-model.h"
63 #include "ns3/nist-error-rate-model.h"
64 #include "ns3/constant-position-mobility-model.h"
65 #include "ns3/simple-frame-capture-model.h"
66 #include "ns3/wifi-psdu.h"
67 #include "ns3/wifi-mac-trailer.h"
68 #include "ns3/wifi-net-device.h"
69 
70 using namespace ns3;
71 
72 NS_LOG_COMPONENT_DEFINE ("test-interference-helper");
73 
74 bool checkResults = false;
75 bool expectRxASuccessfull = false;
76 bool expectRxBSuccessfull = false;
77 
80 {
81 public:
83  struct Input
84  {
85  Input ();
87  double xA;
88  double xB;
89  std::string txModeA;
90  std::string txModeB;
91  double txPowerLevelA;
92  double txPowerLevelB;
93  uint32_t packetSizeA;
94  uint32_t packetSizeB;
95  uint16_t channelA;
96  uint16_t channelB;
97  uint16_t widthA;
98  uint16_t widthB;
103  double captureMargin;
104  };
105 
111  void Run (struct InterferenceExperiment::Input input);
112 
113 private:
119  void PacketDropped (Ptr<const Packet> packet, WifiPhyRxfailureReason reason);
121  void SendA (void) const;
123  void SendB (void) const;
126  struct Input m_input;
127  bool m_droppedA;
128  bool m_droppedB;
129  mutable uint64_t m_uidA;
130  mutable uint64_t m_uidB;
131 };
132 
133 void
135 {
136  WifiMacHeader hdr;
137  hdr.SetType (WIFI_MAC_CTL_ACK); //so that size may not be empty while being as short as possible
138  Ptr<Packet> p = Create<Packet> (m_input.packetSizeA - hdr.GetSerializedSize () - WIFI_MAC_FCS_LENGTH);
139  m_uidA = p->GetUid ();
140  Ptr<WifiPsdu> psdu = Create<WifiPsdu> (p, hdr);
141  WifiTxVector txVector;
142  txVector.SetTxPowerLevel (0); //only one TX power level
143  txVector.SetMode (WifiMode (m_input.txModeA));
144  txVector.SetChannelWidth (m_input.widthA);
145  txVector.SetPreambleType (m_input.preamble);
146  m_txA->Send (psdu, txVector);
147 }
148 
149 void
151 {
152  WifiMacHeader hdr;
153  hdr.SetType (WIFI_MAC_CTL_ACK); //so that size may not be empty while being as short as possible
154  Ptr<Packet> p = Create<Packet> (m_input.packetSizeB - hdr.GetSerializedSize () - WIFI_MAC_FCS_LENGTH);
155  m_uidB = p->GetUid ();
156  Ptr<WifiPsdu> psdu = Create<WifiPsdu> (p, hdr);
157  WifiTxVector txVector;
158  txVector.SetTxPowerLevel (0); //only one TX power level
159  txVector.SetMode (WifiMode (m_input.txModeB));
160  txVector.SetChannelWidth (m_input.widthB);
161  txVector.SetPreambleType (m_input.preamble);
162  m_txB->Send (psdu, txVector);
163 }
164 
165 void
167 {
168  if (packet->GetUid () == m_uidA)
169  {
170  m_droppedA = true;
171  }
172  else if (packet->GetUid () == m_uidB)
173  {
174  m_droppedB = true;
175  }
176  else
177  {
178  NS_LOG_ERROR ("Unknown packet!");
179  exit (1);
180  }
181 }
182 
184  : m_droppedA (false),
185  m_droppedB (false),
186  m_uidA (0),
187  m_uidB (0)
188 {
189 }
190 
192  : interval (MicroSeconds (0)),
193  xA (-5),
194  xB (5),
195  txModeA ("OfdmRate54Mbps"),
196  txModeB ("OfdmRate54Mbps"),
197  txPowerLevelA (16.0206),
198  txPowerLevelB (16.0206),
199  packetSizeA (1500),
200  packetSizeB (1500),
201  channelA (36),
202  channelB (36),
203  widthA (20),
204  widthB (20),
205  standard (WIFI_PHY_STANDARD_80211a),
206  band (WIFI_PHY_BAND_5GHZ),
207  preamble (WIFI_PREAMBLE_LONG),
208  captureEnabled (false),
209  captureMargin (0)
210 {
211 }
212 
213 void
215 {
216  m_input = input;
217 
218  double range = std::max (std::abs (input.xA), input.xB);
219  Config::SetDefault ("ns3::RangePropagationLossModel::MaxRange", DoubleValue (range));
220 
221  Ptr<SingleModelSpectrumChannel> channel = CreateObject<SingleModelSpectrumChannel> ();
222  channel->SetPropagationDelayModel (CreateObject<ConstantSpeedPropagationDelayModel> ());
223  Ptr<RangePropagationLossModel> loss = CreateObject<RangePropagationLossModel> ();
224  channel->AddPropagationLossModel (loss);
225 
226  Ptr<MobilityModel> posTxA = CreateObject<ConstantPositionMobilityModel> ();
227  posTxA->SetPosition (Vector (input.xA, 0.0, 0.0));
228  Ptr<MobilityModel> posTxB = CreateObject<ConstantPositionMobilityModel> ();
229  posTxB->SetPosition (Vector (input.xB, 0.0, 0.0));
230  Ptr<MobilityModel> posRx = CreateObject<ConstantPositionMobilityModel> ();
231  posRx->SetPosition (Vector (0.0, 0.0, 0.0));
232 
233  Ptr<Node> nodeA = CreateObject<Node> ();
234  Ptr<WifiNetDevice> devA = CreateObject<WifiNetDevice> ();
235  m_txA = CreateObject<SpectrumWifiPhy> ();
237  m_txA->SetDevice (devA);
240 
241  Ptr<Node> nodeB = CreateObject<Node> ();
242  Ptr<WifiNetDevice> devB = CreateObject<WifiNetDevice> ();
243  m_txB = CreateObject<SpectrumWifiPhy> ();
245  m_txB->SetDevice (devB);
248 
249  Ptr<Node> nodeRx = CreateObject<Node> ();
250  Ptr<WifiNetDevice> devRx = CreateObject<WifiNetDevice> ();
251  Ptr<SpectrumWifiPhy> rx = CreateObject<SpectrumWifiPhy> ();
252  rx->CreateWifiSpectrumPhyInterface (devRx);
253  rx->SetDevice (devRx);
254 
255  Ptr<ErrorRateModel> error = CreateObject<NistErrorRateModel> ();
256  m_txA->SetErrorRateModel (error);
257  m_txB->SetErrorRateModel (error);
258  rx->SetErrorRateModel (error);
261  rx->SetChannel (channel);
262  m_txA->SetMobility (posTxA);
263  m_txB->SetMobility (posTxB);
264  rx->SetMobility (posRx);
265  if (input.captureEnabled)
266  {
267  Ptr<SimpleFrameCaptureModel> frameCaptureModel = CreateObject<SimpleFrameCaptureModel> ();
268  frameCaptureModel->SetMargin (input.captureMargin);
269  rx->SetFrameCaptureModel (frameCaptureModel);
270  }
271 
274  rx->ConfigureStandardAndBand (input.standard, input.band);
275 
276  devA->SetPhy (m_txA);
277  nodeA->AddDevice (devA);
278  devB->SetPhy (m_txB);
279  nodeB->AddDevice (devB);
280  devRx->SetPhy (rx);
281  nodeRx->AddDevice (devRx);
282 
285  rx->SetChannelNumber (std::max (input.channelA, input.channelB));
286 
287  rx->TraceConnectWithoutContext ("PhyRxDrop", MakeCallback (&InterferenceExperiment::PacketDropped, this));
288 
289  Simulator::Schedule (Seconds (0), &InterferenceExperiment::SendA, this);
290  Simulator::Schedule (Seconds (0) + input.interval, &InterferenceExperiment::SendB, this);
291 
292  Simulator::Run ();
293  Simulator::Destroy ();
294  m_txB->Dispose ();
295  m_txA->Dispose ();
296  rx->Dispose ();
297 
299  {
300  NS_LOG_ERROR ("Results are not expected!");
301  exit (1);
302  }
303 }
304 
305 int main (int argc, char *argv[])
306 {
308  std::string str_standard = "WIFI_PHY_STANDARD_80211a";
309  std::string str_preamble = "WIFI_PREAMBLE_LONG";
310  uint64_t delay = 0; //microseconds
311 
312  CommandLine cmd (__FILE__);
313  cmd.AddValue ("delay", "Delay in microseconds between frame transmission from sender A and frame transmission from sender B", delay);
314  cmd.AddValue ("xA", "The position of transmitter A (< 0)", input.xA);
315  cmd.AddValue ("xB", "The position of transmitter B (> 0)", input.xB);
316  cmd.AddValue ("packetSizeA", "Packet size in bytes of transmitter A", input.packetSizeA);
317  cmd.AddValue ("packetSizeB", "Packet size in bytes of transmitter B", input.packetSizeB);
318  cmd.AddValue ("txPowerA", "TX power level of transmitter A", input.txPowerLevelA);
319  cmd.AddValue ("txPowerB", "TX power level of transmitter B", input.txPowerLevelB);
320  cmd.AddValue ("txModeA", "Wifi mode used for payload transmission of sender A", input.txModeA);
321  cmd.AddValue ("txModeB", "Wifi mode used for payload transmission of sender B", input.txModeB);
322  cmd.AddValue ("channelA", "The selected channel number of sender A", input.channelA);
323  cmd.AddValue ("channelB", "The selected channel number of sender B", input.channelB);
324  cmd.AddValue ("widthA", "The selected channel width (MHz) of sender A", input.widthA);
325  cmd.AddValue ("widthB", "The selected channel width (MHz) of sender B", input.widthB);
326  cmd.AddValue ("standard", "IEEE 802.11 flavor", str_standard);
327  cmd.AddValue ("preamble", "Type of preamble", str_preamble);
328  cmd.AddValue ("enableCapture", "Enable/disable physical layer capture", input.captureEnabled);
329  cmd.AddValue ("captureMargin", "Margin used for physical layer capture", input.captureMargin);
330  cmd.AddValue ("checkResults", "Used to check results at the end of the test", checkResults);
331  cmd.AddValue ("expectRxASuccessfull", "Indicate whether packet A is expected to be successfully received", expectRxASuccessfull);
332  cmd.AddValue ("expectRxBSuccessfull", "Indicate whether packet B is expected to be successfully received", expectRxBSuccessfull);
333  cmd.Parse (argc, argv);
334 
335  input.interval = MicroSeconds (delay);
336 
337  if (input.xA >= 0 || input.xB <= 0)
338  {
339  std::cout << "Value of xA must be smaller than 0 and value of xB must be bigger than 0!" << std::endl;
340  return 0;
341  }
342 
343  if (str_standard == "WIFI_PHY_STANDARD_80211a")
344  {
346  input.band = WIFI_PHY_BAND_5GHZ;
347  }
348  else if (str_standard == "WIFI_PHY_STANDARD_80211b")
349  {
351  input.band = WIFI_PHY_BAND_2_4GHZ;
352  }
353  else if (str_standard == "WIFI_PHY_STANDARD_80211g")
354  {
356  input.band = WIFI_PHY_BAND_2_4GHZ;
357  }
358  else if (str_standard == "WIFI_PHY_STANDARD_80211n_2_4GHZ")
359  {
361  input.band = WIFI_PHY_BAND_2_4GHZ;
362  }
363  else if (str_standard == "WIFI_PHY_STANDARD_80211n_5GHZ")
364  {
366  input.band = WIFI_PHY_BAND_5GHZ;
367  }
368  else if (str_standard == "WIFI_PHY_STANDARD_80211ac")
369  {
371  input.band = WIFI_PHY_BAND_5GHZ;
372  }
373  else if (str_standard == "WIFI_PHY_STANDARD_80211ax_2_4GHZ")
374  {
376  input.band = WIFI_PHY_BAND_2_4GHZ;
377  }
378  else if (str_standard == "WIFI_PHY_STANDARD_80211ax_5GHZ")
379  {
381  input.band = WIFI_PHY_BAND_5GHZ;
382  }
383 
384  if (str_preamble == "WIFI_PREAMBLE_LONG" && (input.standard == WIFI_PHY_STANDARD_80211a || input.standard == WIFI_PHY_STANDARD_80211b || input.standard == WIFI_PHY_STANDARD_80211g))
385  {
387  }
388  else if (str_preamble == "WIFI_PREAMBLE_SHORT" && (input.standard == WIFI_PHY_STANDARD_80211b || input.standard == WIFI_PHY_STANDARD_80211g))
389  {
391  }
392  else if (str_preamble == "WIFI_PREAMBLE_HT_MF" && input.standard == WIFI_PHY_STANDARD_80211n)
393  {
395  }
396  else if (str_preamble == "WIFI_PREAMBLE_HT_GF" && (input.standard == WIFI_PHY_STANDARD_80211n))
397  {
399  }
400  else if (str_preamble == "WIFI_PREAMBLE_VHT_SU" && input.standard == WIFI_PHY_STANDARD_80211ac)
401  {
403  }
404  else if (str_preamble == "WIFI_PREAMBLE_HE_SU" && input.standard == WIFI_PHY_STANDARD_80211ax)
405  {
407  }
408  else
409  {
410  std::cout << "Preamble does not exist or is not compatible with the selected standard!" << std::endl;
411  return 0;
412  }
413 
415  experiment.Run (input);
416 
417  return 0;
418 }
ERP-OFDM PHY (Clause 19, Section 19.5)
void Dispose(void)
Dispose of this Object.
Definition: object.cc:214
double txPowerLevelB
transmit power level B
uint64_t GetUid(void) const
Returns the packet&#39;s Uid.
Definition: packet.cc:390
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:103
void SendB(void) const
Send B function.
This class mimics the TXVECTOR which is to be passed to the PHY in order to define the parameters whi...
bool captureEnabled
whether physical layer capture is enabled
bool expectRxBSuccessfull
bool m_droppedB
flag to indicate whether packet B has been dropped
static const uint16_t WIFI_MAC_FCS_LENGTH
The length in octects of the IEEE 802.11 MAC FCS field.
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:205
void SetMobility(const Ptr< MobilityModel > mobility)
assign a mobility model to this device
Definition: wifi-phy.cc:765
cmd
Definition: second.py:35
The 5 GHz band.
Definition: wifi-phy-band.h:35
represent a single transmission modeA WifiMode is implemented by a single integer which is used to lo...
Definition: wifi-mode.h:99
virtual void SetChannelNumber(uint8_t id)
Set channel number.
channel
Definition: third.py:92
bool m_droppedA
flag to indicate whether packet A has been dropped
void SetDevice(const Ptr< NetDevice > device)
Sets the device this PHY is associated with.
Definition: wifi-phy.cc:753
WifiPreamble
The type of preamble to be used by an IEEE 802.11 transmission.
Definition: wifi-preamble.h:32
WifiPhyStandard
Identifies the PHY specification that a Wifi device is configured to use.
double captureMargin
margin used for physical layer capture
Ptr< SpectrumWifiPhy > m_txB
transmit B function
#define max(a, b)
Definition: 80211b.c:43
void PacketDropped(Ptr< const Packet > packet, WifiPhyRxfailureReason reason)
Function triggered when a packet is dropped.
void SetTxPowerEnd(double end)
Sets the maximum available transmission power level (dBm).
Definition: wifi-phy.cc:688
double txPowerLevelA
transmit power level A
Parse command-line arguments.
Definition: command-line.h:226
virtual void ConfigureStandardAndBand(WifiPhyStandard standard, WifiPhyBand band)
Configure the PHY-level parameters for different Wi-Fi standard.
void SetErrorRateModel(const Ptr< ErrorRateModel > rate)
Sets the error rate model.
Definition: wifi-phy.cc:784
OFDM PHY (Clause 17)
Every class exported by the ns3 library is enclosed in the ns3 namespace.
DSSS PHY (Clause 15) and HR/DSSS PHY (Clause 18)
void Run(struct InterferenceExperiment::Input input)
Run function.
void SetTxPowerLevel(uint8_t powerlevel)
Sets the selected transmission power level.
bool expectRxASuccessfull
The 2.4 GHz band.
Definition: wifi-phy-band.h:33
void SetPosition(const Vector &position)
WifiPhyBand
Identifies the PHY band.
Definition: wifi-phy-band.h:30
void SetType(WifiMacType type, bool resetToDsFromDs=true)
Set Type/Subtype values with the correct values depending on the given type.
void experiment(std::string queue_disc_type)
uint32_t AddDevice(Ptr< NetDevice > device)
Associate a NetDevice to this node.
Definition: node.cc:130
void SetTxPowerStart(double start)
Sets the minimum available transmission power level (dBm).
Definition: wifi-phy.cc:675
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1288
WifiPhyRxfailureReason
Enumeration of the possible reception failure reasons.
Definition: wifi-phy.h:52
void SetDefault(std::string name, const AttributeValue &value)
Definition: config.cc:849
uint32_t GetSerializedSize(void) const
Ptr< SpectrumWifiPhy > m_txA
transmit A function
Time MicroSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:1304
#define NS_LOG_ERROR(msg)
Use NS_LOG to output a message of level LOG_ERROR.
Definition: log.h:257
void SetMargin(double margin)
Sets the frame capture margin (dB).
void SetChannel(const Ptr< SpectrumChannel > channel)
Set the SpectrumChannel this SpectrumWifiPhy is to be connected to.
This class can be used to hold variables of floating point type such as &#39;double&#39; or &#39;float&#39;...
Definition: double.h:41
Callback< R, Ts... > MakeCallback(R(T::*memPtr)(Ts...), OBJ objPtr)
Build Callbacks for class method members which take varying numbers of arguments and potentially retu...
Definition: callback.h:1642
Implements the IEEE 802.11 MAC header.
void CreateWifiSpectrumPhyInterface(Ptr< NetDevice > device)
Method to encapsulate the creation of the WifiSpectrumPhyInterface object (used to bind the WifiSpect...
void SendA(void) const
Send A function.