def _add_onoff_app(self, start_time, end_time, local, remote, on_time, off_time, data_rate, sport, dport): """add one ns3 onoff application to the network """ # ignore the network prefix length if there is if '/' in remote: remote = remote.rsplit('/')[0] if '/' in local: local = local.rsplit('/')[0] ### Install OnOff Application ### socketType = "ns3::UdpSocketFactory" # socketType = "ns3::TcpSocketFactory" helper = ns3.OnOffHelper(socketType, ns3.InetSocketAddress(remote, dport)) helper.SetAttribute("StartTime", ns3.TimeValue(ns3.Time(str(start_time) + 's'))) helper.SetAttribute("StopTime", ns3.TimeValue(ns3.Time(str(end_time) + 's'))) # helper.SetAttribute("Remote", ns3.AddressValue(ns3.Ipv4Address(remote))) local_inet = ns3.InetSocketAddress(local, sport) helper.SetAttribute("Local", ns3.AddressValue(local_inet)) helper.SetAttribute("DataRate", ns3.StringValue(str(data_rate) + 'b/s')) helper.SetAttribute("OnTime", ns3.RandomVariableValue(on_time.to_ns3())) helper.SetAttribute("OffTime", ns3.RandomVariableValue(off_time.to_ns3())) print('local, ', local) local_node = self.net.search_node(local) helper.Install(local_node) ### Install Sink Application #### sinkLocalAddress = ns3.Address( ns3.InetSocketAddress(ns3.Ipv4Address.GetAny(), dport)) sinkHelper = ns3.PacketSinkHelper(socketType, sinkLocalAddress) helper.SetAttribute("StartTime", ns3.TimeValue(ns3.Time(str(start_time) + 's'))) helper.SetAttribute("StopTime", ns3.TimeValue(ns3.Time(str(end_time) + 's'))) remote_node = self.net.search_node(remote) print('remote, ', remote) sinkHelper.Install(remote_node) print("""add an onoff application with start_time: %f end_time: %f local: %s, remote: %s, on_time: %s, off_time: %s""" % (start_time, end_time, local, remote, on_time, off_time))
def onoff_app(network, client_node, server_node, server_device, start, stop, rate, port=9, packet_size=1024, access_class=None, ontime=1, offtime=0): """Set up a OnOff client + sink server.""" server = network.nodes[server_node] assert server_device in server.devices, \ "Device '%s' not found, available: %s" % (server_device, ", ".join(server.devices)) server_address = server.devices[server_device].interfaces[0].address local_address = ns3.InetSocketAddress(ns3.Ipv4Address.GetAny(), port) sink_helper = ns3.PacketSinkHelper("ns3::UdpSocketFactory", local_address) server_apps = sink_helper.Install(server.ns3_node) server_apps.Start(ns3.Seconds(start)) server_apps.Stop(ns3.Seconds(stop)) client = network.nodes[client_node] remote_address = ns3.InetSocketAddress(server_address, port) onoff_helper = ns3.OnOffHelper("ns3::UdpSocketFactory", ns3.Address()) onoff_helper.SetAttribute( "OnTime", ns3.RandomVariableValue(ns3.ConstantVariable(ontime))) onoff_helper.SetAttribute( "OffTime", ns3.RandomVariableValue(ns3.ConstantVariable(offtime))) onoff_helper.SetAttribute("DataRate", ns3.DataRateValue(ns3.DataRate(rate))) onoff_helper.SetAttribute("PacketSize", ns3.UintegerValue(packet_size)) onoff_helper.SetAttribute("Remote", ns3.AddressValue(remote_address)) # Set QoS Access Class -> Tid # Note that this only works with a patched OnOffApplication with QosTid attribute if access_class is not None: access_class_to_qos_tid = { "ac_vo": 6, # AC_VO (Tid: 6, 7) "ac_vi": 4, # AC_VI (Tid: 4, 5) "ac_be": 0, # AC_BE (Tid: 0) "ac_bk": 1, # AC_BK (Tid: 1, 2) "ac_be_nqos": 3, # AC_BE_NQOS (Tid: 3) } qos_tid = access_class_to_qos_tid[access_class.lower()] onoff_helper.SetAttribute("QosTid", ns3.UintegerValue(qos_tid)) client_apps = onoff_helper.Install(client.ns3_node) client_apps.Start(ns3.Seconds(start)) client_apps.Stop(ns3.Seconds(stop))
def main(argv): # # First, we declare and initialize a few local variables that control some # simulation parameters. # backboneNodes = 10 infraNodes = 5 lanNodes = 5 stopTime = 10 # # Simulation defaults are typically set next, before command line # arguments are parsed. # ns3.Config.SetDefault("ns3::OnOffApplication::PacketSize", ns3.StringValue("210")) ns3.Config.SetDefault("ns3::OnOffApplication::DataRate", ns3.StringValue("448kb/s")) # # For convenience, we add the local variables to the command line argument # system so that they can be overridden with flags such as # "--backboneNodes=20" # cmd = ns3.CommandLine() #cmd.AddValue("backboneNodes", "number of backbone nodes", backboneNodes) #cmd.AddValue("infraNodes", "number of leaf nodes", infraNodes) #cmd.AddValue("lanNodes", "number of LAN nodes", lanNodes) #cmd.AddValue("stopTime", "simulation stop time(seconds)", stopTime) # # The system global variables and the local values added to the argument # system can be overridden by command line arguments by using this call. # cmd.Parse(argv) # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # / # # # Construct the backbone # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # / # # Create a container to manage the nodes of the adhoc(backbone) network. # Later we'll create the rest of the nodes we'll need. # backbone = ns3.NodeContainer() backbone.Create(backboneNodes) # # Create the backbone wifi net devices and install them into the nodes in # our container # wifi = ns3.WifiHelper() mac = ns3.NqosWifiMacHelper.Default() mac.SetType("ns3::AdhocWifiMac") wifi.SetRemoteStationManager("ns3::ConstantRateWifiManager", "DataMode", ns3.StringValue("OfdmRate54Mbps")) wifiPhy = ns3.YansWifiPhyHelper.Default() wifiChannel = ns3.YansWifiChannelHelper.Default() wifiPhy.SetChannel(wifiChannel.Create()) backboneDevices = wifi.Install(wifiPhy, mac, backbone) # # Add the IPv4 protocol stack to the nodes in our container # print "Enabling OLSR routing on all backbone nodes" internet = ns3.InternetStackHelper() olsr = ns3.OlsrHelper() internet.SetRoutingHelper(olsr) internet.Install(backbone) # re-initialize for non-olsr routing. internet.Reset() # # Assign IPv4 addresses to the device drivers(actually to the associated # IPv4 interfaces) we just created. # ipAddrs = ns3.Ipv4AddressHelper() ipAddrs.SetBase(ns3.Ipv4Address("192.168.0.0"), ns3.Ipv4Mask("255.255.255.0")) ipAddrs.Assign(backboneDevices) # # The ad-hoc network nodes need a mobility model so we aggregate one to # each of the nodes we just finished building. # mobility = ns3.MobilityHelper() positionAlloc = ns3.ListPositionAllocator() x = 0.0 for i in range(backboneNodes): positionAlloc.Add(ns3.Vector(x, 0.0, 0.0)) x += 5.0 mobility.SetPositionAllocator(positionAlloc) mobility.SetMobilityModel( "ns3::RandomDirection2dMobilityModel", "Bounds", ns3.RectangleValue(ns3.Rectangle(0, 1000, 0, 1000)), "Speed", ns3.RandomVariableValue(ns3.ConstantVariable(2000)), "Pause", ns3.RandomVariableValue(ns3.ConstantVariable(0.2))) mobility.Install(backbone) # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # / # # # Construct the LANs # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # / # Reset the address base-- all of the CSMA networks will be in # the "172.16 address space ipAddrs.SetBase(ns3.Ipv4Address("172.16.0.0"), ns3.Ipv4Mask("255.255.255.0")) for i in range(backboneNodes): print "Configuring local area network for backbone node ", i # # Create a container to manage the nodes of the LAN. We need # two containers here; one with all of the new nodes, and one # with all of the nodes including new and existing nodes # newLanNodes = ns3.NodeContainer() newLanNodes.Create(lanNodes - 1) # Now, create the container with all nodes on this link lan = ns3.NodeContainer(ns3.NodeContainer(backbone.Get(i)), newLanNodes) # # Create the CSMA net devices and install them into the nodes in our # collection. # csma = ns3.CsmaHelper() csma.SetChannelAttribute("DataRate", ns3.DataRateValue(ns3.DataRate(5000000))) csma.SetChannelAttribute("Delay", ns3.TimeValue(ns3.MilliSeconds(2))) lanDevices = csma.Install(lan) # # Add the IPv4 protocol stack to the new LAN nodes # internet.Install(newLanNodes) # # Assign IPv4 addresses to the device drivers(actually to the # associated IPv4 interfaces) we just created. # ipAddrs.Assign(lanDevices) # # Assign a new network prefix for the next LAN, according to the # network mask initialized above # ipAddrs.NewNetwork() # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # / # # # Construct the mobile networks # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # / # Reset the address base-- all of the 802.11 networks will be in # the "10.0" address space ipAddrs.SetBase(ns3.Ipv4Address("10.0.0.0"), ns3.Ipv4Mask("255.255.255.0")) for i in range(backboneNodes): print "Configuring wireless network for backbone node ", i # # Create a container to manage the nodes of the LAN. We need # two containers here; one with all of the new nodes, and one # with all of the nodes including new and existing nodes # stas = ns3.NodeContainer() stas.Create(infraNodes - 1) # Now, create the container with all nodes on this link infra = ns3.NodeContainer(ns3.NodeContainer(backbone.Get(i)), stas) # # Create another ad hoc network and devices # ssid = ns3.Ssid('wifi-infra' + str(i)) wifiInfra = ns3.WifiHelper.Default() wifiPhy.SetChannel(wifiChannel.Create()) wifiInfra.SetRemoteStationManager('ns3::ArfWifiManager') macInfra = ns3.NqosWifiMacHelper.Default() macInfra.SetType("ns3::NqstaWifiMac", "Ssid", ns3.SsidValue(ssid), "ActiveProbing", ns3.BooleanValue(False)) # setup stas staDevices = wifiInfra.Install(wifiPhy, macInfra, stas) # setup ap. macInfra.SetType("ns3::NqapWifiMac", "Ssid", ns3.SsidValue(ssid), "BeaconGeneration", ns3.BooleanValue(True), "BeaconInterval", ns3.TimeValue(ns3.Seconds(2.5))) apDevices = wifiInfra.Install(wifiPhy, macInfra, backbone.Get(i)) # Collect all of these new devices infraDevices = ns3.NetDeviceContainer(apDevices, staDevices) # Add the IPv4 protocol stack to the nodes in our container # internet.Install(stas) # # Assign IPv4 addresses to the device drivers(actually to the associated # IPv4 interfaces) we just created. # ipAddrs.Assign(infraDevices) # # Assign a new network prefix for each mobile network, according to # the network mask initialized above # ipAddrs.NewNetwork() # # The new wireless nodes need a mobility model so we aggregate one # to each of the nodes we just finished building. # subnetAlloc = ns3.ListPositionAllocator() for j in range(infra.GetN()): subnetAlloc.Add(ns3.Vector(0.0, j, 0.0)) mobility.PushReferenceMobilityModel(backbone.Get(i)) mobility.SetPositionAllocator(subnetAlloc) mobility.SetMobilityModel( "ns3::RandomDirection2dMobilityModel", "Bounds", ns3.RectangleValue(ns3.Rectangle(-25, 25, -25, 25)), "Speed", ns3.RandomVariableValue(ns3.ConstantVariable(30)), "Pause", ns3.RandomVariableValue(ns3.ConstantVariable(0.4))) mobility.Install(infra) # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # / # # # Application configuration # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # / # Create the OnOff application to send UDP datagrams of size # 210 bytes at a rate of 448 Kb/s, between two nodes print "Create Applications." port = 9 # Discard port(RFC 863) # Let's make sure that the user does not define too few LAN nodes # to make this example work. We need lanNodes >= 5 assert (lanNodes >= 5) appSource = ns3.NodeList.GetNode(11) appSink = ns3.NodeList.GetNode(13) remoteAddr = ns3.Ipv4Address("172.16.0.5") onoff = ns3.OnOffHelper( "ns3::UdpSocketFactory", ns3.Address(ns3.InetSocketAddress(remoteAddr, port))) onoff.SetAttribute("OnTime", ns3.RandomVariableValue(ns3.ConstantVariable(1))) onoff.SetAttribute("OffTime", ns3.RandomVariableValue(ns3.ConstantVariable(0))) apps = onoff.Install(ns3.NodeContainer(appSource)) apps.Start(ns3.Seconds(3.0)) apps.Stop(ns3.Seconds(20.0)) # Create a packet sink to receive these packets sink = ns3.PacketSinkHelper( "ns3::UdpSocketFactory", ns3.InetSocketAddress(ns3.Ipv4Address.GetAny(), port)) apps = sink.Install(ns3.NodeContainer(appSink)) apps.Start(ns3.Seconds(3.0)) # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # / # # # Tracing configuration # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # / print "Configure Tracing." # # Let's set up some ns-2-like ascii traces, using another helper class # #std.ofstream ascii #ascii = ns3.AsciiTraceHelper(); #stream = ascii.CreateFileStream("mixed-wireless.tr"); #wifiPhy.EnableAsciiAll(stream); #csma.EnableAsciiAll(stream); print "(tracing not done for Python)" # Look at nodes 11, 13 only # WifiHelper.EnableAscii(ascii, 11, 0); # WifiHelper.EnableAscii(ascii, 13, 0); # Let's do a pcap trace on the backbone devices wifiPhy.EnablePcap("mixed-wireless", backboneDevices) # Let's additionally trace the application Sink, ifIndex 0 csma = ns3.CsmaHelper() csma.EnablePcapAll("mixed-wireless", False) # #ifdef ENABLE_FOR_TRACING_EXAMPLE # Config.Connect("/NodeList/*/$MobilityModel/CourseChange", # MakeCallback(&CourseChangeCallback)) # #endif # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # Run simulation # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # print "Run Simulation." ns3.Simulator.Stop(ns3.Seconds(stopTime)) ns3.Simulator.Run() ns3.Simulator.Destroy()
def main(argv): # # Allow the user to override any of the defaults and the above Bind() at # run-time, via command-line arguments # cmd = ns3.CommandLine() cmd.Parse(argv) # # Explicitly create the nodes required by the topology(shown above). # #print "Create nodes." terminals = ns3.NodeContainer() terminals.Create(4) csmaSwitch = ns3.NodeContainer() csmaSwitch.Create(1) #print "Build Topology" csma = ns3.CsmaHelper() csma.SetChannelAttribute("DataRate", ns3.DataRateValue(ns3.DataRate(5000000))) csma.SetChannelAttribute("Delay", ns3.TimeValue(ns3.MilliSeconds(2))) # Create the csma links, from each terminal to the switch terminalDevices = ns3.NetDeviceContainer() switchDevices = ns3.NetDeviceContainer() for i in range(4): link = csma.Install( ns3.NodeContainer(ns3.NodeContainer(terminals.Get(i)), csmaSwitch)) terminalDevices.Add(link.Get(0)) switchDevices.Add(link.Get(1)) # Create the bridge netdevice, which will do the packet switching switchNode = csmaSwitch.Get(0) bridgeDevice = ns3.BridgeNetDevice() switchNode.AddDevice(bridgeDevice) for portIter in range(switchDevices.GetN()): bridgeDevice.AddBridgePort(switchDevices.Get(portIter)) # Add internet stack to the terminals internet = ns3.InternetStackHelper() internet.Install(terminals) # We've got the "hardware" in place. Now we need to add IP addresses. # #print "Assign IP Addresses." ipv4 = ns3.Ipv4AddressHelper() ipv4.SetBase(ns3.Ipv4Address("10.1.1.0"), ns3.Ipv4Mask("255.255.255.0")) ipv4.Assign(terminalDevices) # # Create an OnOff application to send UDP datagrams from node zero to node 1. # #print "Create Applications." port = 9 # Discard port(RFC 863) onoff = ns3.OnOffHelper( "ns3::UdpSocketFactory", ns3.Address(ns3.InetSocketAddress(ns3.Ipv4Address("10.1.1.2"), port))) onoff.SetAttribute("OnTime", ns3.RandomVariableValue(ns3.ConstantVariable(1))) onoff.SetAttribute("OffTime", ns3.RandomVariableValue(ns3.ConstantVariable(0))) app = onoff.Install(ns3.NodeContainer(terminals.Get(0))) # Start the application app.Start(ns3.Seconds(1.0)) app.Stop(ns3.Seconds(10.0)) # Create an optional packet sink to receive these packets sink = ns3.PacketSinkHelper( "ns3::UdpSocketFactory", ns3.Address(ns3.InetSocketAddress(ns3.Ipv4Address.GetAny(), port))) app = sink.Install(ns3.NodeContainer(terminals.Get(1))) app.Start(ns3.Seconds(0.0)) # # Create a similar flow from n3 to n0, starting at time 1.1 seconds # onoff.SetAttribute( "Remote", ns3.AddressValue( ns3.InetSocketAddress(ns3.Ipv4Address("10.1.1.1"), port))) app = onoff.Install(ns3.NodeContainer(terminals.Get(3))) app.Start(ns3.Seconds(1.1)) app.Stop(ns3.Seconds(10.0)) app = sink.Install(ns3.NodeContainer(terminals.Get(0))) app.Start(ns3.Seconds(0.0)) # # Configure tracing of all enqueue, dequeue, and NetDevice receive events. # Trace output will be sent to the file "csma-bridge.tr" # #print "Configure Tracing." #ascii = ns3.AsciiTraceHelper(); #csma.EnableAsciiAll(ascii.CreateFileStream ("csma-bridge.tr")); # # Also configure some tcpdump traces; each interface will be traced. # The output files will be named: # csma-bridge.pcap-<nodeId>-<interfaceId> # and can be read by the "tcpdump -r" command(use "-tt" option to # display timestamps correctly) # csma.EnablePcapAll("csma-bridge", False) # # Now, do the actual simulation. # #print "Run Simulation." ns3.Simulator.Run() ns3.Simulator.Destroy()
mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel") mobility.Install(nodes) port = 5000 #On off Application onoff = ns3.OnOffHelper( "ns3::UdpSocketFactory", ns3.Address(ns3.InetSocketAddress(ipcontainer.GetAddress(1), port))) onoff.SetAttribute("OnTime", ns3.RandomVariableValue(ns3.ConstantVariable(42))) onoff.SetAttribute("OffTime", ns3.RandomVariableValue(ns3.ConstantVariable(0))) #onoff.SetAttribute ("Remote", ns3.AddressValue (ns3.InetSocketAddress(ipcontainer.GetAddress(1),port))); apps = onoff.Install(nodes.Get(0)) apps.Start(ns3.Seconds(0.1)) apps.Stop(ns3.Seconds(90.0)) sink = ns3.PacketSinkHelper( "ns3::UdpSocketFactory", ns3.InetSocketAddress(ipcontainer.GetAddress(1), port)) appsink = sink.Install(nodes.Get(1)) appsink.Start(ns3.Seconds(0.5)) appsink.Stop(ns3.Seconds(90.0)) ns3.Simulator.Stop(ns3.Seconds(100)) #ns3.Simulator.Run() visualizer.start() ns3.Simulator.Destroy()