int main (int argc, char *argv[]) { std::string phyMode ("DsssRate1Mbps"); double rss = -80; // -dBm uint32_t packetSize = 1000; // bytes uint32_t numPackets = 1; double interval = 1.0; // seconds bool verbose = false; CommandLine cmd; cmd.AddValue ("phyMode", "Wifi Phy mode", phyMode); cmd.AddValue ("rss", "received signal strength", rss); 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.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 (2); // 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 } wifi.SetStandard (WIFI_PHY_STANDARD_80211b); YansWifiPhyHelper wifiPhy = YansWifiPhyHelper::Default (); // This is one parameter that matters when using FixedRssLossModel // set it to zero; otherwise, gain will be added wifiPhy.Set ("RxGain", DoubleValue (0) ); // ns-3 supports RadioTap and Prism tracing extensions for 802.11b wifiPhy.SetPcapDataLinkType (YansWifiPhyHelper::DLT_IEEE802_11_RADIO); YansWifiChannelHelper wifiChannel; wifiChannel.SetPropagationDelay ("ns3::ConstantSpeedPropagationDelayModel"); // The below FixedRssLossModel will cause the rss to be fixed regardless // of the distance between the two stations, and the transmit power wifiChannel.AddPropagationLoss ("ns3::FixedRssLossModel","Rss",DoubleValue (rss)); wifiPhy.SetChannel (wifiChannel.Create ()); // Add a non-QoS upper mac, and disable rate control NqosWifiMacHelper wifiMac = NqosWifiMacHelper::Default (); wifi.SetRemoteStationManager ("ns3::ConstantRateWifiManager", "DataMode",StringValue (phyMode), "ControlMode",StringValue (phyMode)); // Setup the rest of the upper mac Ssid ssid = Ssid ("wifi-default"); // setup sta. wifiMac.SetType ("ns3::StaWifiMac", "Ssid", SsidValue (ssid), "ActiveProbing", BooleanValue (false)); NetDeviceContainer staDevice = wifi.Install (wifiPhy, wifiMac, c.Get (0)); NetDeviceContainer devices = staDevice; // setup ap. wifiMac.SetType ("ns3::ApWifiMac", "Ssid", SsidValue (ssid)); NetDeviceContainer apDevice = wifi.Install (wifiPhy, wifiMac, c.Get (1)); devices.Add (apDevice); // Note that with FixedRssLossModel, the positions below are not // used for received signal strength. MobilityHelper mobility; Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator> (); positionAlloc->Add (Vector (0.0, 0.0, 0.0)); positionAlloc->Add (Vector (5.0, 0.0, 0.0)); mobility.SetPositionAllocator (positionAlloc); mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel"); mobility.Install (c); InternetStackHelper internet; internet.Install (c); Ipv4AddressHelper ipv4; NS_LOG_INFO ("Assign IP Addresses."); ipv4.SetBase ("10.1.1.0", "255.255.255.0"); Ipv4InterfaceContainer i = ipv4.Assign (devices); TypeId tid = TypeId::LookupByName ("ns3::UdpSocketFactory"); Ptr<Socket> recvSink = Socket::CreateSocket (c.Get (0), tid); InetSocketAddress local = InetSocketAddress (Ipv4Address::GetAny (), 80); recvSink->Bind (local); recvSink->SetRecvCallback (MakeCallback (&ReceivePacket)); Ptr<Socket> source = Socket::CreateSocket (c.Get (1), tid); InetSocketAddress remote = InetSocketAddress (Ipv4Address ("255.255.255.255"), 80); source->SetAllowBroadcast (true); source->Connect (remote); // Tracing wifiPhy.EnablePcap ("wifi-simple-infra", devices); // Output what we are doing NS_LOG_UNCOND ("Testing " << numPackets << " packets sent with receiver rss " << rss ); Simulator::ScheduleWithContext (source->GetNode ()->GetId (), Seconds (1.0), &GenerateTraffic, source, packetSize, numPackets, interPacketInterval); Simulator::Stop (Seconds (30.0)); Simulator::Run (); Simulator::Destroy (); return 0; }
int main (int argc, char *argv[]) { std::string mode = "ConfigureLocal"; std::string tapName = "thetap"; CommandLine cmd; cmd.AddValue ("mode", "Mode setting of TapBridge", mode); cmd.AddValue ("tapName", "Name of the OS tap device", tapName); cmd.Parse (argc, argv); GlobalValue::Bind ("SimulatorImplementationType", StringValue ("ns3::RealtimeSimulatorImpl")); GlobalValue::Bind ("ChecksumEnabled", BooleanValue (true)); // // The topology has a Wifi network of four nodes on the left side. We'll make // node zero the AP and have the other three will be the STAs. // NodeContainer nodesLeft; nodesLeft.Create (4); YansWifiPhyHelper wifiPhy = YansWifiPhyHelper::Default (); YansWifiChannelHelper wifiChannel = YansWifiChannelHelper::Default (); wifiPhy.SetChannel (wifiChannel.Create ()); Ssid ssid = Ssid ("left"); WifiHelper wifi = WifiHelper::Default (); NqosWifiMacHelper wifiMac = NqosWifiMacHelper::Default (); wifi.SetRemoteStationManager ("ns3::ArfWifiManager"); wifiMac.SetType ("ns3::ApWifiMac", "Ssid", SsidValue (ssid)); NetDeviceContainer devicesLeft = wifi.Install (wifiPhy, wifiMac, nodesLeft.Get (0)); wifiMac.SetType ("ns3::StaWifiMac", "Ssid", SsidValue (ssid), "ActiveProbing", BooleanValue (false)); devicesLeft.Add (wifi.Install (wifiPhy, wifiMac, NodeContainer (nodesLeft.Get (1), nodesLeft.Get (2), nodesLeft.Get (3)))); MobilityHelper mobility; mobility.Install (nodesLeft); InternetStackHelper internetLeft; internetLeft.Install (nodesLeft); Ipv4AddressHelper ipv4Left; ipv4Left.SetBase ("10.1.1.0", "255.255.255.0"); Ipv4InterfaceContainer interfacesLeft = ipv4Left.Assign (devicesLeft); TapBridgeHelper tapBridge (interfacesLeft.GetAddress (1)); tapBridge.SetAttribute ("Mode", StringValue (mode)); tapBridge.SetAttribute ("DeviceName", StringValue (tapName)); tapBridge.Install (nodesLeft.Get (0), devicesLeft.Get (0)); // // Now, create the right side. // NodeContainer nodesRight; nodesRight.Create (4); CsmaHelper csmaRight; csmaRight.SetChannelAttribute ("DataRate", DataRateValue (5000000)); csmaRight.SetChannelAttribute ("Delay", TimeValue (MilliSeconds (2))); NetDeviceContainer devicesRight = csmaRight.Install (nodesRight); InternetStackHelper internetRight; internetRight.Install (nodesRight); Ipv4AddressHelper ipv4Right; ipv4Right.SetBase ("10.1.3.0", "255.255.255.0"); Ipv4InterfaceContainer interfacesRight = ipv4Right.Assign (devicesRight); // // Stick in the point-to-point line between the sides. // PointToPointHelper p2p; p2p.SetDeviceAttribute ("DataRate", StringValue ("512kbps")); p2p.SetChannelAttribute ("Delay", StringValue ("10ms")); NodeContainer nodes = NodeContainer (nodesLeft.Get (3), nodesRight.Get (0)); NetDeviceContainer devices = p2p.Install (nodes); Ipv4AddressHelper ipv4; ipv4.SetBase ("10.1.2.0", "255.255.255.192"); Ipv4InterfaceContainer interfaces = ipv4.Assign (devices); // // Simulate some CBR traffic over the point-to-point link // uint16_t port = 9; // Discard port (RFC 863) OnOffHelper onoff ("ns3::UdpSocketFactory", InetSocketAddress (interfaces.GetAddress (1), port)); onoff.SetConstantRate (DataRate ("500kb/s")); ApplicationContainer apps = onoff.Install (nodesLeft.Get (3)); apps.Start (Seconds (1.0)); // Create a packet sink to receive these packets PacketSinkHelper sink ("ns3::UdpSocketFactory", InetSocketAddress (Ipv4Address::GetAny (), port)); apps = sink.Install (nodesRight.Get (0)); apps.Start (Seconds (1.0)); wifiPhy.EnablePcapAll ("tap-wifi-dumbbell"); csmaRight.EnablePcapAll ("tap-wifi-dumbbell", false); Ipv4GlobalRoutingHelper::PopulateRoutingTables (); Simulator::Stop (Seconds (60.)); Simulator::Run (); Simulator::Destroy (); }
void EpcS1uDlTestCase::DoRun () { Ptr<PointToPointEpcHelper> epcHelper = CreateObject<PointToPointEpcHelper> (); Ptr<Node> pgw = epcHelper->GetPgwNode (); // allow jumbo packets Config::SetDefault ("ns3::CsmaNetDevice::Mtu", UintegerValue (30000)); Config::SetDefault ("ns3::PointToPointNetDevice::Mtu", UintegerValue (30000)); epcHelper->SetAttribute ("S1uLinkMtu", UintegerValue (30000)); // Create a single RemoteHost NodeContainer remoteHostContainer; remoteHostContainer.Create (1); Ptr<Node> remoteHost = remoteHostContainer.Get (0); InternetStackHelper internet; internet.Install (remoteHostContainer); // Create the internet PointToPointHelper p2ph; p2ph.SetDeviceAttribute ("DataRate", DataRateValue (DataRate ("100Gb/s"))); NetDeviceContainer internetDevices = p2ph.Install (pgw, remoteHost); Ipv4AddressHelper ipv4h; ipv4h.SetBase ("1.0.0.0", "255.0.0.0"); ipv4h.Assign (internetDevices); // setup default gateway for the remote hosts Ipv4StaticRoutingHelper ipv4RoutingHelper; Ptr<Ipv4StaticRouting> remoteHostStaticRouting = ipv4RoutingHelper.GetStaticRouting (remoteHost->GetObject<Ipv4> ()); // hardcoded UE addresses for now remoteHostStaticRouting->AddNetworkRouteTo (Ipv4Address ("7.0.0.0"), Ipv4Mask ("255.255.255.0"), 1); NodeContainer enbs; uint16_t cellIdCounter = 0; for (std::vector<EnbDlTestData>::iterator enbit = m_enbDlTestData.begin (); enbit < m_enbDlTestData.end (); ++enbit) { Ptr<Node> enb = CreateObject<Node> (); enbs.Add (enb); // we test EPC without LTE, hence we use: // 1) a CSMA network to simulate the cell // 2) a raw socket opened on the CSMA device to simulate the LTE socket uint16_t cellId = ++cellIdCounter; NodeContainer ues; ues.Create (enbit->ues.size ()); NodeContainer cell; cell.Add (ues); cell.Add (enb); CsmaHelper csmaCell; NetDeviceContainer cellDevices = csmaCell.Install (cell); // the eNB's CSMA NetDevice acting as an LTE NetDevice. Ptr<NetDevice> enbDevice = cellDevices.Get (cellDevices.GetN () - 1); // Note that the EpcEnbApplication won't care of the actual NetDevice type epcHelper->AddEnb (enb, enbDevice, cellId); // Plug test RRC entity Ptr<EpcEnbApplication> enbApp = enb->GetApplication (0)->GetObject<EpcEnbApplication> (); NS_ASSERT_MSG (enbApp != 0, "cannot retrieve EpcEnbApplication"); Ptr<EpcTestRrc> rrc = CreateObject<EpcTestRrc> (); rrc->SetS1SapProvider (enbApp->GetS1SapProvider ()); enbApp->SetS1SapUser (rrc->GetS1SapUser ()); // we install the IP stack on UEs only InternetStackHelper internet; internet.Install (ues); // assign IP address to UEs, and install applications for (uint32_t u = 0; u < ues.GetN (); ++u) { Ptr<NetDevice> ueLteDevice = cellDevices.Get (u); Ipv4InterfaceContainer ueIpIface = epcHelper->AssignUeIpv4Address (NetDeviceContainer (ueLteDevice)); Ptr<Node> ue = ues.Get (u); // disable IP Forwarding on the UE. This is because we use // CSMA broadcast MAC addresses for this test. The problem // won't happen with a LteUeNetDevice. ue->GetObject<Ipv4> ()->SetAttribute ("IpForward", BooleanValue (false)); uint16_t port = 1234; PacketSinkHelper packetSinkHelper ("ns3::UdpSocketFactory", InetSocketAddress (Ipv4Address::GetAny (), port)); ApplicationContainer apps = packetSinkHelper.Install (ue); apps.Start (Seconds (1.0)); apps.Stop (Seconds (10.0)); enbit->ues[u].serverApp = apps.Get (0)->GetObject<PacketSink> (); Time interPacketInterval = Seconds (0.01); UdpEchoClientHelper client (ueIpIface.GetAddress (0), port); client.SetAttribute ("MaxPackets", UintegerValue (enbit->ues[u].numPkts)); client.SetAttribute ("Interval", TimeValue (interPacketInterval)); client.SetAttribute ("PacketSize", UintegerValue (enbit->ues[u].pktSize)); apps = client.Install (remoteHost); apps.Start (Seconds (2.0)); apps.Stop (Seconds (10.0)); enbit->ues[u].clientApp = apps.Get (0); uint64_t imsi = u+1; epcHelper->AddUe (ueLteDevice, imsi); epcHelper->ActivateEpsBearer (ueLteDevice, imsi, EpcTft::Default (), EpsBearer (EpsBearer::NGBR_VIDEO_TCP_DEFAULT)); enbApp->GetS1SapProvider ()->InitialUeMessage (imsi, (uint16_t) imsi); } } Simulator::Run (); for (std::vector<EnbDlTestData>::iterator enbit = m_enbDlTestData.begin (); enbit < m_enbDlTestData.end (); ++enbit) { for (std::vector<UeDlTestData>::iterator ueit = enbit->ues.begin (); ueit < enbit->ues.end (); ++ueit) { NS_TEST_ASSERT_MSG_EQ (ueit->serverApp->GetTotalRx (), (ueit->numPkts) * (ueit->pktSize), "wrong total received bytes"); } } Simulator::Destroy (); }
void LenaDlCtrlPhyErrorModelTestCase::DoRun (void) { double ber = 0.03; Config::SetDefault ("ns3::LteAmc::Ber", DoubleValue (ber)); Config::SetDefault ("ns3::LteAmc::AmcModel", EnumValue (LteAmc::PiroEW2010)); Config::SetDefault ("ns3::LteSpectrumPhy::CtrlErrorModelEnabled", BooleanValue (true)); Config::SetDefault ("ns3::LteSpectrumPhy::DataErrorModelEnabled", BooleanValue (false)); Config::SetDefault ("ns3::RrFfMacScheduler::HarqEnabled", BooleanValue (false)); Config::SetGlobal ("RngRun", IntegerValue (m_rngRun)); /* * Initialize Simulation Scenario: 1 eNB and m_nUser UEs */ int64_t stream = 1; Ptr<LteHelper> lena = CreateObject<LteHelper> (); // Create Nodes: eNodeB and UE NodeContainer enbNodes; NodeContainer ueNodes; enbNodes.Create (m_nEnb); ueNodes.Create (1); // Install Mobility Model MobilityHelper mobility; mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel"); mobility.Install (enbNodes); BuildingsHelper::Install (enbNodes); mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel"); mobility.Install (ueNodes); BuildingsHelper::Install (ueNodes); // remove random shadowing component lena->SetAttribute ("PathlossModel", StringValue ("ns3::HybridBuildingsPropagationLossModel")); lena->SetPathlossModelAttribute ("ShadowSigmaOutdoor", DoubleValue (0.0)); lena->SetPathlossModelAttribute ("ShadowSigmaIndoor", DoubleValue (0.0)); lena->SetPathlossModelAttribute ("ShadowSigmaExtWalls", DoubleValue (0.0)); // Create Devices and install them in the Nodes (eNB and UE) NetDeviceContainer enbDevs; NetDeviceContainer ueDevs; lena->SetSchedulerType ("ns3::RrFfMacScheduler"); lena->SetSchedulerAttribute ("UlCqiFilter", EnumValue (FfMacScheduler::PUSCH_UL_CQI)); enbDevs = lena->InstallEnbDevice (enbNodes); stream += lena->AssignStreams (enbDevs, stream); ueDevs = lena->InstallUeDevice (ueNodes); stream += lena->AssignStreams (ueDevs, stream); // Attach a UE to one eNB (the others are interfering ones) lena->Attach (ueDevs, enbDevs.Get (0)); // Activate an EPS bearer enum EpsBearer::Qci q = EpsBearer::GBR_CONV_VOICE; EpsBearer bearer (q); lena->ActivateDataRadioBearer (ueDevs, bearer); // Set UEs' position and power for (int i = 0; i < m_nEnb; i++) { // place the HeNB over the default rooftop level (20 mt.) Ptr<MobilityModel> mm = enbNodes.Get (i)->GetObject<MobilityModel> (); mm->SetPosition (Vector (0.0, 0.0, 30.0)); Ptr<LteEnbNetDevice> lteEnbDev = enbDevs.Get (i)->GetObject<LteEnbNetDevice> (); Ptr<LteEnbPhy> enbPhy = lteEnbDev->GetPhy (); enbPhy->SetAttribute ("TxPower", DoubleValue (43.0)); enbPhy->SetAttribute ("NoiseFigure", DoubleValue (5.0)); } // Set UEs' position and power Ptr<MobilityModel> mm = ueNodes.Get (0)->GetObject<MobilityModel> (); mm->SetPosition (Vector (m_dist, 0.0, 1.0)); Ptr<LteUeNetDevice> lteUeDev = ueDevs.Get (0)->GetObject<LteUeNetDevice> (); Ptr<LteUePhy> uePhy = lteUeDev->GetPhy (); uePhy->SetAttribute ("TxPower", DoubleValue (23.0)); uePhy->SetAttribute ("NoiseFigure", DoubleValue (9.0)); Time statsDuration = Seconds (1.0); Simulator::Stop (m_statsStartTime + statsDuration - Seconds (0.0001)); lena->EnableRlcTraces (); Ptr<RadioBearerStatsCalculator> rlcStats = lena->GetRlcStats (); rlcStats->SetAttribute ("StartTime", TimeValue (m_statsStartTime)); rlcStats->SetAttribute ("EpochDuration", TimeValue (statsDuration)); Simulator::Run (); NS_LOG_INFO ("\tTest downlink control channels (PCFICH+PDCCH)"); NS_LOG_INFO ("Test with " << m_nEnb << " eNB(s) at distance " << m_dist << " expected BLER " << m_blerRef); int nUser = 1; for (int i = 0; i < nUser; i++) { // get the imsi uint64_t imsi = ueDevs.Get (i)->GetObject<LteUeNetDevice> ()->GetImsi (); uint8_t lcId = 3; double dlRxPackets = rlcStats->GetDlRxPackets (imsi, lcId); double dlTxPackets = rlcStats->GetDlTxPackets (imsi, lcId); double dlBler = 1.0 - (dlRxPackets/dlTxPackets); double expectedDlRxPackets = dlTxPackets -dlTxPackets*m_blerRef; NS_LOG_INFO ("\tUser " << i << " imsi " << imsi << " DOWNLINK" << " pkts rx " << dlRxPackets << " tx " << dlTxPackets << " BLER " << dlBler << " Err " << std::fabs (m_blerRef - dlBler) << " expected rx " << expectedDlRxPackets << " difference " << std::abs (expectedDlRxPackets - dlRxPackets) << " tolerance " << m_toleranceRxPackets); NS_UNUSED (dlBler); // sanity check for whether the tx packets reported by the stats are correct // we expect one packet per TTI double expectedDlTxPackets = statsDuration.GetMilliSeconds (); NS_TEST_ASSERT_MSG_EQ_TOL (dlTxPackets, expectedDlTxPackets, expectedDlTxPackets * 0.005, " too different DL TX packets reported"); // this is the main test condition: check that the RX packets are within the expected range NS_TEST_ASSERT_MSG_EQ_TOL (dlRxPackets, expectedDlRxPackets, m_toleranceRxPackets, "too different DL RX packets reported"); } Simulator::Destroy (); }
int main (int argc, char *argv[]) { // // Users may find it convenient to turn on explicit debugging // for selected modules; the below lines suggest how to do this // // LogComponentEnable ("CsmaMulticastExample", LOG_LEVEL_INFO); // // Set up default values for the simulation. // // Select DIX/Ethernet II-style encapsulation (no LLC/Snap header) Config::SetDefault ("ns3::CsmaNetDevice::EncapsulationMode", StringValue ("Dix")); // Allow the user to override any of the defaults at // run-time, via command-line arguments CommandLine cmd; cmd.Parse (argc, argv); NS_LOG_INFO ("Create nodes."); NodeContainer c; c.Create (5); // We will later want two subcontainers of these nodes, for the two LANs NodeContainer c0 = NodeContainer (c.Get (0), c.Get (1), c.Get (2)); NodeContainer c1 = NodeContainer (c.Get (2), c.Get (3), c.Get (4)); NS_LOG_INFO ("Build Topology."); CsmaHelper csma; csma.SetChannelAttribute ("DataRate", DataRateValue (DataRate (5000000))); csma.SetChannelAttribute ("Delay", TimeValue (MilliSeconds (2))); // We will use these NetDevice containers later, for IP addressing NetDeviceContainer nd0 = csma.Install (c0); // First LAN NetDeviceContainer nd1 = csma.Install (c1); // Second LAN NS_LOG_INFO ("Add IP Stack."); InternetStackHelper internet; internet.Install (c); NS_LOG_INFO ("Assign IP Addresses."); Ipv4AddressHelper ipv4Addr; ipv4Addr.SetBase ("10.1.1.0", "255.255.255.0"); ipv4Addr.Assign (nd0); ipv4Addr.SetBase ("10.1.2.0", "255.255.255.0"); ipv4Addr.Assign (nd1); NS_LOG_INFO ("Configure multicasting."); // // Now we can configure multicasting. As described above, the multicast // source is at node zero, which we assigned the IP address of 10.1.1.1 // earlier. We need to define a multicast group to send packets to. This // can be any multicast address from 224.0.0.0 through 239.255.255.255 // (avoiding the reserved routing protocol addresses). // Ipv4Address multicastSource ("10.1.1.1"); Ipv4Address multicastGroup ("225.1.2.4"); // Now, we will set up multicast routing. We need to do three things: // 1) Configure a (static) multicast route on node n2 // 2) Set up a default multicast route on the sender n0 // 3) Have node n4 join the multicast group // We have a helper that can help us with static multicast Ipv4StaticRoutingHelper multicast; // 1) Configure a (static) multicast route on node n2 (multicastRouter) Ptr<Node> multicastRouter = c.Get (2); // The node in question Ptr<NetDevice> inputIf = nd0.Get (2); // The input NetDevice NetDeviceContainer outputDevices; // A container of output NetDevices outputDevices.Add (nd1.Get (0)); // (we only need one NetDevice here) multicast.AddMulticastRoute (multicastRouter, multicastSource, multicastGroup, inputIf, outputDevices); // 2) Set up a default multicast route on the sender n0 Ptr<Node> sender = c.Get (0); Ptr<NetDevice> senderIf = nd0.Get (0); multicast.SetDefaultMulticastRoute (sender, senderIf); // // Create an OnOff application to send UDP datagrams from node zero to the // multicast group (node four will be listening). // NS_LOG_INFO ("Create Applications."); uint16_t multicastPort = 9; // Discard port (RFC 863) // Configure a multicast packet generator that generates a packet // every few seconds OnOffHelper onoff ("ns3::UdpSocketFactory", Address (InetSocketAddress (multicastGroup, multicastPort))); onoff.SetConstantRate (DataRate ("255b/s")); onoff.SetAttribute ("PacketSize", UintegerValue (128)); ApplicationContainer srcC = onoff.Install (c0.Get (0)); // // Tell the application when to start and stop. // srcC.Start (Seconds (1.)); srcC.Stop (Seconds (10.)); // Create an optional packet sink to receive these packets PacketSinkHelper sink ("ns3::UdpSocketFactory", InetSocketAddress (Ipv4Address::GetAny (), multicastPort)); ApplicationContainer sinkC = sink.Install (c1.Get (2)); // Node n4 // Start the sink sinkC.Start (Seconds (1.0)); sinkC.Stop (Seconds (10.0)); NS_LOG_INFO ("Configure Tracing."); // // Configure tracing of all enqueue, dequeue, and NetDevice receive events. // Ascii trace output will be sent to the file "csma-multicast.tr" // AsciiTraceHelper ascii; csma.EnableAsciiAll (ascii.CreateFileStream ("csma-multicast.tr")); // Also configure some tcpdump traces; each interface will be traced. // The output files will be named: // csma-multicast-<nodeId>-<interfaceId>.pcap // and can be read by the "tcpdump -r" command (use "-tt" option to // display timestamps correctly) csma.EnablePcapAll ("csma-multicast", false); // // Now, do the actual simulation. // NS_LOG_INFO ("Run Simulation."); Simulator::Run (); Simulator::Destroy (); NS_LOG_INFO ("Done."); }
int main (int argc, char *argv[]) { // // Users may find it convenient to turn on explicit debugging // for selected modules; the below lines suggest how to do this // #if 0 LogComponentEnable ("CsmaBridgeOneHopExample", LOG_LEVEL_INFO); #endif // // Allow the user to override any of the defaults and the above Bind() at // run-time, via command-line arguments // CommandLine cmd; cmd.Parse (argc, argv); // // Explicitly create the nodes required by the topology (shown above). // NS_LOG_INFO ("Create nodes."); Ptr<Node> n0 = CreateObject<Node> (); Ptr<Node> n1 = CreateObject<Node> (); Ptr<Node> n2 = CreateObject<Node> (); Ptr<Node> n3 = CreateObject<Node> (); Ptr<Node> n4 = CreateObject<Node> (); Ptr<Node> bridge1 = CreateObject<Node> (); Ptr<Node> bridge2 = CreateObject<Node> (); NS_LOG_INFO ("Build Topology"); CsmaHelper csma; csma.SetChannelAttribute ("DataRate", DataRateValue (5000000)); csma.SetChannelAttribute ("Delay", TimeValue (MilliSeconds (2))); // Create the csma links, from each terminal to the bridge // This will create six network devices; we'll keep track separately // of the devices on and off the bridge respectively, for later configuration NetDeviceContainer topLanDevices; NetDeviceContainer topBridgeDevices; // It is easier to iterate the nodes in C++ if we put them into a container NodeContainer topLan (n2, n0, n1); for (int i = 0; i < 3; i++) { // install a csma channel between the ith toplan node and the bridge node NetDeviceContainer link = csma.Install (NodeContainer (topLan.Get (i), bridge1)); topLanDevices.Add (link.Get (0)); topBridgeDevices.Add (link.Get (1)); } // // Now, Create the bridge netdevice, which will do the packet switching. The // bridge lives on the node bridge1 and bridges together the topBridgeDevices // which are the three CSMA net devices on the node in the diagram above. // BridgeHelper bridge; bridge.Install (bridge1, topBridgeDevices); // Add internet stack to the router nodes NodeContainer routerNodes (n0, n1, n2, n3, n4); InternetStackHelper internet; internet.Install (routerNodes); // Repeat for bottom bridged LAN NetDeviceContainer bottomLanDevices; NetDeviceContainer bottomBridgeDevices; NodeContainer bottomLan (n2, n3, n4); for (int i = 0; i < 3; i++) { NetDeviceContainer link = csma.Install (NodeContainer (bottomLan.Get (i), bridge2)); bottomLanDevices.Add (link.Get (0)); bottomBridgeDevices.Add (link.Get (1)); } bridge.Install (bridge2, bottomBridgeDevices); // We've got the "hardware" in place. Now we need to add IP addresses. NS_LOG_INFO ("Assign IP Addresses."); Ipv4AddressHelper ipv4; ipv4.SetBase ("10.1.1.0", "255.255.255.0"); ipv4.Assign (topLanDevices); ipv4.SetBase ("10.1.2.0", "255.255.255.0"); ipv4.Assign (bottomLanDevices); // // Create router nodes, initialize routing database and set up the routing // tables in the nodes. We excuse the bridge nodes from having to serve as // routers, since they don't even have internet stacks on them. // Ipv4GlobalRoutingHelper::PopulateRoutingTables (); // // Create an OnOff application to send UDP datagrams from node zero to node 1. // NS_LOG_INFO ("Create Applications."); uint16_t port = 9; // Discard port (RFC 863) OnOffHelper onoff ("ns3::UdpSocketFactory", Address (InetSocketAddress (Ipv4Address ("10.1.1.3"), port))); onoff.SetConstantRate (DataRate ("500kb/s")); ApplicationContainer app = onoff.Install (n0); // Start the application app.Start (Seconds (1.0)); app.Stop (Seconds (10.0)); // Create an optional packet sink to receive these packets PacketSinkHelper sink ("ns3::UdpSocketFactory", Address (InetSocketAddress (Ipv4Address::GetAny (), port))); ApplicationContainer sink1 = sink.Install (n1); sink1.Start (Seconds (1.0)); sink1.Stop (Seconds (10.0)); // // Create a similar flow from n3 to n0, starting at time 1.1 seconds // onoff.SetAttribute ("Remote", AddressValue (InetSocketAddress (Ipv4Address ("10.1.1.2"), port))); ApplicationContainer app2 = onoff.Install (n3); app2.Start (Seconds (1.1)); app2.Stop (Seconds (10.0)); ApplicationContainer sink2 = sink.Install (n0); sink2.Start (Seconds (1.1)); sink2.Stop (Seconds (10.0)); NS_LOG_INFO ("Configure Tracing."); // // Configure tracing of all enqueue, dequeue, and NetDevice receive events. // Trace output will be sent to the file "csma-bridge-one-hop.tr" // AsciiTraceHelper ascii; csma.EnableAsciiAll (ascii.CreateFileStream ("csma-bridge-one-hop.tr")); // // Also configure some tcpdump traces; each interface will be traced. // The output files will be named: // csma-bridge-one-hop-<nodeId>-<interfaceId>.pcap // and can be read by the "tcpdump -r" command (use "-tt" option to // display timestamps correctly) // csma.EnablePcapAll ("csma-bridge-one-hop", false); // // Now, do the actual simulation. // NS_LOG_INFO ("Run Simulation."); Simulator::Run (); Simulator::Destroy (); NS_LOG_INFO ("Done."); }