예제 #1
0
def network_address_helper(network):
    if network.version == 4:
        address = ns_net.Ipv4Address(network.network_address)
        prefix = ns_net.Ipv4Mask(network.netmask)
        return internet.Ipv4AddressHelper(address, prefix)
    if network.version == 6:
        address = ns_net.Ipv6Address(network.network_address)
        prefix = ns_net.Ipv6Prefix(network.prefixlen)
        return internet.Ipv6AddressHelper(address, prefix)
    raise 'Network version is not IPv4 or IPv6'
예제 #2
0
def network_address_helper(network, base):
    if network.version == 4:
        if base is None:
            base = "0.0.0.1"
        address = ns_net.Ipv4Address(network.network_address)
        prefix = ns_net.Ipv4Mask(network.netmask)
        return internet.Ipv4AddressHelper(address, prefix, base=ns_net.Ipv4Address(base))
    if network.version == 6:
        if base is None:
            base = "::1"
        address = ns_net.Ipv6Address(network.network_address)
        prefix = ns_net.Ipv6Prefix(network.prefixlen)
        return internet.Ipv6AddressHelper(address, prefix, base=ns_net.Ipv6Address(base))
    raise 'Network version is not IPv4 or IPv6'
예제 #3
0
파일: wifi.py 프로젝트: Paul-Geppert/marvis
    def __init__(self,
                 network,
                 channel_name,
                 nodes,
                 frequency=None,
                 channel=1,
                 channel_width=40,
                 antennas=1,
                 tx_power=20.0,
                 standard: WiFiStandard = WiFiStandard.WIFI_802_11b,
                 data_rate: WiFiDataRate = WiFiDataRate.DSSS_RATE_11Mbps,
                 delay="0ms"):
        super().__init__(network, channel_name, nodes)

        #: The channel to use.
        self.channel = channel
        #: The frequency to use.
        #:
        #: This could collide with other WiFi channels.
        self.frequency = frequency
        #: The width of the channel in MHz.
        self.channel_width = channel_width
        #: The number of antennas to use.
        self.antennas = antennas
        #: The sending power in dBm.
        self.tx_power = tx_power
        #: The WiFi standard to use.
        self.standard = standard
        #: The data rate to use.
        self.data_rate = data_rate
        #: The delay for the channel
        self.delay = delay

        logger.debug("Setting up physical layer of WiFi.")
        self.wifi_phy_helper = wifi.YansWifiPhyHelper()
        self.wifi_phy_helper.Set("ChannelWidth",
                                 core.UintegerValue(self.channel_width))
        if self.frequency:
            self.wifi_phy_helper.Set("Frequency",
                                     core.UintegerValue(self.frequency))
        else:
            self.wifi_phy_helper.Set("ChannelNumber",
                                     core.UintegerValue(self.channel))
        self.wifi_phy_helper.Set("Antennas", core.UintegerValue(self.antennas))
        self.wifi_phy_helper.Set("MaxSupportedTxSpatialStreams",
                                 core.UintegerValue(self.antennas))
        self.wifi_phy_helper.Set("MaxSupportedRxSpatialStreams",
                                 core.UintegerValue(self.antennas))
        self.wifi_phy_helper.Set("TxPowerStart",
                                 core.DoubleValue(self.tx_power))
        self.wifi_phy_helper.Set("TxPowerEnd", core.DoubleValue(self.tx_power))

        # Enable monitoring of radio headers.
        self.wifi_phy_helper.SetPcapDataLinkType(
            wifi.WifiPhyHelper.DLT_IEEE802_11_RADIO)

        wifi_channel = wifi.YansWifiChannel()
        self.propagation_delay_model = propagation.ConstantSpeedPropagationDelayModel(
        )
        self.set_delay(self.delay)
        wifi_channel.SetAttribute(
            "PropagationDelayModel",
            core.PointerValue(self.propagation_delay_model))

        if self.standard == WiFiChannel.WiFiStandard.WIFI_802_11p:
            # Loss Model, parameter values from Boockmeyer, A. (2020):
            # "Hatebefi: Hybrid Application Testbed for Fault Injection"
            loss_model = propagation.ThreeLogDistancePropagationLossModel()
            loss_model.SetAttribute("Distance0", core.DoubleValue(27.3))
            loss_model.SetAttribute("Distance1", core.DoubleValue(68.4))
            loss_model.SetAttribute("Distance2", core.DoubleValue(80.7))
            loss_model.SetAttribute("Exponent0",
                                    core.DoubleValue(1.332671627050236))
            loss_model.SetAttribute("Exponent1",
                                    core.DoubleValue(2.6812446718062612))
            loss_model.SetAttribute("Exponent2",
                                    core.DoubleValue(3.5145944762444183))
            loss_model.SetAttribute("ReferenceLoss",
                                    core.DoubleValue(83.54330702928374))
            wifi_channel.SetAttribute("PropagationLossModel",
                                      core.PointerValue(loss_model))
        else:
            loss_model = propagation.LogDistancePropagationLossModel()
            wifi_channel.SetAttribute("PropagationLossModel",
                                      core.PointerValue(loss_model))

        self.wifi_phy_helper.SetChannel(wifi_channel)

        #: Helper for creating the WiFi channel.
        self.wifi = None

        #: All ns-3 devices on this channel.
        self.devices_container = None

        #: Helper for creating MAC layers.
        self.wifi_mac_helper = None

        if self.standard != WiFiChannel.WiFiStandard.WIFI_802_11p:
            self.wifi = wifi.WifiHelper()
            self.wifi.SetRemoteStationManager(
                "ns3::ConstantRateWifiManager", "DataMode",
                core.StringValue(self.data_rate.value), "ControlMode",
                core.StringValue(self.data_rate.value))
            self.wifi.SetStandard(self.standard.value)

            self.wifi_mac_helper = wifi.WifiMacHelper()

            # Adhoc network between multiple nodes (no access point).
            self.wifi_mac_helper.SetType("ns3::AdhocWifiMac")
        else:
            self.wifi = wave.Wifi80211pHelper.Default()
            self.wifi.SetRemoteStationManager(
                "ns3::ConstantRateWifiManager", "DataMode",
                core.StringValue(self.data_rate.value), "ControlMode",
                core.StringValue(self.data_rate.value), "NonUnicastMode",
                core.StringValue(self.data_rate.value))
            self.wifi_mac_helper = wave.NqosWaveMacHelper.Default()

        # Install on all connected nodes.
        logger.debug(
            "Installing the WiFi channel to %d nodes. Mode is %s (data) / %s (control).",
            len(nodes), self.standard, self.data_rate)

        #: All ns-3 devices on this channel.
        self.devices_container = self.wifi.Install(self.wifi_phy_helper,
                                                   self.wifi_mac_helper,
                                                   self.ns3_nodes_container)

        logger.info('Setting IP addresses on nodes.')
        stack_helper = internet.InternetStackHelper()

        for i, connected_node in enumerate(nodes):
            ns3_device = self.devices_container.Get(i)
            node = connected_node.node

            address = None
            interface = None
            if node.wants_ip_stack():
                if node.ns3_node.GetObject(internet.Ipv4.GetTypeId()) is None:
                    logger.info('Installing IP stack on %s', node.name)
                    stack_helper.Install(node.ns3_node)
                address = connected_node.address
                if address is None:
                    address = self.network.get_free_ip_address()

                network_address = ipaddress.ip_network(
                    f'{str(address)}/{network.netmask}', strict=False)
                ns3_network_address = ns_net.Ipv4Address(
                    network_address.network_address)
                ns3_network_prefix = ns_net.Ipv4Mask(network_address.netmask)
                base = ipaddress.ip_address(
                    int(address) - int(network_address.network_address))
                helper = internet.Ipv4AddressHelper(ns3_network_address,
                                                    ns3_network_prefix,
                                                    base=ns_net.Ipv4Address(
                                                        str(base)))
                device_container = ns_net.NetDeviceContainer(ns3_device)
                helper.Assign(device_container)
                interface = Interface(node=node,
                                      ns3_device=ns3_device,
                                      address=ipaddress.ip_interface(
                                          f'{str(address)}/{network.netmask}'))
            else:
                interface = Interface(node=node,
                                      ns3_device=ns3_device,
                                      address=connected_node.address)
            ns3_device.SetAddress(ns_net.Mac48Address(interface.mac_address))
            node.add_interface(interface, name=connected_node.ifname)
            self.interfaces.append(interface)
