A Discrete-Event Network Simulator
API
wifi-simple-interference.cc
Go to the documentation of this file.
1 /* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * Copyright (c) 2009 The Boeing Company
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  */
19 
20 // This script configures three nodes on an 802.11b physical layer, with
21 // 802.11b NICs in adhoc mode. There is a transmitter, receiver, and
22 // interferer. The transmitter sends one packet to the receiver and
23 // the receiver receives it with a certain configurable RSS (by default,
24 // -80 dBm). The interferer does not do carrier sense and also sends
25 // the packet to interfere with the primary packet. The channel model
26 // is clear channel.
27 //
28 // Therefore, at the receiver, the reception looks like this:
29 //
30 // ------------------time---------------->
31 // t0
32 //
33 // |------------------------------------|
34 // | |
35 // | primary received frame (time t0) |
36 // | |
37 // |------------------------------------|
38 //
39 //
40 // t1
41 // |-----------------------------------|
42 // | |
43 // | interfering frame (time t1) |
44 // | |
45 // |-----------------------------------|
46 //
47 // The orientation is:
48 // n2 ---------> n0 <---------- n1
49 // interferer receiver transmitter
50 //
51 // The configurable parameters are:
52 // - Prss (primary rss) (-80 dBm default)
53 // - Irss (interfering rss) (-95 dBm default)
54 // - delta (microseconds, (t1-t0), may be negative, default 0)
55 // - PpacketSize (primary packet size) (bytes, default 1000)
56 // - IpacketSize (interferer packet size) (bytes, default 1000)
57 //
58 // For instance, for this configuration, the interfering frame arrives
59 // at -90 dBm with a time offset of 3.2 microseconds:
60 //
61 // ./waf --run "wifi-simple-interference --Irss=-90 --delta=3.2"
62 //
63 // Note that all ns-3 attributes (not just the ones exposed in the below
64 // script) can be changed at command line; see the documentation.
65 //
66 // This script can also be helpful to put the Wifi layer into verbose
67 // logging mode; this command will turn on all wifi logging:
68 //
69 // ./waf --run "wifi-simple-interference --verbose=1"
70 //
71 // When you are done, you will notice a pcap trace file in your directory.
72 // If you have tcpdump installed, you can try this:
73 //
74 // tcpdump -r wifi-simple-interference-0-0.pcap -nn -tt
75 // reading from file wifi-simple-interference-0-0.pcap, link-type IEEE802_11_RADIO (802.11 plus BSD radio information header)
76 // 10.008704 10008704us tsft 1.0 Mb/s 2437 MHz (0x00c0) -80dB signal -98dB noise IP 10.1.1.2.49153 > 10.1.1.255.80: UDP, length 1000
77 //
78 // Next, try this command and look at the tcpdump-- you should see two packets
79 // that are no longer interfering:
80 // ./waf --run "wifi-simple-interference --delta=30000"
81 
82 #include "ns3/command-line.h"
83 #include "ns3/config.h"
84 #include "ns3/double.h"
85 #include "ns3/string.h"
86 #include "ns3/log.h"
87 #include "ns3/yans-wifi-helper.h"
88 #include "ns3/ssid.h"
89 #include "ns3/mobility-helper.h"
90 #include "ns3/yans-wifi-channel.h"
91 #include "ns3/mobility-model.h"
92 #include "ns3/internet-stack-helper.h"
93 
94 using namespace ns3;
95 
96 NS_LOG_COMPONENT_DEFINE ("WifiSimpleInterference");
97 
98 static inline std::string PrintReceivedPacket (Ptr<Socket> socket)
99 {
100  Address addr;
101 
102  std::ostringstream oss;
103 
104  while (socket->Recv ())
105  {
106  socket->GetSockName (addr);
108 
109  oss << "Received one packet! Socket: " << iaddr.GetIpv4 () << " port: " << iaddr.GetPort ();
110  }
111 
112  return oss.str ();
113 }
114 
115 static void ReceivePacket (Ptr<Socket> socket)
116 {
118 }
119 
120 static void GenerateTraffic (Ptr<Socket> socket, uint32_t pktSize,
121  uint32_t pktCount, Time pktInterval )
122 {
123  if (pktCount > 0)
124  {
125  socket->Send (Create<Packet> (pktSize));
126  Simulator::Schedule (pktInterval, &GenerateTraffic,
127  socket, pktSize,pktCount - 1, pktInterval);
128  }
129  else
130  {
131  socket->Close ();
132  }
133 }
134 
135 int main (int argc, char *argv[])
136 {
137  std::string phyMode ("DsssRate1Mbps");
138  double Prss = -80; // -dBm
139  double Irss = -95; // -dBm
140  double delta = 0; // microseconds
141  uint32_t PpacketSize = 1000; // bytes
142  uint32_t IpacketSize = 1000; // bytes
143  bool verbose = false;
144 
145  // these are not command line arguments for this version
146  uint32_t numPackets = 1;
147  double interval = 1.0; // seconds
148  double startTime = 10.0; // seconds
149  double distanceToRx = 100.0; // meters
150 
151  double offset = 91; // This is a magic number used to set the
152  // transmit power, based on other configuration
154  cmd.AddValue ("phyMode", "Wifi Phy mode", phyMode);
155  cmd.AddValue ("Prss", "Intended primary received signal strength (dBm)", Prss);
156  cmd.AddValue ("Irss", "Intended interfering received signal strength (dBm)", Irss);
157  cmd.AddValue ("delta", "time offset (microseconds) for interfering signal", delta);
158  cmd.AddValue ("PpacketSize", "size of application packet sent", PpacketSize);
159  cmd.AddValue ("IpacketSize", "size of interfering packet sent", IpacketSize);
160  cmd.AddValue ("verbose", "turn on all WifiNetDevice log components", verbose);
161  cmd.Parse (argc, argv);
162  // Convert to time object
163  Time interPacketInterval = Seconds (interval);
164 
165  // Fix non-unicast data rate to be the same as that of unicast
166  Config::SetDefault ("ns3::WifiRemoteStationManager::NonUnicastMode",
167  StringValue (phyMode));
168 
169  NodeContainer c;
170  c.Create (3);
171 
172  // The below set of helpers will help us to put together the wifi NICs we want
174  if (verbose)
175  {
176  wifi.EnableLogComponents (); // Turn on all Wifi logging
177  }
178  wifi.SetStandard (WIFI_PHY_STANDARD_80211b);
179 
181 
182  // ns-3 supports RadioTap and Prism tracing extensions for 802.11b
184 
185  YansWifiChannelHelper wifiChannel;
186  wifiChannel.SetPropagationDelay ("ns3::ConstantSpeedPropagationDelayModel");
187  wifiChannel.AddPropagationLoss ("ns3::LogDistancePropagationLossModel");
188  wifiPhy.SetChannel (wifiChannel.Create ());
189 
190  // Add a mac and disable rate control
191  WifiMacHelper wifiMac;
192  wifi.SetRemoteStationManager ("ns3::ConstantRateWifiManager",
193  "DataMode",StringValue (phyMode),
194  "ControlMode",StringValue (phyMode));
195  // Set it to adhoc mode
196  wifiMac.SetType ("ns3::AdhocWifiMac");
197  NetDeviceContainer devices = wifi.Install (wifiPhy, wifiMac, c.Get (0));
198  // This will disable these sending devices from detecting a signal
199  // so that they do not backoff
200  wifiPhy.Set ("TxGain", DoubleValue (offset + Prss) );
201  devices.Add (wifi.Install (wifiPhy, wifiMac, c.Get (1)));
202  wifiPhy.Set ("TxGain", DoubleValue (offset + Irss) );
203  devices.Add (wifi.Install (wifiPhy, wifiMac, c.Get (2)));
204 
205  // Note that with FixedRssLossModel, the positions below are not
206  // used for received signal strength.
208  Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator> ();
209  positionAlloc->Add (Vector (0.0, 0.0, 0.0));
210  positionAlloc->Add (Vector (distanceToRx, 0.0, 0.0));
211  positionAlloc->Add (Vector (-1 * distanceToRx, 0.0, 0.0));
212  mobility.SetPositionAllocator (positionAlloc);
213  mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
214  mobility.Install (c);
215 
216  InternetStackHelper internet;
217  internet.Install (c);
218 
219  TypeId tid = TypeId::LookupByName ("ns3::UdpSocketFactory");
220  Ptr<Socket> recvSink = Socket::CreateSocket (c.Get (0), tid);
221  InetSocketAddress local = InetSocketAddress (Ipv4Address ("10.1.1.1"), 80);
222  recvSink->Bind (local);
224 
225  Ptr<Socket> source = Socket::CreateSocket (c.Get (1), tid);
226  InetSocketAddress remote = InetSocketAddress (Ipv4Address ("255.255.255.255"), 80);
227  source->SetAllowBroadcast (true);
228  source->Connect (remote);
229 
230  // Interferer will send to a different port; we will not see a
231  // "Received packet" message
232  Ptr<Socket> interferer = Socket::CreateSocket (c.Get (2), tid);
233  InetSocketAddress interferingAddr = InetSocketAddress (Ipv4Address ("255.255.255.255"), 49000);
234  interferer->SetAllowBroadcast (true);
235  interferer->Connect (interferingAddr);
236 
237  // Tracing
238  wifiPhy.EnablePcap ("wifi-simple-interference", devices.Get (0));
239 
240  // Output what we are doing
241  NS_LOG_UNCOND ("Primary packet RSS=" << Prss << " dBm and interferer RSS=" << Irss << " dBm at time offset=" << delta << " ms");
242 
245  source, PpacketSize, numPackets, interPacketInterval);
246 
247  Simulator::ScheduleWithContext (interferer->GetNode ()->GetId (),
248  Seconds (startTime + delta / 1000000.0), &GenerateTraffic,
249  interferer, IpacketSize, numPackets, interPacketInterval);
250 
251  Simulator::Run ();
253 
254  return 0;
255 }
void AddPropagationLoss(std::string name, std::string n0="", const AttributeValue &v0=EmptyAttributeValue(), std::string n1="", const AttributeValue &v1=EmptyAttributeValue(), std::string n2="", const AttributeValue &v2=EmptyAttributeValue(), std::string n3="", const AttributeValue &v3=EmptyAttributeValue(), std::string n4="", const AttributeValue &v4=EmptyAttributeValue(), std::string n5="", const AttributeValue &v5=EmptyAttributeValue(), std::string n6="", const AttributeValue &v6=EmptyAttributeValue(), std::string n7="", const AttributeValue &v7=EmptyAttributeValue())
void Set(std::string name, const AttributeValue &v)
Definition: wifi-helper.cc:142
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:102
an Inet address class
uint32_t GetId(void) const
Definition: node.cc:107
Hold variables of type string.
Definition: string.h:41
virtual bool SetAllowBroadcast(bool allowBroadcast)=0
Configure whether broadcast datagram transmissions are allowed.
Make it easy to create and manage PHY objects for the yans model.
static void Run(void)
Run the simulation.
Definition: simulator.cc:170
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:204
virtual int GetSockName(Address &address) const =0
Get socket address.
aggregate IP/TCP/UDP functionality to existing Nodes.
cmd
Definition: second.py:35
static YansWifiPhyHelper Default(void)
Create a phy helper in a default working state.
helps to create WifiNetDevice objects
Definition: wifi-helper.h:299
a polymophic address class
Definition: address.h:90
Ptr< YansWifiChannel > Create(void) const
mobility
Definition: third.py:108
void SetChannel(Ptr< YansWifiChannel > channel)
static EventId Schedule(Time const &delay, MEM mem_ptr, OBJ obj)
Schedule an event to expire after delay.
Definition: simulator.h:1389
double startTime
holds a vector of ns3::NetDevice pointers
Callback< R > MakeCallback(R(T::*memPtr)(void), OBJ objPtr)
Definition: callback.h:1489
void SetRecvCallback(Callback< void, Ptr< Socket > >)
Notify application when new data is available to be read.
Definition: socket.cc:128
static Ptr< Socket > CreateSocket(Ptr< Node > node, TypeId tid)
This method wraps the creation of sockets that is performed on a given node by a SocketFactory specif...
Definition: socket.cc:71
Parse command-line arguments.
Definition: command-line.h:213
static void Destroy(void)
Execute the events scheduled with ScheduleDestroy().
Definition: simulator.cc:134
virtual int Connect(const Address &address)=0
Initiate a connection to a remote host.
virtual int Bind(const Address &address)=0
Allocate a local endpoint for this socket.
Every class exported by the ns3 library is enclosed in the ns3 namespace.
static InetSocketAddress ConvertFrom(const Address &address)
Returns an InetSocketAddress which corresponds to the input Address.
keep track of a set of node pointers.
virtual Ptr< Packet > Recv(uint32_t maxSize, uint32_t flags)=0
Read data from the socket.
DSSS PHY (Clause 15) and HR/DSSS PHY (Clause 18)
uint16_t GetPort(void) const
#define NS_LOG_UNCOND(msg)
Output the requested message unconditionally.
manage and create wifi channel objects for the yans model.
create MAC layers for a ns3::WifiNetDevice.
void SetPcapDataLinkType(SupportedPcapDataLinkTypes dlt)
Set the data link type of PCAP traces to be used.
Definition: wifi-helper.cc:513
virtual void SetType(std::string type, std::string n0="", const AttributeValue &v0=EmptyAttributeValue(), std::string n1="", const AttributeValue &v1=EmptyAttributeValue(), std::string n2="", const AttributeValue &v2=EmptyAttributeValue(), std::string n3="", const AttributeValue &v3=EmptyAttributeValue(), std::string n4="", const AttributeValue &v4=EmptyAttributeValue(), std::string n5="", const AttributeValue &v5=EmptyAttributeValue(), std::string n6="", const AttributeValue &v6=EmptyAttributeValue(), std::string n7="", const AttributeValue &v7=EmptyAttributeValue(), std::string n8="", const AttributeValue &v8=EmptyAttributeValue(), std::string n9="", const AttributeValue &v9=EmptyAttributeValue(), std::string n10="", const AttributeValue &v10=EmptyAttributeValue())
void Install(std::string nodeName) const
Aggregate implementations of the ns3::Ipv4, ns3::Ipv6, ns3::Udp, and ns3::Tcp classes onto the provid...
wifi
Definition: third.py:96
Helper class used to assign positions and mobility models to nodes.
static void ScheduleWithContext(uint32_t context, Time const &delay, MEM mem_ptr, OBJ obj)
Schedule an event with the given context.
Definition: simulator.h:1483
Ipv4 addresses are stored in host order in this class.
Definition: ipv4-address.h:40
static std::string PrintReceivedPacket(Ptr< Socket > socket)
virtual Ptr< Node > GetNode(void) const =0
Return the node this socket is associated with.
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1062
void SetDefault(std::string name, const AttributeValue &value)
Definition: config.cc:810
static void GenerateTraffic(Ptr< Socket > socket, uint32_t pktSize, uint32_t pktCount, Time pktInterval)
void Add(Vector v)
Add a position to the list of positions.
Ptr< Node > Get(uint32_t i) const
Get the Ptr<Node> stored in this container at a given index.
void Create(uint32_t n)
Create n nodes and append pointers to them to the end of this NodeContainer.
static void ReceivePacket(Ptr< Socket > socket)
void SetPropagationDelay(std::string name, std::string n0="", const AttributeValue &v0=EmptyAttributeValue(), std::string n1="", const AttributeValue &v1=EmptyAttributeValue(), std::string n2="", const AttributeValue &v2=EmptyAttributeValue(), std::string n3="", const AttributeValue &v3=EmptyAttributeValue(), std::string n4="", const AttributeValue &v4=EmptyAttributeValue(), std::string n5="", const AttributeValue &v5=EmptyAttributeValue(), std::string n6="", const AttributeValue &v6=EmptyAttributeValue(), std::string n7="", const AttributeValue &v7=EmptyAttributeValue())
void EnablePcap(std::string prefix, Ptr< NetDevice > nd, bool promiscuous=false, bool explicitFilename=false)
Enable pcap output the indicated net device.
devices
Definition: first.py:32
virtual int Send(Ptr< Packet > p, uint32_t flags)=0
Send data (or dummy data) to the remote host.
virtual int Close(void)=0
Close a socket.
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
a unique identifier for an interface.
Definition: type-id.h:58
Include Radiotap link layer information.
Definition: wifi-helper.h:178
Ipv4Address GetIpv4(void) const
bool verbose
static TypeId LookupByName(std::string name)
Get a TypeId by name.
Definition: type-id.cc:824