int main (int argc, char *argv[]) { CommandLine cmd; cmd.Parse (argc, argv); // to save a template default attribute file run it like this: // ./waf --command-template="%s --ns3::ConfigStore::Filename=input-defaults.txt --ns3::ConfigStore::Mode=Save --ns3::ConfigStore::FileFormat=RawText" --run src/lte/examples/lena-first-sim // // to load a previously created default attribute file // ./waf --command-template="%s --ns3::ConfigStore::Filename=input-defaults.txt --ns3::ConfigStore::Mode=Load --ns3::ConfigStore::FileFormat=RawText" --run src/lte/examples/lena-first-sim ConfigStore inputConfig; inputConfig.ConfigureDefaults (); // parse again so you can override default values from the command line cmd.Parse (argc, argv); Ptr<LteHelper> lteHelper = CreateObject<LteHelper> (); lteHelper->SetAttribute ("PathlossModel", StringValue ("ns3::FriisSpectrumPropagationLossModel")); // Uncomment to enable logging //lteHelper->EnableLogComponents (); // Create Nodes: eNodeB and UE NodeContainer enbNodes; NodeContainer ueNodes; enbNodes.Create (1); 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); // Create Devices and install them in the Nodes (eNB and UE) NetDeviceContainer enbDevs; NetDeviceContainer ueDevs; // lteHelper->SetSchedulerType ("ns3::RrFfMacScheduler"); lteHelper->SetSchedulerType ("ns3::PfFfMacScheduler"); lteHelper->SetSchedulerAttribute ("CqiTimerThreshold", UintegerValue (3)); enbDevs = lteHelper->InstallEnbDevice (enbNodes); ueDevs = lteHelper->InstallUeDevice (ueNodes); lteHelper->EnableRlcTraces(); lteHelper->EnableMacTraces(); // Attach a UE to a eNB lteHelper->Attach (ueDevs, enbDevs.Get (0)); Simulator::Schedule (Seconds (0.010), &ChangePosition, ueNodes.Get (0)); Simulator::Schedule (Seconds (0.020), &ChangePosition, ueNodes.Get (0)); // Activate a data radio bearer enum EpsBearer::Qci q = EpsBearer::GBR_CONV_VOICE; EpsBearer bearer (q); lteHelper->ActivateDataRadioBearer (ueDevs, bearer); Simulator::Stop (Seconds (0.030)); Simulator::Run (); //GtkConfigStore config; //config.ConfigureAttributes (); Simulator::Destroy (); return 0; }
int main (int argc, char *argv[]) { CommandLine cmd; cmd.Parse (argc, argv); // to save a template default attribute file run it like this: // ./waf --command-template="%s --ns3::ConfigStore::Filename=input-defaults.txt --ns3::ConfigStore::Mode=Save --ns3::ConfigStore::FileFormat=RawText" --run src/lte/examples/lena-first-sim // // to load a previously created default attribute file // ./waf --command-template="%s --ns3::ConfigStore::Filename=input-defaults.txt --ns3::ConfigStore::Mode=Load --ns3::ConfigStore::FileFormat=RawText" --run src/lte/examples/lena-first-sim ConfigStore inputConfig; inputConfig.ConfigureDefaults (); // Parse again so you can override default values from the command line cmd.Parse (argc, argv); Ptr<LteHelper> lteHelper = CreateObject<LteHelper> (); // Uncomment to enable logging //lteHelper->EnableLogComponents (); // Create Nodes: eNodeB and UE NodeContainer enbNodes; NodeContainer ueNodes; enbNodes.Create (1); 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); // Create Devices and install them in the Nodes (eNB and UE) NetDeviceContainer enbDevs; NetDeviceContainer ueDevs; // Default scheduler is PF, uncomment to use RR //lteHelper->SetSchedulerType ("ns3::RrFfMacScheduler"); enbDevs = lteHelper->InstallEnbDevice (enbNodes); ueDevs = lteHelper->InstallUeDevice (ueNodes); // Attach a UE to a eNB lteHelper->Attach (ueDevs, enbDevs.Get (0)); // Activate an EPS bearer enum EpsBearer::Qci q = EpsBearer::GBR_CONV_VOICE; EpsBearer bearer (q); lteHelper->ActivateDataRadioBearer (ueDevs, bearer); // Configure Radio Environment Map (REM) output // for LTE-only simulations always use /ChannelList/0 which is the downlink channel Ptr<RadioEnvironmentMapHelper> remHelper = CreateObject<RadioEnvironmentMapHelper> (); remHelper->SetAttribute ("ChannelPath", StringValue ("/ChannelList/0")); remHelper->SetAttribute ("OutputFile", StringValue ("rem.out")); remHelper->SetAttribute ("XMin", DoubleValue (-400.0)); remHelper->SetAttribute ("XMax", DoubleValue (400.0)); remHelper->SetAttribute ("YMin", DoubleValue (-300.0)); remHelper->SetAttribute ("YMax", DoubleValue (300.0)); remHelper->SetAttribute ("Z", DoubleValue (0.0)); remHelper->Install (); // here's a minimal gnuplot script that will plot the above: // // set view map; // set term x11; // set xlabel "X" // set ylabel "Y" // set cblabel "SINR (dB)" // plot "rem.out" using ($1):($2):(10*log10($4)) with image BuildingsHelper::MakeMobilityModelConsistent (); Simulator::Run (); //GtkConfigStore config; //config.ConfigureAttributes (); Simulator::Destroy (); return 0; }
void LenaMimoTestCase::DoRun (void) { NS_LOG_FUNCTION (this << GetName ()); Config::SetDefault ("ns3::LteSpectrumPhy::DataErrorModelEnabled", BooleanValue (false)); Config::SetDefault ("ns3::LteAmc::AmcModel", EnumValue (LteAmc::PiroEW2010)); Config::SetDefault ("ns3::LteHelper::UseIdealRrc", BooleanValue (m_useIdealRrc)); /** * Initialize Simulation Scenario: 1 eNB and m_nUser UEs */ Ptr<LteHelper> lteHelper = CreateObject<LteHelper> (); Config::SetDefault ("ns3::RrFfMacScheduler::HarqEnabled", BooleanValue (false)); Config::SetDefault ("ns3::PfFfMacScheduler::HarqEnabled", BooleanValue (false)); // lteHelper->SetSchedulerAttribute ("HarqEnabled", BooleanValue (false)); lteHelper->SetAttribute ("PathlossModel", StringValue ("ns3::HybridBuildingsPropagationLossModel")); lteHelper->SetPathlossModelAttribute ("ShadowSigmaOutdoor", DoubleValue (0.0)); lteHelper->SetPathlossModelAttribute ("ShadowSigmaIndoor", DoubleValue (0.0)); lteHelper->SetPathlossModelAttribute ("ShadowSigmaExtWalls", DoubleValue (0.0)); // lteHelper->EnableLogComponents (); // Create Nodes: eNodeB and UE NodeContainer enbNodes; NodeContainer ueNodes; enbNodes.Create (1); 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); // Create Devices and install them in the Nodes (eNB and UE) NetDeviceContainer enbDevs; NetDeviceContainer ueDevs; lteHelper->SetSchedulerType (m_schedulerType); enbDevs = lteHelper->InstallEnbDevice (enbNodes); ueDevs = lteHelper->InstallUeDevice (ueNodes); // Attach a UE to a eNB lteHelper->Attach (ueDevs, enbDevs.Get (0)); // Activate an EPS bearer enum EpsBearer::Qci q = EpsBearer::GBR_CONV_VOICE; EpsBearer bearer (q); lteHelper->ActivateDataRadioBearer (ueDevs, bearer); Ptr<LteEnbNetDevice> lteEnbDev = enbDevs.Get (0)->GetObject<LteEnbNetDevice> (); Ptr<LteEnbPhy> enbPhy = lteEnbDev->GetPhy (); enbPhy->SetAttribute ("TxPower", DoubleValue (46.0)); enbPhy->SetAttribute ("NoiseFigure", DoubleValue (5.0)); Ptr<MobilityModel> mmenb = enbNodes.Get (0)->GetObject<MobilityModel> (); mmenb->SetPosition (Vector (0.0, 0.0, 30.0)); // Set UE's position and power Ptr<MobilityModel> mmue = ueNodes.Get (0)->GetObject<MobilityModel> (); mmue->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)); // need to allow for RRC connection establishment + SRS before enabling traces lteHelper->EnableRlcTraces (); lteHelper->EnableMacTraces (); double simulationTime = 0.6; double tolerance = 0.1; uint8_t rnti = 1; Ptr<LteEnbNetDevice> enbNetDev = enbDevs.Get (0)->GetObject<LteEnbNetDevice> (); PointerValue ptrval; enbNetDev->GetAttribute ("FfMacScheduler", ptrval); Ptr<PfFfMacScheduler> pfsched; Ptr<RrFfMacScheduler> rrsched; if (m_schedulerType.compare ("ns3::RrFfMacScheduler") == 0) { rrsched = ptrval.Get<RrFfMacScheduler> (); if (rrsched == 0) { NS_FATAL_ERROR ("No RR Scheduler available"); } Simulator::Schedule (Seconds (0.2), &RrFfMacScheduler::TransmissionModeConfigurationUpdate, rrsched, rnti, 1); Simulator::Schedule (Seconds (0.4), &RrFfMacScheduler::TransmissionModeConfigurationUpdate, rrsched, rnti, 2); } else if (m_schedulerType.compare ("ns3::PfFfMacScheduler") == 0) { pfsched = ptrval.Get<PfFfMacScheduler> (); if (pfsched == 0) { NS_FATAL_ERROR ("No Pf Scheduler available"); } Simulator::Schedule (Seconds (0.2), &PfFfMacScheduler::TransmissionModeConfigurationUpdate, pfsched, rnti, 1); Simulator::Schedule (Seconds (0.4), &PfFfMacScheduler::TransmissionModeConfigurationUpdate, pfsched, rnti, 2); } else { NS_FATAL_ERROR ("Scheduler not supported by this test"); } Ptr<RadioBearerStatsCalculator> rlcStats = lteHelper->GetRlcStats (); rlcStats->SetAttribute ("EpochDuration", TimeValue (Seconds (0.1))); NS_LOG_INFO (m_schedulerType << " MIMO test:"); double sampleTime = 0.199999; // at 0.2 RlcStats are reset for (uint8_t j = 0; j < m_estThrDl.size (); j ++) { NS_LOG_INFO ("\t test with user at distance " << m_dist << " time " << sampleTime); // get the imsi uint64_t imsi = ueDevs.Get (0)->GetObject<LteUeNetDevice> ()->GetImsi (); uint8_t lcId = 3; Time t = Seconds (sampleTime); Simulator::Schedule(t, &LenaMimoTestCase::GetRlcBufferSample, this, rlcStats, imsi, lcId); sampleTime += 0.2; } Simulator::Stop (Seconds (simulationTime)); Simulator::Run (); Simulator::Destroy (); NS_LOG_INFO ("Check consistency"); for (uint8_t i = 0; i < m_estThrDl.size (); i++) { NS_LOG_INFO ("interval " << i + 1 << ": bytes rxed " << (double)m_dlDataRxed.at (i) << " ref " << m_estThrDl.at (i)); NS_TEST_ASSERT_MSG_EQ_TOL ((double)m_dlDataRxed.at (i) , m_estThrDl.at (i), m_estThrDl.at (i) * tolerance, " Unfair Throughput!"); } }
int main (int argc, char *argv[]) { uint32_t nEnbPerFloor = 1; uint32_t nUe = 1; uint32_t nFloors = 0; double simTime = 1.0; CommandLine cmd; cmd.AddValue ("nEnb", "Number of eNodeBs per floor", nEnbPerFloor); cmd.AddValue ("nUe", "Number of UEs", nUe); cmd.AddValue ("nFloors", "Number of floors, 0 for Friis propagation model", nFloors); cmd.AddValue ("simTime", "Total duration of the simulation (in seconds)", simTime); cmd.Parse (argc, argv); ConfigStore inputConfig; inputConfig.ConfigureDefaults (); // parse again so you can override default values from the command line cmd.Parse (argc, argv); // Geometry of the scenario (in meters) // Assume squared building double nodeHeight = 1.5; double roomHeight = 3; double roomLength = 8; uint32_t nRooms = std::ceil (std::sqrt (nEnbPerFloor)); uint32_t nEnb; Ptr<LteHelper> lteHelper = CreateObject<LteHelper> (); //lteHelper->EnableLogComponents (); //LogComponentEnable ("BuildingsPropagationLossModel", LOG_LEVEL_ALL); if (nFloors == 0) { lteHelper->SetAttribute ("PathlossModel", StringValue ("ns3::FriisPropagationLossModel")); nEnb = nEnbPerFloor; } else { lteHelper->SetAttribute ("PathlossModel", StringValue ("ns3::HybridBuildingsPropagationLossModel")); nEnb = nFloors * nEnbPerFloor; } // Create Nodes: eNodeB and UE NodeContainer enbNodes; std::vector<NodeContainer> ueNodes; enbNodes.Create (nEnb); for (uint32_t i = 0; i < nEnb; i++) { NodeContainer ueNode; ueNode.Create (nUe); ueNodes.push_back (ueNode); } MobilityHelper mobility; mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel"); std::vector<Vector> enbPosition; Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator> (); Ptr<Building> building; if (nFloors == 0) { // Position of eNBs uint32_t plantedEnb = 0; for (uint32_t row = 0; row < nRooms; row++) { for (uint32_t column = 0; column < nRooms && plantedEnb < nEnbPerFloor; column++, plantedEnb++) { Vector v (roomLength * (column + 0.5), roomLength * (row + 0.5), nodeHeight); positionAlloc->Add (v); enbPosition.push_back (v); mobility.Install (ueNodes.at(plantedEnb)); } } mobility.SetPositionAllocator (positionAlloc); mobility.Install (enbNodes); BuildingsHelper::Install (enbNodes); // Position of UEs attached to eNB for (uint32_t i = 0; i < nEnb; i++) { Ptr<UniformRandomVariable> posX = CreateObject<UniformRandomVariable> (); posX->SetAttribute ("Min", DoubleValue (enbPosition.at(i).x - roomLength * 0.5)); posX->SetAttribute ("Max", DoubleValue (enbPosition.at(i).x + roomLength * 0.5)); Ptr<UniformRandomVariable> posY = CreateObject<UniformRandomVariable> (); posY->SetAttribute ("Min", DoubleValue (enbPosition.at(i).y - roomLength * 0.5)); posY->SetAttribute ("Max", DoubleValue (enbPosition.at(i).y + roomLength * 0.5)); positionAlloc = CreateObject<ListPositionAllocator> (); for (uint32_t j = 0; j < nUe; j++) { positionAlloc->Add (Vector (posX->GetValue (), posY->GetValue (), nodeHeight)); mobility.SetPositionAllocator (positionAlloc); } mobility.Install (ueNodes.at(i)); BuildingsHelper::Install (ueNodes.at(i)); } } else { building = CreateObject<Building> (); building->SetBoundaries (Box (0.0, nRooms * roomLength, 0.0, nRooms * roomLength, 0.0, nFloors* roomHeight)); building->SetBuildingType (Building::Residential); building->SetExtWallsType (Building::ConcreteWithWindows); building->SetNFloors (nFloors); building->SetNRoomsX (nRooms); building->SetNRoomsY (nRooms); mobility.Install (enbNodes); BuildingsHelper::Install (enbNodes); uint32_t plantedEnb = 0; for (uint32_t floor = 0; floor < nFloors; floor++) { uint32_t plantedEnbPerFloor = 0; for (uint32_t row = 0; row < nRooms; row++) { for (uint32_t column = 0; column < nRooms && plantedEnbPerFloor < nEnbPerFloor; column++, plantedEnb++, plantedEnbPerFloor++) { Vector v (roomLength * (column + 0.5), roomLength * (row + 0.5), nodeHeight + roomHeight * floor); positionAlloc->Add (v); enbPosition.push_back (v); Ptr<MobilityModel> mmEnb = enbNodes.Get (plantedEnb)->GetObject<MobilityModel> (); mmEnb->SetPosition (v); // Positioning UEs attached to eNB mobility.Install (ueNodes.at(plantedEnb)); BuildingsHelper::Install (ueNodes.at(plantedEnb)); for (uint32_t ue = 0; ue < nUe; ue++) { Ptr<MobilityModel> mmUe = ueNodes.at(plantedEnb).Get (ue)->GetObject<MobilityModel> (); Vector vUe (v.x, v.y, v.z); mmUe->SetPosition (vUe); } } } } } // Create Devices and install them in the Nodes (eNB and UE) NetDeviceContainer enbDevs; std::vector<NetDeviceContainer> ueDevs; enbDevs = lteHelper->InstallEnbDevice (enbNodes); for (uint32_t i = 0; i < nEnb; i++) { NetDeviceContainer ueDev = lteHelper->InstallUeDevice (ueNodes.at(i)); ueDevs.push_back (ueDev); lteHelper->Attach (ueDev, enbDevs.Get (i)); enum EpsBearer::Qci q = EpsBearer::GBR_CONV_VOICE; EpsBearer bearer (q); lteHelper->ActivateDataRadioBearer (ueDev, bearer); } BuildingsHelper::MakeMobilityModelConsistent (); Simulator::Stop (Seconds (simTime)); lteHelper->EnableTraces (); Simulator::Run (); /*GtkConfigStore config; config.ConfigureAttributes ();*/ Simulator::Destroy (); return 0; }
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 (); }