예제 #4
0
    def __init__(self,
                 network,
                 channel_name,
                 nodes,
                 delay="0ms",
                 data_rate="100Mbps"):
        super().__init__(network, channel_name, nodes)

        #: The channel's delay.
        self.delay = delay
        #: The channel's speed for transmitting and receiving.
        #:
        #: Valid values e.g. are :code:`'100Mbps'` or :code:`'64kbps'`.
        self.data_rate = data_rate

        #: A helper for connecting nodes via CSMA.
        self.csma_helper = csma.CsmaHelper()

        #: The channel for connecting the nodes
        self.csma_channel = csma.CsmaChannel()
        self.set_delay(self.delay)
        self.set_data_rate(self.data_rate)

        #: All ns-3 devices on this channel.
        logger.info('Install connection between nodes')
        self.devices_container = self.csma_helper.Install(
            self.ns3_nodes_container, self.csma_channel)

        logger.info('Set IP addresses on nodes')
        stack_helper = internet.InternetStackHelper()

        for i, connected_node in enumerate(nodes):
            ns3_device = self.devices_container.Get(i)
            node = connected_node.node

            if node.wants_ip_stack():
                if node.ns3_node.GetObject(internet.Ipv4.GetTypeId()) is None:
                    logger.info('Installing IP stack on %s', node.name)
                    stack_helper.Install(node.ns3_node)
                address = connected_node.address
                if address is None:
                    address = self.network.get_free_ip_address()

                network_address = ipaddress.ip_network(
                    f'{str(address)}/{network.netmask}', strict=False)
                ns3_network_address = ns_net.Ipv4Address(
                    network_address.network_address)
                ns3_network_prefix = ns_net.Ipv4Mask(network_address.netmask)
                base = ipaddress.ip_address(
                    int(address) - int(network_address.network_address))
                helper = internet.Ipv4AddressHelper(ns3_network_address,
                                                    ns3_network_prefix,
                                                    base=ns_net.Ipv4Address(
                                                        str(base)))
                device_container = ns_net.NetDeviceContainer(ns3_device)
                helper.Assign(device_container)
                interface = Interface(node=node,
                                      ns3_device=ns3_device,
                                      address=ipaddress.ip_interface(
                                          f'{str(address)}/{network.netmask}'))
            else:
                interface = Interface(node=node,
                                      ns3_device=ns3_device,
                                      address=connected_node.address)
            ns3_device.SetAddress(ns_net.Mac48Address(interface.mac_address))
            node.add_interface(interface)
            self.interfaces.append(interface)
