Created
June 30, 2012 13:31
-
-
Save anonymous/3023757 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */ | |
/* | |
* Copyright (c) 2009 University of Washington | |
* | |
* 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 | |
* | |
*/ | |
// | |
// This program configures a grid (default 5x5) of nodes on an | |
// 802.11b physical layer, with | |
// 802.11b NICs in adhoc mode, and by default, sends one packet of 1000 | |
// (application) bytes to node 1. | |
// | |
// The default layout is like this, on a 2-D grid. | |
// | |
// n20 n21 n22 n23 n24 | |
// n15 n16 n17 n18 n19 | |
// n10 n11 n12 n13 n14 | |
// n5 n6 n7 n8 n9 | |
// n0 n1 n2 n3 n4 | |
// | |
// the layout is affected by the parameters given to GridPositionAllocator; | |
// by default, GridWidth is 5 and numNodes is 25.. | |
// | |
// There are a number of command-line options available to control | |
// the default behavior. The list of available command-line options | |
// can be listed with the following command: | |
// ./waf --run "wifi-simple-adhoc-grid --help" | |
// | |
// Note that all ns-3 attributes (not just the ones exposed in the below | |
// script) can be changed at command line; see the ns-3 documentation. | |
// | |
// For instance, for this configuration, the physical layer will | |
// stop successfully receiving packets when distance increases beyond | |
// the default of 500m. | |
// To see this effect, try running: | |
// | |
// ./waf --run "wifi-simple-adhoc --distance=500" | |
// ./waf --run "wifi-simple-adhoc --distance=1000" | |
// ./waf --run "wifi-simple-adhoc --distance=1500" | |
// | |
// The source node and sink node can be changed like this: | |
// | |
// ./waf --run "wifi-simple-adhoc --sourceNode=20 --sinkNode=10" | |
// | |
// This script can also be helpful to put the Wifi layer into verbose | |
// logging mode; this command will turn on all wifi logging: | |
// | |
// ./waf --run "wifi-simple-adhoc-grid --verbose=1" | |
// | |
// By default, trace file writing is off-- to enable it, try: | |
// ./waf --run "wifi-simple-adhoc-grid --tracing=1" | |
// | |
// When you are done tracing, you will notice many pcap trace files | |
// in your directory. If you have tcpdump installed, you can try this: | |
// | |
// tcpdump -r wifi-simple-adhoc-grid-0-0.pcap -nn -tt | |
// | |
#include "ns3/core-module.h" | |
#include "ns3/network-module.h" | |
#include "ns3/mobility-module.h" | |
#include "ns3/config-store-module.h" | |
#include "ns3/wifi-module.h" | |
#include "ns3/internet-module.h" | |
#include "ns3/aodv-helper.h" | |
#include "ns3/ipv4-static-routing-helper.h" | |
#include "ns3/ipv4-list-routing-helper.h" | |
#include <iostream> | |
#include <fstream> | |
#include <vector> | |
#include <string> | |
NS_LOG_COMPONENT_DEFINE ("WifiAdhoc"); | |
using namespace ns3; | |
void ReceivePacket (Ptr<Socket> socket) | |
{ | |
NS_LOG_UNCOND ("Received one packet!"); | |
} | |
static void GenerateTraffic (Ptr<Socket> socket, uint32_t pktSize, | |
uint32_t pktCount, Time pktInterval ) | |
{ | |
if (pktCount > 0) | |
{ | |
socket->Send (Create<Packet> (pktSize)); | |
std::cerr << "Sent packed " << pktSize << " " << pktCount << " " << pktInterval << std::endl; | |
Simulator::Schedule (pktInterval, &GenerateTraffic, | |
socket, pktSize, pktCount-1, pktInterval); | |
} | |
else | |
{ | |
socket->Close (); | |
} | |
} | |
int main (int argc, char *argv[]) | |
{ | |
std::string phyMode ("DsssRate1Mbps"); | |
double distance = 100; // m | |
uint32_t packetSize = 1460; // bytes | |
uint32_t numPackets = 3; | |
uint32_t numNodes = 2; | |
uint32_t sinkNode = 0; | |
uint32_t sourceNode = numNodes-1; | |
double interval = 1.0; // seconds | |
bool verbose = false; | |
bool tracing = true; | |
CommandLine cmd; | |
cmd.AddValue ("phyMode", "Wifi Phy mode", phyMode); | |
cmd.AddValue ("distance", "distance (m)", distance); | |
cmd.AddValue ("packetSize", "size of application packet sent", packetSize); | |
cmd.AddValue ("numPackets", "number of packets generated", numPackets); | |
cmd.AddValue ("interval", "interval (seconds) between packets", interval); | |
cmd.AddValue ("verbose", "turn on all WifiNetDevice log components", verbose); | |
cmd.AddValue ("tracing", "turn on ascii and pcap tracing", tracing); | |
cmd.AddValue ("numNodes", "number of nodes", numNodes); | |
cmd.AddValue ("sinkNode", "Receiver node number", sinkNode); | |
cmd.AddValue ("sourceNode", "Sender node number", sourceNode); | |
cmd.Parse (argc, argv); | |
// Convert to time object | |
Time interPacketInterval = Seconds (interval); | |
// disable fragmentation for frames below 2200 bytes | |
//Config::SetDefault ("ns3::WifiRemoteStationManager::FragmentationThreshold", StringValue ("2200")); | |
// turn off RTS/CTS for frames below 2200 bytes | |
//Config::SetDefault ("ns3::WifiRemoteStationManager::RtsCtsThreshold", StringValue ("2200")); | |
// Fix non-unicast data rate to be the same as that of unicast | |
Config::SetDefault ("ns3::WifiRemoteStationManager::NonUnicastMode", | |
StringValue (phyMode)); | |
NodeContainer c; | |
c.Create (numNodes); | |
// The below set of helpers will help us to put together the wifi NICs we want | |
WifiHelper wifi; | |
if (verbose) | |
wifi.EnableLogComponents (); // Turn on all Wifi logging | |
YansWifiPhyHelper wifiPhy = YansWifiPhyHelper::Default (); | |
// set it to zero; otherwise, gain will be added | |
wifiPhy.Set ("RxGain", DoubleValue (-10) ); | |
// ns-3 supports RadioTap and Prism tracing extensions for 802.11g | |
// but we just use IEEE 802.11 Wireless LAN headers on packets | |
// else use DLT_IEEE802_11_RADIO | |
wifiPhy.SetPcapDataLinkType (YansWifiPhyHelper::DLT_IEEE802_11); | |
YansWifiChannelHelper wifiChannel; | |
wifiChannel.SetPropagationDelay ("ns3::ConstantSpeedPropagationDelayModel"); | |
wifiChannel.AddPropagationLoss ("ns3::FriisPropagationLossModel"); | |
wifiPhy.SetChannel (wifiChannel.Create ()); | |
// Add a non-QoS upper mac, and disable rate control | |
NqosWifiMacHelper wifiMac = NqosWifiMacHelper::Default (); | |
wifi.SetStandard (WIFI_PHY_STANDARD_80211g); | |
wifi.SetRemoteStationManager ("ns3::MinstrelWifiManager"); | |
//"DataMode",StringValue (phyMode), | |
//"ControlMode",StringValue (phyMode)); | |
// Set it to adhoc mode | |
wifiMac.SetType ("ns3::AdhocWifiMac"); | |
NetDeviceContainer devices = wifi.Install (wifiPhy, wifiMac, c); | |
MobilityHelper mobility; | |
mobility.SetPositionAllocator ("ns3::GridPositionAllocator", | |
"MinX", DoubleValue (0.0), | |
"MinY", DoubleValue (0.0), | |
"DeltaX", DoubleValue (distance), | |
"DeltaY", DoubleValue (0), | |
"GridWidth", UintegerValue (1), | |
"LayoutType", StringValue ("RowFirst")); | |
mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel"); | |
mobility.Install (c); | |
// Enable AODV | |
AodvHelper aodv; | |
Ipv4StaticRoutingHelper staticRouting; | |
Ipv4ListRoutingHelper list; | |
list.Add (staticRouting, 0); | |
list.Add (aodv, 10); | |
InternetStackHelper internet; | |
internet.SetRoutingHelper (list); // has effect on the next Install () | |
internet.Install (c); | |
Ipv4AddressHelper ipv4; | |
NS_LOG_INFO ("Assign IP Addresses."); | |
ipv4.SetBase ("10.0.0.0", "255.255.255.0"); | |
Ipv4InterfaceContainer i = ipv4.Assign (devices); | |
TypeId tid = ns3::TcpSocketFactory::GetTypeId(); | |
Ptr<Socket> recvSink = Socket::CreateSocket (c.Get (sinkNode), tid); | |
InetSocketAddress local = InetSocketAddress (Ipv4Address::GetAny (), 80); | |
recvSink->Bind (local); | |
recvSink->SetRecvCallback (MakeCallback (&ReceivePacket)); | |
Ptr<Socket> source = Socket::CreateSocket (c.Get (sourceNode), tid); | |
InetSocketAddress remote = InetSocketAddress (i.GetAddress (sinkNode, 0), 80); | |
// source->Connect (remote); | |
if (tracing == true) | |
{ | |
AsciiTraceHelper ascii; | |
wifiPhy.EnableAsciiAll (ascii.CreateFileStream ("wifi-multihop.tr")); | |
wifiPhy.EnablePcap ("wifi-multihop", devices); | |
// Trace routing tables | |
Ptr<OutputStreamWrapper> routingStream = Create<OutputStreamWrapper> ("wifi-multihop.routes", std::ios::out); | |
aodv.PrintRoutingTableAllEvery (Seconds (2), routingStream); | |
} | |
// Give AODV time to converge-- 30 seconds perhaps | |
Simulator::Schedule (Seconds (30.0), &GenerateTraffic, | |
source, packetSize, numPackets, interPacketInterval); | |
Simulator::Schedule (Seconds (30.5), &ns3::Socket::Connect, source, | |
remote); | |
// Output what we are doing | |
NS_LOG_UNCOND ("Testing from node " << sourceNode << " to " << sinkNode << " with grid distance " << distance); | |
Simulator::Stop (Seconds (31.0 + interval * numPackets)); | |
Simulator::Run (); | |
Simulator::Destroy (); | |
return 0; | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment