diff --git a/model/leo-mock-channel.cc b/model/leo-mock-channel.cc index 7953ad5..9cd71f7 100644 --- a/model/leo-mock-channel.cc +++ b/model/leo-mock-channel.cc @@ -62,12 +62,17 @@ LeoMockChannel::TransmitStart (Ptr p, NS_LOG_ERROR ("unable to find satellite with address " << dst); return false; } - NS_LOG_DEBUG ("BOOOOM " << srcDev->GetAddress () << " -> " << dst); return Deliver (p, srcDev, it->second, txTime); } else // space to ground delivers to everything within the beam { + DeviceIndex::iterator it = m_groundDevices.find (dst); + if (it == m_groundDevices.end ()) + { + NS_LOG_ERROR ("unable to find satellite with address " << dst); + return false; + } for (DeviceIndex::iterator it = m_groundDevices.begin (); it != m_groundDevices.end (); it++) diff --git a/model/leo-propagation-loss-model.cc b/model/leo-propagation-loss-model.cc new file mode 100644 index 0000000..e427c0f --- /dev/null +++ b/model/leo-propagation-loss-model.cc @@ -0,0 +1,51 @@ +/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */ + +#include "leo-propagation-loss-model.h" + +namespace ns3 { + +NS_LOG_COMPONENT_DEFINE ("LeoPropagationLossModel"); + +NS_OBJECT_ENSURE_REGISTERED (LeoPropagationLossModel); + +TypeId +LeoPropagationLossModel::GetTypeId (void) +{ + static TypeId tid = TypeId ("ns3::LeoPropagationLossModel") + .SetParent () + .SetGroupName ("Leo") + .AddConstructor () + ; + return tid; +} + +LeoPropagationLossModel::LeoPropagationLossModel () +{ +} + +LeoPropagationLossModel::~LeoPropagationLossModel () +{ +} + +double +LeoPropagationLossModel::DoCalcRxPower (double txPowerDbm, + Ptr a, + Ptr b) const +{ + //Vector aPos = a->GetPosition (); + //Vector bPos = b->GetPosition (); + + // TODO perform line-earth intersection (ray tracing) + + double rxc = 0;//-m_variable->GetValue (); + NS_LOG_DEBUG ("attenuation coefficient="< +#include + +namespace ns3 { + +class LeoPropagationLossModel : public PropagationLossModel +{ +public: + static TypeId GetTypeId (void); + LeoPropagationLossModel (); + virtual ~LeoPropagationLossModel (); +private: + /** + * Returns the Rx Power taking into account only the particular + * PropagationLossModel. + * + * \param txPowerDbm current transmission power (in dBm) + * \param a the mobility model of the source + * \param b the mobility model of the destination + * \returns the reception power after adding/multiplying propagation loss (in dBm) + */ + virtual double DoCalcRxPower (double txPowerDbm, + Ptr a, + Ptr b) const; + /** + * Subclasses must implement this; those not using random variables + * can return zero + */ + virtual int64_t DoAssignStreams (int64_t stream); +}; + +} + +#endif /* SATELLITE_LEO_PROPAGATION_LOSS_MODEL_H */ diff --git a/test/leo-mock-channel-test-suite.cc b/test/leo-mock-channel-test-suite.cc new file mode 100644 index 0000000..f7283eb --- /dev/null +++ b/test/leo-mock-channel-test-suite.cc @@ -0,0 +1,219 @@ +/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */ + +#include "ns3/core-module.h" +#include "ns3/network-module.h" +#include "ns3/internet-module.h" +#include "ns3/applications-module.h" +#include "ns3/node-container.h" + +#include "ns3/leo-module.h" +#include "ns3/test.h" + +using namespace ns3; + +class LeoMockChannelTransmitUnknownTestCase : public TestCase +{ +public: + LeoMockChannelTransmitUnknownTestCase (); + virtual ~LeoMockChannelTransmitUnknownTestCase (); + +private: + virtual void DoRun (void); +}; + +LeoMockChannelTransmitUnknownTestCase::LeoMockChannelTransmitUnknownTestCase () + : TestCase ("Test transmission to unkown destination") +{ +} + +LeoMockChannelTransmitUnknownTestCase::~LeoMockChannelTransmitUnknownTestCase () +{ +} + +void +LeoMockChannelTransmitUnknownTestCase::DoRun (void) +{ + Ptr channel = CreateObject (); + Packet *packet = new Packet (); + Ptr p = Ptr(packet); + Ptr dev = CreateObject (); + dev->SetDeviceType (LeoMockNetDevice::GND); + int32_t srcId = channel->Attach (dev); + Address destAddr; + Time txTime; + channel->SetAttribute ("PropagationDelay", StringValue ("ns3::ConstantSpeedPropagationDelayModel")); + channel->SetAttribute ("PropagationLoss", StringValue ("ns3::LeoPropagationLossModel")); + dev->SetAttribute ("MobilityModel", StringValue ("ns3::ConstantPositionMobilityModel")); + bool result = channel->TransmitStart (p, srcId, destAddr, txTime); + + NS_TEST_ASSERT_MSG_EQ (result, false, "Unknown destination fails to deliver"); +} + +class LeoMockChannelTransmitKnownTestCase : public TestCase +{ +public: + LeoMockChannelTransmitKnownTestCase (); + virtual ~LeoMockChannelTransmitKnownTestCase (); + +private: + virtual void DoRun (void); +}; + +LeoMockChannelTransmitKnownTestCase::LeoMockChannelTransmitKnownTestCase () + : TestCase ("Test transmission to known destination") +{ +} + +LeoMockChannelTransmitKnownTestCase::~LeoMockChannelTransmitKnownTestCase () +{ +} + +void +LeoMockChannelTransmitKnownTestCase::DoRun (void) +{ + Ptr channel = CreateObject (); + channel->SetAttribute ("PropagationDelay", StringValue ("ns3::ConstantSpeedPropagationDelayModel")); + channel->SetAttribute ("PropagationLoss", StringValue ("ns3::LeoPropagationLossModel")); + + Packet *packet = new Packet (); + Ptr p = Ptr(packet); + + Ptr srcNode = CreateObject (); + Ptr srcDev = CreateObject (); + srcDev->SetNode (srcNode); + srcDev->SetAttribute ("MobilityModel", StringValue ("ns3::ConstantPositionMobilityModel")); + srcDev->SetDeviceType (LeoMockNetDevice::GND); + int32_t srcId = channel->Attach (srcDev); + + Ptr dstNode = CreateObject (); + Ptr dstDev = CreateObject (); + dstDev->SetNode (dstNode); + dstDev->SetAttribute ("MobilityModel", StringValue ("ns3::LeoMobilityModel")); + dstDev->SetDeviceType (LeoMockNetDevice::SAT); + channel->Attach (dstDev); + + Address destAddr = dstDev->GetAddress (); + Time txTime; + bool result = channel->TransmitStart (p, srcId, destAddr, txTime); + + NS_TEST_ASSERT_MSG_EQ (result, true, "Known destination delivers"); +} + +class LeoMockChannelTransmitSpaceGroundTestCase : public TestCase +{ +public: + LeoMockChannelTransmitSpaceGroundTestCase (); + virtual ~LeoMockChannelTransmitSpaceGroundTestCase (); + +private: + virtual void DoRun (void); +}; + +LeoMockChannelTransmitSpaceGroundTestCase::LeoMockChannelTransmitSpaceGroundTestCase () + : TestCase ("Test transmission to known destination") +{ +} + +LeoMockChannelTransmitSpaceGroundTestCase::~LeoMockChannelTransmitSpaceGroundTestCase () +{ +} + +void +LeoMockChannelTransmitSpaceGroundTestCase::DoRun (void) +{ + Ptr channel = CreateObject (); + channel->SetAttribute ("PropagationDelay", StringValue ("ns3::ConstantSpeedPropagationDelayModel")); + channel->SetAttribute ("PropagationLoss", StringValue ("ns3::LeoPropagationLossModel")); + + Packet *packet = new Packet (); + Ptr p = Ptr(packet); + + Ptr srcNode = CreateObject (); + Ptr srcDev = CreateObject (); + srcDev->SetNode (srcNode); + srcDev->SetAttribute ("MobilityModel", StringValue ("ns3::LeoMobilityModel")); + srcDev->SetDeviceType (LeoMockNetDevice::SAT); + int32_t srcId = channel->Attach (srcDev); + + Ptr dstNode = CreateObject (); + Ptr dstDev = CreateObject (); + dstDev->SetNode (dstNode); + dstDev->SetAttribute ("MobilityModel", StringValue ("ns3::ConstantPositionMobilityModel")); + dstDev->SetDeviceType (LeoMockNetDevice::GND); + channel->Attach (dstDev); + + Address destAddr = dstDev->GetAddress (); + Time txTime; + bool result = channel->TransmitStart (p, srcId, destAddr, txTime); + + NS_TEST_ASSERT_MSG_EQ (result, true, "Space to ground destination delivers"); +} + +class LeoMockChannelTransmitSpaceSpaceTestCase : public TestCase +{ +public: + LeoMockChannelTransmitSpaceSpaceTestCase (); + virtual ~LeoMockChannelTransmitSpaceSpaceTestCase (); + +private: + virtual void DoRun (void); +}; + +LeoMockChannelTransmitSpaceSpaceTestCase::LeoMockChannelTransmitSpaceSpaceTestCase () + : TestCase ("Test transmission to known destination") +{ +} + +LeoMockChannelTransmitSpaceSpaceTestCase::~LeoMockChannelTransmitSpaceSpaceTestCase () +{ +} + +void +LeoMockChannelTransmitSpaceSpaceTestCase::DoRun (void) +{ + Ptr channel = CreateObject (); + channel->SetAttribute ("PropagationDelay", StringValue ("ns3::ConstantSpeedPropagationDelayModel")); + channel->SetAttribute ("PropagationLoss", StringValue ("ns3::LeoPropagationLossModel")); + + Packet *packet = new Packet (); + Ptr p = Ptr(packet); + + Ptr srcNode = CreateObject (); + Ptr srcDev = CreateObject (); + srcDev->SetNode (srcNode); + srcDev->SetAttribute ("MobilityModel", StringValue ("ns3::LeoMobilityModel")); + srcDev->SetDeviceType (LeoMockNetDevice::SAT); + int32_t srcId = channel->Attach (srcDev); + + Ptr dstNode = CreateObject (); + Ptr dstDev = CreateObject (); + dstDev->SetNode (dstNode); + dstDev->SetAttribute ("MobilityModel", StringValue ("ns3::LeoMobilityModel")); + dstDev->SetDeviceType (LeoMockNetDevice::SAT); + channel->Attach (dstDev); + + Address destAddr = dstDev->GetAddress (); + Time txTime; + bool result = channel->TransmitStart (p, srcId, destAddr, txTime); + + NS_TEST_ASSERT_MSG_EQ (result, false, "Space to space gets dropped"); +} + +class LeoMockChannelTestSuite : public TestSuite +{ +public: + LeoMockChannelTestSuite (); +}; + +LeoMockChannelTestSuite::LeoMockChannelTestSuite () + : TestSuite ("leo-mock-channel", UNIT) +{ + // TestDuration for TestCase can be QUICK, EXTENSIVE or TAKES_FOREVER + AddTestCase (new LeoMockChannelTransmitUnknownTestCase, TestCase::QUICK); + AddTestCase (new LeoMockChannelTransmitKnownTestCase, TestCase::QUICK); + AddTestCase (new LeoMockChannelTransmitSpaceGroundTestCase, TestCase::QUICK); + AddTestCase (new LeoMockChannelTransmitSpaceSpaceTestCase, TestCase::QUICK); +} + +// Do not forget to allocate an instance of this TestSuite +static LeoMockChannelTestSuite islMockChannelTestSuite; diff --git a/test/leo-test-suite.cc b/test/leo-test-suite.cc index 4cfb105..b88ac65 100644 --- a/test/leo-test-suite.cc +++ b/test/leo-test-suite.cc @@ -48,7 +48,6 @@ LeoTestCase1::DoRun (void) LeoHelper leo; leo.SetDeviceAttribute ("DataRate", StringValue ("10Mbps")); leo.SetChannelAttribute ("PropagationDelay", StringValue ("ns3::ConstantSpeedPropagationDelayModel")); - leo.SetChannelAttribute ("PropagationLoss", StringValue ("ns3::IslPropagationLossModel")); leo.SetDeviceAttribute ("MobilityModel", StringValue ("ns3::LeoMobilityModel")); NetDeviceContainer allDevices = leo.Install (satellites, gateways, terminals); diff --git a/wscript b/wscript index f9cb134..d60c9ef 100644 --- a/wscript +++ b/wscript @@ -18,6 +18,7 @@ def build(bld): 'model/leo-mock-channel.cc', 'model/leo-mock-net-device.cc', 'helper/leo-helper.cc', + 'model/leo-propagation-loss-model.cc', 'model/mock-net-device.cc', 'model/mock-channel.cc', 'helper/nd-cache-helper.cc', @@ -28,6 +29,7 @@ def build(bld): 'test/leo-test-suite.cc', 'test/isl-test-suite.cc', 'test/isl-mock-channel-test-suite.cc', + 'test/leo-mock-channel-test-suite.cc', ] headers = bld(features='ns3header') @@ -42,6 +44,7 @@ def build(bld): 'model/leo-mock-channel.h', 'model/leo-mock-net-device.h', 'helper/leo-helper.h', + 'model/leo-propagation-loss-model.h', 'model/mock-net-device.h', 'model/mock-channel.h', 'helper/nd-cache-helper.h',