예제 #5
0
def main(li):
    p2pNodes = network.NodeContainer()
    p2pNodes.Create(2)

    pointToPoint = point_to_point.PointToPointHelper()
    pointToPoint.SetDeviceAttribute(
        "DataRate",
        core.StringValue(str(int(sum([i[0] for i in li]))) + "Mbps"))
    pointToPoint.SetChannelAttribute("Delay", core.StringValue("20ms"))

    p2pDevices = pointToPoint.Install(p2pNodes)

    csmaNodes = network.NodeContainer()
    csmaNodes.Add(p2pNodes.Get(1))
    csmaNodes.Create(3)

    csma = ccc.CsmaHelper()
    csma.SetChannelAttribute("DataRate", core.StringValue("100Mbps"))
    csma.SetChannelAttribute("Delay", core.TimeValue(core.NanoSeconds(6560)))

    csmaDevices = csma.Install(csmaNodes)

    wifiStaNodes = network.NodeContainer()
    wifiStaNodes.Create(3)
    wifiApNode = p2pNodes.Get(0)

    channel = www.YansWifiChannelHelper.Default()
    phy = www.YansWifiPhyHelper.Default()
    phy.SetChannel(channel.Create())

    wifi = www.WifiHelper()
    # wifi.SetRemoteStationManager("ns3::AarfWifiManager")
    wifi.SetRemoteStationManager("ns3::ConstantRateWifiManager", "DataMode",
                                 core.StringValue("OfdmRate54Mbps"))

    mac = www.WifiMacHelper()
    ssid = www.Ssid("ns-3-ssid")

    mac.SetType("ns3::StaWifiMac", "Ssid", www.SsidValue(ssid),
                "ActiveProbing", core.BooleanValue(False))
    staDevices = wifi.Install(phy, mac, wifiStaNodes)

    mac.SetType("ns3::ApWifiMac", "Ssid", www.SsidValue(ssid))
    apDevices = wifi.Install(phy, mac, wifiApNode)

    mobility = mob.MobilityHelper()
    mobility.SetPositionAllocator("ns3::GridPositionAllocator", "MinX",
                                  core.DoubleValue(0.0), "MinY",
                                  core.DoubleValue(0.0), "DeltaX",
                                  core.DoubleValue(5.0), "DeltaY",
                                  core.DoubleValue(10.0), "GridWidth",
                                  core.UintegerValue(3), "LayoutType",
                                  core.StringValue("RowFirst"))
    mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel")
    mobility.Install(wifiApNode)
    mobility.Install(wifiStaNodes)

    stack = internet.InternetStackHelper()
    stack.Install(csmaNodes)
    stack.Install(wifiApNode)
    stack.Install(wifiStaNodes)

    address = internet.Ipv4AddressHelper()
    address.SetBase(network.Ipv4Address("10.1.1.0"),
                    network.Ipv4Mask("255.255.255.0"))
    address.Assign(p2pDevices)

    address.SetBase(network.Ipv4Address("10.1.2.0"),
                    network.Ipv4Mask("255.255.255.0"))
    address.Assign(csmaDevices)

    address.SetBase(network.Ipv4Address("10.1.3.0"),
                    network.Ipv4Mask("255.255.255.0"))
    address.Assign(staDevices)
    address.Assign(apDevices)

    client = csmaNodes.Get(0)
    soc = network.Socket.CreateSocket(client,
                                      internet.UdpSocketFactory.GetTypeId())
    pre = li[0]
    client.AddApplication(send(soc, pre[0], pre[1], False))
    for i in range(1, 4):
        client = csmaNodes.Get(i)
        soc = network.Socket.CreateSocket(
            client, internet.UdpSocketFactory.GetTypeId())
        pre = li[i]
        client.AddApplication(send(soc, pre[0], pre[1]))

    client = wifiStaNodes.Get(0)
    soc = network.Socket.CreateSocket(client,
                                      internet.UdpSocketFactory.GetTypeId())
    client.AddApplication(recv(soc))
    client = wifiStaNodes.Get(1)
    soc = network.Socket.CreateSocket(client,
                                      internet.UdpSocketFactory.GetTypeId())
    client.AddApplication(recv(soc, False))

    internet.Ipv4GlobalRoutingHelper.PopulateRoutingTables()

    core.Simulator.Stop(core.Seconds(3.0))

    # pointToPoint.EnablePcapAll("third")
    # phy.EnablePcapAll("csma")
    # csma.EnablePcapAll("third", True)
    # stack.EnablePcapIpv4All('ics')

    core.Simulator.Run()
    core.Simulator.Destroy()
