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// ./ns3 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// ./ns3 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// ./ns3 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
94using namespace ns3;
95
96NS_LOG_COMPONENT_DEFINE ("WifiSimpleInterference");
97
104static inline std::string PrintReceivedPacket (Ptr<Socket> socket)
105{
106 Address addr;
107
108 std::ostringstream oss;
109
110 while (socket->Recv ())
111 {
112 socket->GetSockName (addr);
113 InetSocketAddress iaddr = InetSocketAddress::ConvertFrom (addr);
114
115 oss << "Received one packet! Socket: " << iaddr.GetIpv4 () << " port: " << iaddr.GetPort ();
116 }
117
118 return oss.str ();
119}
120
126static void ReceivePacket (Ptr<Socket> socket)
127{
129}
130
140 uint32_t pktCount, Time pktInterval)
141{
142 if (pktCount > 0)
143 {
144 socket->Send (Create<Packet> (pktSize));
145 Simulator::Schedule (pktInterval, &GenerateTraffic,
146 socket, pktSize, pktCount - 1, pktInterval);
147 }
148 else
149 {
150 socket->Close ();
151 }
152}
153
154int main (int argc, char *argv[])
155{
156 std::string phyMode ("DsssRate1Mbps");
157 double Prss = -80; // -dBm
158 double Irss = -95; // -dBm
159 double delta = 0; // microseconds
160 uint32_t PpacketSize = 1000; // bytes
161 uint32_t IpacketSize = 1000; // bytes
162 bool verbose = false;
163
164 // these are not command line arguments for this version
165 uint32_t numPackets = 1;
166 double interval = 1.0; // seconds
167 double startTime = 10.0; // seconds
168 double distanceToRx = 100.0; // meters
169
170 double offset = 91; // This is a magic number used to set the
171 // transmit power, based on other configuration
172 CommandLine cmd (__FILE__);
173 cmd.AddValue ("phyMode", "Wifi Phy mode", phyMode);
174 cmd.AddValue ("Prss", "Intended primary received signal strength (dBm)", Prss);
175 cmd.AddValue ("Irss", "Intended interfering received signal strength (dBm)", Irss);
176 cmd.AddValue ("delta", "time offset (microseconds) for interfering signal", delta);
177 cmd.AddValue ("PpacketSize", "size of application packet sent", PpacketSize);
178 cmd.AddValue ("IpacketSize", "size of interfering packet sent", IpacketSize);
179 cmd.AddValue ("verbose", "turn on all WifiNetDevice log components", verbose);
180 cmd.Parse (argc, argv);
181 // Convert to time object
182 Time interPacketInterval = Seconds (interval);
183
184 // Fix non-unicast data rate to be the same as that of unicast
185 Config::SetDefault ("ns3::WifiRemoteStationManager::NonUnicastMode",
186 StringValue (phyMode));
187
189 c.Create (3);
190
191 // The below set of helpers will help us to put together the wifi NICs we want
193 if (verbose)
194 {
195 wifi.EnableLogComponents (); // Turn on all Wifi logging
196 }
197 wifi.SetStandard (WIFI_STANDARD_80211b);
198
199 YansWifiPhyHelper wifiPhy;
200
201 // ns-3 supports RadioTap and Prism tracing extensions for 802.11b
202 wifiPhy.SetPcapDataLinkType (WifiPhyHelper::DLT_IEEE802_11_RADIO);
203
204 YansWifiChannelHelper wifiChannel;
205 wifiChannel.SetPropagationDelay ("ns3::ConstantSpeedPropagationDelayModel");
206 wifiChannel.AddPropagationLoss ("ns3::LogDistancePropagationLossModel");
207 wifiPhy.SetChannel (wifiChannel.Create ());
208
209 // Add a mac and disable rate control
210 WifiMacHelper wifiMac;
211 wifi.SetRemoteStationManager ("ns3::ConstantRateWifiManager",
212 "DataMode",StringValue (phyMode),
213 "ControlMode",StringValue (phyMode));
214 // Set it to adhoc mode
215 wifiMac.SetType ("ns3::AdhocWifiMac");
216 NetDeviceContainer devices = wifi.Install (wifiPhy, wifiMac, c.Get (0));
217 // This will disable these sending devices from detecting a signal
218 // so that they do not backoff
219 wifiPhy.Set ("TxGain", DoubleValue (offset + Prss) );
220 devices.Add (wifi.Install (wifiPhy, wifiMac, c.Get (1)));
221 wifiPhy.Set ("TxGain", DoubleValue (offset + Irss) );
222 devices.Add (wifi.Install (wifiPhy, wifiMac, c.Get (2)));
223
224 // Note that with FixedRssLossModel, the positions below are not
225 // used for received signal strength.
227 Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator> ();
228 positionAlloc->Add (Vector (0.0, 0.0, 0.0));
229 positionAlloc->Add (Vector (distanceToRx, 0.0, 0.0));
230 positionAlloc->Add (Vector (-1 * distanceToRx, 0.0, 0.0));
231 mobility.SetPositionAllocator (positionAlloc);
232 mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
233 mobility.Install (c);
234
235 InternetStackHelper internet;
236 internet.Install (c);
237
238 TypeId tid = TypeId::LookupByName ("ns3::UdpSocketFactory");
239 Ptr<Socket> recvSink = Socket::CreateSocket (c.Get (0), tid);
240 InetSocketAddress local = InetSocketAddress (Ipv4Address ("10.1.1.1"), 80);
241 recvSink->Bind (local);
243
244 Ptr<Socket> source = Socket::CreateSocket (c.Get (1), tid);
245 InetSocketAddress remote = InetSocketAddress (Ipv4Address ("255.255.255.255"), 80);
246 source->SetAllowBroadcast (true);
247 source->Connect (remote);
248
249 // Interferer will send to a different port; we will not see a
250 // "Received packet" message
251 Ptr<Socket> interferer = Socket::CreateSocket (c.Get (2), tid);
252 InetSocketAddress interferingAddr = InetSocketAddress (Ipv4Address ("255.255.255.255"), 49000);
253 interferer->SetAllowBroadcast (true);
254 interferer->Connect (interferingAddr);
255
256 // Tracing
257 wifiPhy.EnablePcap ("wifi-simple-interference", devices.Get (0));
258
259 // Output what we are doing
260 NS_LOG_UNCOND ("Primary packet RSS=" << Prss << " dBm and interferer RSS=" << Irss << " dBm at time offset=" << delta << " ms");
261
262 Simulator::ScheduleWithContext (source->GetNode ()->GetId (),
263 Seconds (startTime), &GenerateTraffic,
264 source, PpacketSize, numPackets, interPacketInterval);
265
266 Simulator::ScheduleWithContext (interferer->GetNode ()->GetId (),
267 Seconds (startTime + delta / 1000000.0), &GenerateTraffic,
268 interferer, IpacketSize, numPackets, interPacketInterval);
269
271 Simulator::Destroy ();
272
273 return 0;
274}
void Run(ObjectFactory &factory, uint32_t pop, uint32_t total, uint32_t runs, Ptr< RandomVariableStream > eventStream, bool calRev)
Perform the runs for a single scheduler type.
a polymophic address class
Definition: address.h:91
Parse command-line arguments.
Definition: command-line.h:229
This class can be used to hold variables of floating point type such as 'double' or 'float'.
Definition: double.h:41
an Inet address class
uint16_t GetPort(void) const
Ipv4Address GetIpv4(void) const
aggregate IP/TCP/UDP functionality to existing Nodes.
void Install(std::string nodeName) const
Aggregate implementations of the ns3::Ipv4, ns3::Ipv6, ns3::Udp, and ns3::Tcp classes onto the provid...
Ipv4 addresses are stored in host order in this class.
Definition: ipv4-address.h:41
Helper class used to assign positions and mobility models to nodes.
holds a vector of ns3::NetDevice pointers
keep track of a set of node pointers.
void Create(uint32_t n)
Create n nodes and append pointers to them to the end of this NodeContainer.
Ptr< Node > Get(uint32_t i) const
Get the Ptr<Node> stored in this container at a given index.
uint32_t GetId(void) const
Definition: node.cc:109
void EnablePcap(std::string prefix, Ptr< NetDevice > nd, bool promiscuous=false, bool explicitFilename=false)
Enable pcap output the indicated net device.
virtual int Send(Ptr< Packet > p, uint32_t flags)=0
Send data (or dummy data) to the remote host.
virtual bool SetAllowBroadcast(bool allowBroadcast)=0
Configure whether broadcast datagram transmissions are allowed.
virtual Ptr< Node > GetNode(void) const =0
Return the node this socket is associated with.
virtual int Connect(const Address &address)=0
Initiate a connection to a remote host.
virtual int GetSockName(Address &address) const =0
Get socket address.
virtual int Close(void)=0
Close a socket.
void SetRecvCallback(Callback< void, Ptr< Socket > > receivedData)
Notify application when new data is available to be read.
Definition: socket.cc:128
virtual Ptr< Packet > Recv(uint32_t maxSize, uint32_t flags)=0
Read data from the socket.
virtual int Bind(const Address &address)=0
Allocate a local endpoint for this socket.
Hold variables of type string.
Definition: string.h:41
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:104
a unique identifier for an interface.
Definition: type-id.h:59
Vector3D Vector
Vector alias typedef for compatibility with mobility models.
Definition: vector.h:324
helps to create WifiNetDevice objects
Definition: wifi-helper.h:322
create MAC layers for a ns3::WifiNetDevice.
void SetType(std::string type, Args &&... args)
void SetPcapDataLinkType(SupportedPcapDataLinkTypes dlt)
Set the data link type of PCAP traces to be used.
Definition: wifi-helper.cc:538
void Set(std::string name, const AttributeValue &v)
Definition: wifi-helper.cc:162
manage and create wifi channel objects for the YANS model.
Ptr< YansWifiChannel > Create(void) const
void SetPropagationDelay(std::string name, Ts &&... args)
void AddPropagationLoss(std::string name, Ts &&... args)
Make it easy to create and manage PHY objects for the YANS model.
void SetChannel(Ptr< YansWifiChannel > channel)
void SetDefault(std::string name, const AttributeValue &value)
Definition: config.cc:849
#define NS_LOG_UNCOND(msg)
Output the requested message unconditionally.
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:205
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1245
@ WIFI_STANDARD_80211b
devices
Definition: first.py:35
Every class exported by the ns3 library is enclosed in the ns3 namespace.
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:661
cmd
Definition: second.py:43
wifi
Definition: third.py:90
mobility
Definition: third.py:98
bool verbose
uint32_t pktSize
packet size used for the simulation (in bytes)
Definition: wifi-bianchi.cc:90
static void ReceivePacket(Ptr< Socket > socket)
Function called when a packet is received.
static void GenerateTraffic(Ptr< Socket > socket, uint32_t pktSize, uint32_t pktCount, Time pktInterval)
Generate traffic.
static std::string PrintReceivedPacket(Ptr< Socket > socket)
Print a packer that has been received.