예제 #6
0
파일: main.py 프로젝트: xinjuehu/ns3-study
def main():
    # core.LogComponentEnable("UdpEchoClientApplication", core.LOG_LEVEL_INFO)

    wifihelper = wifi.WifiHelper.Default()
    wifihelper.SetStandard(wifi.WIFI_PHY_STANDARD_80211a)

    wifiphy = wifi.YansWifiPhyHelper.Default()
    wifichannel = wifi.YansWifiChannelHelper.Default()
    wifiphy.SetChannel(wifichannel.Create())

    wifimac = wifi.WifiMacHelper()
    wifimac.SetType("ns3::AdhocWifiMac")
    wifihelper.SetRemoteStationManager("ns3::ConstantRateWifiManager",
                                       "DataMode",
                                       core.StringValue("OfdmRate54Mbps"))

    p2pmac = p2p.PointToPointHelper()
    p2pmac.SetChannelAttribute("Delay", core.TimeValue(core.NanoSeconds(6560)))
    p2pmac.SetDeviceAttribute("DataRate", core.StringValue("2Mbps"))

    stas = network.NodeContainer()
    stas.Create(3)

    p2ps = network.NodeContainer()
    p2ps.Create(1)

    mob = mobility.MobilityHelper()
    mob.Install(stas)

    stack = internet.InternetStackHelper()
    stack.Install(stas)
    stack.Install(p2ps)

    dev = wifihelper.Install(wifiphy, wifimac, stas)
    p2ps.Add(stas.Get(0))
    dev2 = p2pmac.Install(p2ps)

    ip = internet.Ipv4AddressHelper()
    ip.SetBase(network.Ipv4Address('192.168.0.0'),
               network.Ipv4Mask('255.255.255.0'))
    ip.Assign(dev)
    ip.SetBase(network.Ipv4Address('192.168.1.0'),
               network.Ipv4Mask('255.255.255.0'))
    ip.Assign(dev2)

    client = p2ps.Get(0)
    client.AddApplication(
        aaa(
            network.Socket.CreateSocket(client,
                                        internet.UdpSocketFactory.GetTypeId()),
            0))
    for i in range(3):
        client = stas.Get(i)
        client.AddApplication(
            aaa(
                network.Socket.CreateSocket(
                    client, internet.UdpSocketFactory.GetTypeId()), i))

    internet.Ipv4GlobalRoutingHelper.PopulateRoutingTables()

    core.Simulator.Stop(core.Seconds(10.0))

    wifiphy.EnablePcapAll('adhoc', True)
    stack.EnablePcapIpv4All('ipv4')
    core.Simulator.Run()
    core.Simulator.Destroy()

    sys.exit(0)