embedded-systems/eden-sim
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
main
eden-sim/contrib/tsn/test/tsn-multidrop-test-suite.cc

864 lines
30 KiB
C++
Raw Permalink Blame History

// Include a header file from your module to test.
#include "ns3/tsn-multidrop-net-device.h"
#include "ns3/tsn-multidrop-channel.h"
#include "ns3/tsn-net-device.h"
#include "ns3/tsn-node.h"
#include "ns3/ethernet-channel.h"
#include "ns3/ethernet-header2.h"
#include "ns3/ethernet-generator.h"
#include "ns3/switch-net-device.h"
// An essential include is test.h
#include "ns3/test.h"
#include "ns3/core-module.h"
#include "ns3/drop-tail-queue.h"
#include "ns3/timestamp-tag.h"
// Do not put your test classes in namespace ns3. You may find it useful
// to use the using directive to access the ns3 namespace directly
using namespace ns3;
NS_LOG_COMPONENT_DEFINE("TsnMultidropTestSuite");
// Add a doxygen group for tests.
// If you have more than one test, this should be in only one of them.
/**
* \defgroup tsn-multidrop-tests Tests for multidrop tsn
* \ingroup tsn
* \ingroup tests
*/
/**
* \ingroup tsn-multidrop-tests
* Check if message crossed an tsn multidrop channel
*/
class TsnMultiDropBasicTestCase1Flow : public TestCase
{
public:
TsnMultiDropBasicTestCase1Flow();
virtual ~TsnMultiDropBasicTestCase1Flow();
private:
void DoRun() override;
void SendTx(Ptr<const Packet> p);
void ReceiveRx(Ptr<const Packet> p);
uint64_t m_sent{0}; //!< number of bytes sent
uint64_t m_received{0}; //!< number of bytes received
};
// Add some help text to this case to describe what it is intended to test
TsnMultiDropBasicTestCase1Flow::TsnMultiDropBasicTestCase1Flow()
: TestCase("Check if message crossed an tsn multidrop channel")
{
}
// This destructor does nothing but we include it as a reminder that
// the test case should clean up after itself
TsnMultiDropBasicTestCase1Flow::~TsnMultiDropBasicTestCase1Flow()
{
}
void
TsnMultiDropBasicTestCase1Flow::SendTx(Ptr<const Packet> p)
{
m_sent += p->GetSize();
}
void
TsnMultiDropBasicTestCase1Flow::ReceiveRx(Ptr<const Packet> p)
{
m_received += p->GetSize();
}
//
// This method is the pure virtual method from class TestCase that every
// TestCase must implement
//
void
TsnMultiDropBasicTestCase1Flow::DoRun()
{
//Create four nodes
Ptr<TsnNode> n0 = CreateObject<TsnNode>();
Ptr<TsnNode> n1 = CreateObject<TsnNode>();
Ptr<TsnNode> n2 = CreateObject<TsnNode>();
Ptr<TsnNode> n3 = CreateObject<TsnNode>();
//Create and add a netDevice to each node
Ptr<TsnMultidropNetDevice> net0 = CreateObject<TsnMultidropNetDevice>();
net0->SetAttribute("PLCALocalNodeId", UintegerValue(0));
net0->SetAttribute("PLCANodeCount", UintegerValue(4));
n0->AddDevice(net0);
Ptr<TsnMultidropNetDevice> net1 = CreateObject<TsnMultidropNetDevice>();
net1->SetAttribute("PLCALocalNodeId", UintegerValue(1));
net1->SetAttribute("PLCANodeCount", UintegerValue(4));
n1->AddDevice(net1);
Ptr<TsnMultidropNetDevice> net2 = CreateObject<TsnMultidropNetDevice>();
net2->SetAttribute("PLCALocalNodeId", UintegerValue(2));
net2->SetAttribute("PLCANodeCount", UintegerValue(4));
n2->AddDevice(net2);
Ptr<TsnMultidropNetDevice> net3 = CreateObject<TsnMultidropNetDevice>();
net3->SetAttribute("PLCALocalNodeId", UintegerValue(3));
net3->SetAttribute("PLCANodeCount", UintegerValue(4));
n3->AddDevice(net3);
//Create a 10Base-T1S Channel and attach it two the netDevices
Ptr<TsnMultidropChannel> channel = CreateObject<TsnMultidropChannel>();
net0->Attach(channel);
net1->Attach(channel);
net2->Attach(channel);
net3->Attach(channel);
//Allocate a Mac address and create a FIFO (for the output port)
//for each netDevice.
net0->SetAddress(Mac48Address::Allocate());
net0->SetQueue(CreateObject<DropTailQueue<Packet>>());
net1->SetAddress(Mac48Address::Allocate());
net1->SetQueue(CreateObject<DropTailQueue<Packet>>());
net2->SetAddress(Mac48Address::Allocate());
net2->SetQueue(CreateObject<DropTailQueue<Packet>>());
net3->SetAddress(Mac48Address::Allocate());
net3->SetQueue(CreateObject<DropTailQueue<Packet>>());
//Application description
Ptr<EthernetGenerator> app0 = CreateObject<EthernetGenerator>();
app0->Setup(net0);
app0->SetAttribute("BurstSize", UintegerValue(10));
app0->SetAttribute("PayloadSize", UintegerValue(1400));
app0->SetAttribute("Period", TimeValue(Seconds(5)));
app0->SetAttribute("VlanID", UintegerValue(1));
app0->SetStartTime(Seconds(0));
app0->SetStopTime(Seconds(10));
n0->AddApplication(app0);
//Callback to trace the message being send and received
net0->TraceConnectWithoutContext("MacTx",
MakeCallback(&TsnMultiDropBasicTestCase1Flow::SendTx, this));
net1->TraceConnectWithoutContext("MacRx",
MakeCallback(&TsnMultiDropBasicTestCase1Flow::ReceiveRx, this));
//Execute the simulation
Simulator::Stop(Seconds(12));
Simulator::Run();
Simulator::Destroy();
NS_TEST_ASSERT_MSG_EQ(m_sent, 2 * 10 * (1400 + 22), "10 Packets have been sent two times");
NS_TEST_ASSERT_MSG_EQ(m_sent, m_received, "All Packets sent have been received");
}
/**
* \ingroup tsn-multidrop-tests
* Check if message crossed an tsn multidrop channel from multiple
* sources.
*/
class TsnMultiDropBasicTestCase3Flows : public TestCase
{
public:
TsnMultiDropBasicTestCase3Flows();
virtual ~TsnMultiDropBasicTestCase3Flows();
private:
void DoRun() override;
void SendTx(Ptr<const Packet> p);
void ReceiveRx(Ptr<const Packet> p);
uint64_t m_sent{0}; //!< number of bytes sent
uint64_t m_received{0}; //!< number of bytes received
};
// Add some help text to this case to describe what it is intended to test
TsnMultiDropBasicTestCase3Flows::TsnMultiDropBasicTestCase3Flows()
: TestCase("Check if message crossed an tsn multidrop channel from"
" multiple sources")
{
}
// This destructor does nothing but we include it as a reminder that
// the test case should clean up after itself
TsnMultiDropBasicTestCase3Flows::~TsnMultiDropBasicTestCase3Flows()
{
}
void
TsnMultiDropBasicTestCase3Flows::SendTx(Ptr<const Packet> p)
{
m_sent += p->GetSize();
}
void
TsnMultiDropBasicTestCase3Flows::ReceiveRx(Ptr<const Packet> p)
{
m_received += p->GetSize();
}
//
// This method is the pure virtual method from class TestCase that every
// TestCase must implement
//
void
TsnMultiDropBasicTestCase3Flows::DoRun()
{
//Create four nodes
Ptr<TsnNode> n0 = CreateObject<TsnNode>();
Ptr<TsnNode> n1 = CreateObject<TsnNode>();
Ptr<TsnNode> n2 = CreateObject<TsnNode>();
Ptr<TsnNode> n3 = CreateObject<TsnNode>();
//Create and add a netDevice to each node
Ptr<TsnMultidropNetDevice> net0 = CreateObject<TsnMultidropNetDevice>();
net0->SetAttribute("PLCALocalNodeId", UintegerValue(0));
net0->SetAttribute("PLCANodeCount", UintegerValue(4));
n0->AddDevice(net0);
Ptr<TsnMultidropNetDevice> net1 = CreateObject<TsnMultidropNetDevice>();
net1->SetAttribute("PLCALocalNodeId", UintegerValue(1));
net1->SetAttribute("PLCANodeCount", UintegerValue(4));
n1->AddDevice(net1);
Ptr<TsnMultidropNetDevice> net2 = CreateObject<TsnMultidropNetDevice>();
net2->SetAttribute("PLCALocalNodeId", UintegerValue(2));
net2->SetAttribute("PLCANodeCount", UintegerValue(4));
n2->AddDevice(net2);
Ptr<TsnMultidropNetDevice> net3 = CreateObject<TsnMultidropNetDevice>();
net3->SetAttribute("PLCALocalNodeId", UintegerValue(3));
net3->SetAttribute("PLCANodeCount", UintegerValue(4));
n3->AddDevice(net3);
//Create a 10Base-T1S Channel and attach it two the netDevices
Ptr<TsnMultidropChannel> channel = CreateObject<TsnMultidropChannel>();
net0->Attach(channel);
net1->Attach(channel);
net2->Attach(channel);
net3->Attach(channel);
//Allocate a Mac address and create a FIFO (for the output port)
//for each netDevice.
net0->SetAddress(Mac48Address::Allocate());
net0->SetQueue(CreateObject<DropTailQueue<Packet>>());
net0->SetQueue(CreateObject<DropTailQueue<Packet>>());
net1->SetAddress(Mac48Address::Allocate());
net1->SetQueue(CreateObject<DropTailQueue<Packet>>());
net1->SetQueue(CreateObject<DropTailQueue<Packet>>());
net2->SetAddress(Mac48Address::Allocate());
net2->SetQueue(CreateObject<DropTailQueue<Packet>>());
net2->SetQueue(CreateObject<DropTailQueue<Packet>>());
net3->SetAddress(Mac48Address::Allocate());
net3->SetQueue(CreateObject<DropTailQueue<Packet>>());
net3->SetQueue(CreateObject<DropTailQueue<Packet>>());
//Application description
Ptr<EthernetGenerator> app0 = CreateObject<EthernetGenerator>();
app0->Setup(net0);
app0->SetAttribute("BurstSize", UintegerValue(10));
app0->SetAttribute("PayloadSize", UintegerValue(1400));
app0->SetAttribute("Period", TimeValue(Seconds(5)));
app0->SetAttribute("VlanID", UintegerValue(1));
app0->SetStartTime(Seconds(0));
app0->SetStopTime(Seconds(10));
n0->AddApplication(app0);
Ptr<EthernetGenerator> app1 = CreateObject<EthernetGenerator>();
app1->Setup(net1);
app1->SetAttribute("BurstSize", UintegerValue(1));
app1->SetAttribute("PayloadSize", UintegerValue(100));
app1->SetAttribute("Period", TimeValue(Seconds(5)));
app1->SetAttribute("VlanID", UintegerValue(1));
app1->SetAttribute("PCP", UintegerValue(1));
app1->SetStartTime(Seconds(0));
app1->SetStopTime(Seconds(10));
n1->AddApplication(app1);
Ptr<EthernetGenerator> app2 = CreateObject<EthernetGenerator>();
app2->Setup(net2);
app2->SetAttribute("BurstSize", UintegerValue(2));
app2->SetAttribute("PayloadSize", UintegerValue(500));
app2->SetAttribute("Period", TimeValue(Seconds(5)));
app2->SetAttribute("VlanID", UintegerValue(1));
app2->SetAttribute("PCP", UintegerValue(1));
app2->SetStartTime(Seconds(6));
app2->SetStopTime(Seconds(7));
n3->AddApplication(app2);
//Callback to trace the message being send and received
net0->TraceConnectWithoutContext("MacTx",
MakeCallback(&TsnMultiDropBasicTestCase3Flows::SendTx, this));
net1->TraceConnectWithoutContext("MacRx",
MakeCallback(&TsnMultiDropBasicTestCase3Flows::ReceiveRx, this));
net2->TraceConnectWithoutContext("MacRx",
MakeCallback(&TsnMultiDropBasicTestCase3Flows::ReceiveRx, this));
//Execute the simulation
Simulator::Stop(Seconds(12));
Simulator::Run();
Simulator::Destroy();
NS_TEST_ASSERT_MSG_EQ(m_sent, 2 * 10 * (1400 + 22), "10 Packets have been sent two times by net0");
NS_TEST_ASSERT_MSG_EQ(m_received, 2*2*10*(1400 + 22) + 2*1*(100+22) + 2*1*(500+22), "All Packets sent have been received");
}
/**
* \ingroup tsn-multidrop-tests
* Check if message crossed an tsn multidrop channel with the expected latency
*/
class TsnMultiDropLatencyTestCase1Flow : public TestCase
{
public:
TsnMultiDropLatencyTestCase1Flow(bool isLocalNodeId0, Time startTime, Time expectedLatency);
virtual ~TsnMultiDropLatencyTestCase1Flow();
private:
void DoRun() override;
void LatencyCallback(Ptr<const Packet> p);
bool m_is_local_node_id_0;
Time m_expected_latency;
Time m_latency;
Time m_start_time;
};
// Add some help text to this case to describe what it is intended to test
TsnMultiDropLatencyTestCase1Flow::TsnMultiDropLatencyTestCase1Flow(bool isLocalNodeId0, Time startTime, Time expectedLatency)
: TestCase("Check if message crossed an tsn multidrop channel with the expected latency")
{
m_is_local_node_id_0 = isLocalNodeId0;
m_expected_latency = expectedLatency;
m_start_time = startTime;
}
// This destructor does nothing but we include it as a reminder that
// the test case should clean up after itself
TsnMultiDropLatencyTestCase1Flow::~TsnMultiDropLatencyTestCase1Flow()
{
}
void
TsnMultiDropLatencyTestCase1Flow::LatencyCallback(Ptr<const Packet> p)
{
TimestampTag tag;
if (!p->FindFirstMatchingByteTag(tag))
{
return;
}
Ptr<Packet> originalPacket = p->Copy();
EthernetHeader2 ethHeader;
originalPacket->RemoveHeader(ethHeader);
if (ethHeader.GetVid()!=1)
{
return;
}
Time arrival = Simulator::Now();
m_latency = arrival - tag.GetTimestamp();
}
//
// This method is the pure virtual method from class TestCase that every
// TestCase must implement
//
void
TsnMultiDropLatencyTestCase1Flow::DoRun()
{
//Create four nodes
Ptr<TsnNode> n0 = CreateObject<TsnNode>();
Ptr<TsnNode> n1 = CreateObject<TsnNode>();
Ptr<TsnNode> n2 = CreateObject<TsnNode>();
Ptr<TsnNode> n3 = CreateObject<TsnNode>();
//Create and add a netDevice to each node
Ptr<TsnMultidropNetDevice> net0 = CreateObject<TsnMultidropNetDevice>();
if (m_is_local_node_id_0){
net0->SetAttribute("PLCALocalNodeId", UintegerValue(0));
}
else
{
net0->SetAttribute("PLCALocalNodeId", UintegerValue(2));
}
net0->SetAttribute("PLCANodeCount", UintegerValue(4));
n0->AddDevice(net0);
Ptr<TsnMultidropNetDevice> net1 = CreateObject<TsnMultidropNetDevice>();
net1->SetAttribute("PLCALocalNodeId", UintegerValue(1));
net1->SetAttribute("PLCANodeCount", UintegerValue(4));
n1->AddDevice(net1);
Ptr<TsnMultidropNetDevice> net2 = CreateObject<TsnMultidropNetDevice>();
if (m_is_local_node_id_0){
net2->SetAttribute("PLCALocalNodeId", UintegerValue(2));
}
else
{
net2->SetAttribute("PLCALocalNodeId", UintegerValue(0));
}
net2->SetAttribute("PLCANodeCount", UintegerValue(4));
n2->AddDevice(net2);
Ptr<TsnMultidropNetDevice> net3 = CreateObject<TsnMultidropNetDevice>();
net3->SetAttribute("PLCALocalNodeId", UintegerValue(3));
net3->SetAttribute("PLCANodeCount", UintegerValue(4));
n3->AddDevice(net3);
//Create a 10Base-T1S Channel and attach it two the netDevices
Ptr<TsnMultidropChannel> channel = CreateObject<TsnMultidropChannel>();
net0->Attach(channel);
net1->Attach(channel);
net2->Attach(channel);
net3->Attach(channel);
//Allocate a Mac address and create a FIFO (for the output port)
//for each netDevice.
net0->SetAddress(Mac48Address::Allocate());
net0->SetQueue(CreateObject<DropTailQueue<Packet>>());
net1->SetAddress(Mac48Address::Allocate());
net1->SetQueue(CreateObject<DropTailQueue<Packet>>());
net2->SetAddress(Mac48Address::Allocate());
net2->SetQueue(CreateObject<DropTailQueue<Packet>>());
net3->SetAddress(Mac48Address::Allocate());
net3->SetQueue(CreateObject<DropTailQueue<Packet>>());
//Application description
Ptr<EthernetGenerator> app0 = CreateObject<EthernetGenerator>();
app0->Setup(net0);
app0->SetAttribute("BurstSize", UintegerValue(1));
app0->SetAttribute("PayloadSize", UintegerValue(1400));
app0->SetAttribute("Period", TimeValue(Seconds(5)));
app0->SetAttribute("VlanID", UintegerValue(1));
app0->SetStartTime(m_start_time);
app0->SetStopTime(Seconds(1));
n0->AddApplication(app0);
//Callback to trace the message being send and received
net1->TraceConnectWithoutContext("Latency",
MakeCallback(&TsnMultiDropLatencyTestCase1Flow::LatencyCallback, this));
//Execute the simulation
Simulator::Stop(Seconds(1));
Simulator::Run();
Simulator::Destroy();
NS_TEST_ASSERT_MSG_EQ(m_latency, m_expected_latency, "The simulated latency is equal to the expected latency");
}
/**
* \ingroup tsn-multidrop-tests
* Check if message crossed an tsn multidrop channel with the expected latency
* when the channel is shared with two other flows
*/
class TsnMultiDropLatencyTestCase3Flows : public TestCase
{
public:
TsnMultiDropLatencyTestCase3Flows(uint8_t burstSize, uint8_t priority, Time startTime, Time expectedLatency);
virtual ~TsnMultiDropLatencyTestCase3Flows();
private:
void DoRun() override;
void LatencyCallback(Ptr<const Packet> p);
uint8_t m_burst_size;
uint8_t m_priority;
Time m_expected_latency;
Time m_latency;
Time m_start_time;
};
// Add some help text to this case to describe what it is intended to test
TsnMultiDropLatencyTestCase3Flows::TsnMultiDropLatencyTestCase3Flows(uint8_t burstSize, uint8_t priority, Time startTime, Time expectedLatency)
: TestCase("Check if message crossed an tsn multidrop channel with the "
"expected latency when the channel is shared with two other flows")
{
m_burst_size = burstSize;
m_priority = priority;
m_expected_latency = expectedLatency;
m_start_time = startTime;
}
// This destructor does nothing but we include it as a reminder that
// the test case should clean up after itself
TsnMultiDropLatencyTestCase3Flows::~TsnMultiDropLatencyTestCase3Flows()
{
}
void
TsnMultiDropLatencyTestCase3Flows::LatencyCallback(Ptr<const Packet> p)
{
TimestampTag tag;
if (!p->FindFirstMatchingByteTag(tag))
{
return;
}
Ptr<Packet> originalPacket = p->Copy();
EthernetHeader2 ethHeader;
originalPacket->RemoveHeader(ethHeader);
if (ethHeader.GetVid()!=1)
{
return;
}
Time arrival = Simulator::Now();
m_latency = arrival - tag.GetTimestamp();
}
//
// This method is the pure virtual method from class TestCase that every
// TestCase must implement
//
void
TsnMultiDropLatencyTestCase3Flows::DoRun()
{
//Create four nodes
Ptr<TsnNode> n0 = CreateObject<TsnNode>();
Ptr<TsnNode> n1 = CreateObject<TsnNode>();
Ptr<TsnNode> n2 = CreateObject<TsnNode>();
Ptr<TsnNode> n3 = CreateObject<TsnNode>();
//Create and add a netDevice to each node
Ptr<TsnMultidropNetDevice> net0 = CreateObject<TsnMultidropNetDevice>();
net0->SetAttribute("PLCALocalNodeId", UintegerValue(0));
net0->SetAttribute("PLCANodeCount", UintegerValue(4));
n0->AddDevice(net0);
Ptr<TsnMultidropNetDevice> net1 = CreateObject<TsnMultidropNetDevice>();
net1->SetAttribute("PLCALocalNodeId", UintegerValue(1));
net1->SetAttribute("PLCANodeCount", UintegerValue(4));
n1->AddDevice(net1);
Ptr<TsnMultidropNetDevice> net2 = CreateObject<TsnMultidropNetDevice>();
net2->SetAttribute("PLCALocalNodeId", UintegerValue(2));
net2->SetAttribute("PLCANodeCount", UintegerValue(4));
n2->AddDevice(net2);
Ptr<TsnMultidropNetDevice> net3 = CreateObject<TsnMultidropNetDevice>();
net3->SetAttribute("PLCALocalNodeId", UintegerValue(3));
net3->SetAttribute("PLCANodeCount", UintegerValue(4));
n3->AddDevice(net3);
//Create a 10Base-T1S Channel and attach it two the netDevices
Ptr<TsnMultidropChannel> channel = CreateObject<TsnMultidropChannel>();
net0->Attach(channel);
net1->Attach(channel);
net2->Attach(channel);
net3->Attach(channel);
//Allocate a Mac address and create a FIFO (for the output port)
//for each netDevice.
net0->SetAddress(Mac48Address::Allocate());
net0->SetQueue(CreateObject<DropTailQueue<Packet>>());
net0->SetQueue(CreateObject<DropTailQueue<Packet>>());
net1->SetAddress(Mac48Address::Allocate());
net1->SetQueue(CreateObject<DropTailQueue<Packet>>());
net1->SetQueue(CreateObject<DropTailQueue<Packet>>());
net2->SetAddress(Mac48Address::Allocate());
net2->SetQueue(CreateObject<DropTailQueue<Packet>>());
net2->SetQueue(CreateObject<DropTailQueue<Packet>>());
net3->SetAddress(Mac48Address::Allocate());
net3->SetQueue(CreateObject<DropTailQueue<Packet>>());
net3->SetQueue(CreateObject<DropTailQueue<Packet>>());
//Application description
Ptr<EthernetGenerator> app0 = CreateObject<EthernetGenerator>();
app0->Setup(net0);
app0->SetAttribute("BurstSize", UintegerValue(m_burst_size));
app0->SetAttribute("PayloadSize", UintegerValue(1400));
app0->SetAttribute("Period", TimeValue(Seconds(5)));
app0->SetAttribute("VlanID", UintegerValue(1));
app0->SetAttribute("PCP", UintegerValue(m_priority));
app0->SetStartTime(m_start_time);
app0->SetStopTime(Seconds(1));
n0->AddApplication(app0);
Ptr<EthernetGenerator> app1 = CreateObject<EthernetGenerator>();
app1->Setup(net0);
app1->SetAttribute("BurstSize", UintegerValue(2));
app1->SetAttribute("PayloadSize", UintegerValue(1000));
app1->SetAttribute("Period", TimeValue(Seconds(5)));
app1->SetAttribute("VlanID", UintegerValue(2));
app1->SetAttribute("PCP", UintegerValue(0));
app1->SetStartTime(NanoSeconds(10));
app1->SetStopTime(Seconds(1));
n0->AddApplication(app1);
Ptr<EthernetGenerator> app2 = CreateObject<EthernetGenerator>();
app2->Setup(net2);
app2->SetAttribute("BurstSize", UintegerValue(1));
app2->SetAttribute("PayloadSize", UintegerValue(100));
app2->SetAttribute("Period", TimeValue(Seconds(5)));
app2->SetAttribute("VlanID", UintegerValue(3));
app2->SetAttribute("PCP", UintegerValue(1));
app2->SetStartTime(NanoSeconds(0));
app2->SetStopTime(Seconds(1));
n2->AddApplication(app2);
//Callback to trace the message being send and received
net1->TraceConnectWithoutContext("Latency",
MakeCallback(&TsnMultiDropLatencyTestCase3Flows::LatencyCallback, this));
//Execute the simulation
Simulator::Stop(Seconds(1));
Simulator::Run();
Simulator::Destroy();
NS_TEST_ASSERT_MSG_EQ(m_latency, m_expected_latency, "The simulated latency is equal to the expected latency");
}
/**
* \ingroup tsn-multidrop-tests
* Check if message can crossed from a switched network to a 10Base-T1S bus
* and from a 10Base-T1S bus to a switched network
*/
class TsnMultiDropSwitchedBasicTestCase : public TestCase
{
public:
TsnMultiDropSwitchedBasicTestCase();
virtual ~TsnMultiDropSwitchedBasicTestCase();
private:
void DoRun() override;
void ReceiveRxFrom10BaseT1SBus(Ptr<const Packet> p);
void ReceiveRxFromSwitchedNetwork(Ptr<const Packet> p);
uint64_t m_received_from_switched_network{0}; //!< number of bytes
uint64_t m_received_from_10BaseT1S_bus{0}; //!< number of bytes
};
// Add some help text to this case to describe what it is intended to test
TsnMultiDropSwitchedBasicTestCase::TsnMultiDropSwitchedBasicTestCase()
: TestCase("Check if message can crossed from a switched network to a 10Base-T1S"
"bus and from a 10Base-T1S bus to a switched network")
{
}
// This destructor does nothing but we include it as a reminder that
// the test case should clean up after itself
TsnMultiDropSwitchedBasicTestCase::~TsnMultiDropSwitchedBasicTestCase()
{
}
void
TsnMultiDropSwitchedBasicTestCase::ReceiveRxFrom10BaseT1SBus(Ptr<const Packet> p)
{
m_received_from_10BaseT1S_bus += p->GetSize();
}
void
TsnMultiDropSwitchedBasicTestCase::ReceiveRxFromSwitchedNetwork(Ptr<const Packet> p)
{
m_received_from_switched_network += p->GetSize();
}
//
// This method is the pure virtual method from class TestCase that every
// TestCase must implement
//
void
TsnMultiDropSwitchedBasicTestCase::DoRun()
{
//Create four nodes
Ptr<TsnNode> n0 = CreateObject<TsnNode>();
Ptr<TsnNode> n1 = CreateObject<TsnNode>();
Ptr<TsnNode> n2 = CreateObject<TsnNode>();
Ptr<TsnNode> n3 = CreateObject<TsnNode>();
Ptr<TsnNode> n4 = CreateObject<TsnNode>();
//Create and add a netDevice to each node
Ptr<TsnNetDevice> net0 = CreateObject<TsnNetDevice>();
n0->AddDevice(net0);
Ptr<TsnNetDevice> swnet0 = CreateObject<TsnNetDevice>();
n4->AddDevice(swnet0);
Ptr<TsnMultidropNetDevice> swnet1 = CreateObject<TsnMultidropNetDevice>();
swnet1->SetAttribute("PLCALocalNodeId", UintegerValue(0));
swnet1->SetAttribute("PLCANodeCount", UintegerValue(4));
n4->AddDevice(swnet1);
Ptr<TsnMultidropNetDevice> net1 = CreateObject<TsnMultidropNetDevice>();
net1->SetAttribute("PLCALocalNodeId", UintegerValue(1));
net1->SetAttribute("PLCANodeCount", UintegerValue(4));
n1->AddDevice(net1);
Ptr<TsnMultidropNetDevice> net2 = CreateObject<TsnMultidropNetDevice>();
net2->SetAttribute("PLCALocalNodeId", UintegerValue(2));
net2->SetAttribute("PLCANodeCount", UintegerValue(4));
n2->AddDevice(net2);
Ptr<TsnMultidropNetDevice> net3 = CreateObject<TsnMultidropNetDevice>();
net3->SetAttribute("PLCALocalNodeId", UintegerValue(3));
net3->SetAttribute("PLCANodeCount", UintegerValue(4));
n3->AddDevice(net3);
//Create a full-duplex channel
Ptr<EthernetChannel> channel0 = CreateObject<EthernetChannel>();
net0->Attach(channel0);
swnet0->Attach(channel0);
//Create a 10Base-T1S Channel and attach it two the netDevices
Ptr<TsnMultidropChannel> channel1 = CreateObject<TsnMultidropChannel>();
swnet1->Attach(channel1);
net1->Attach(channel1);
net2->Attach(channel1);
net3->Attach(channel1);
//Create and add a switch net device to the switch node
Ptr<SwitchNetDevice> sw = CreateObject<SwitchNetDevice>();
sw->SetAttribute("MinForwardingLatency", TimeValue(MicroSeconds(10)));
sw->SetAttribute("MaxForwardingLatency", TimeValue(MicroSeconds(10)));
n4->AddDevice(sw);
sw->AddSwitchPort(swnet0);
sw->AddSwitchPort(swnet1);
//Allocate a Mac address and create a FIFO (for the output port)
//for each netDevice.
net0->SetAddress(Mac48Address::Allocate());
net0->SetQueue(CreateObject<DropTailQueue<Packet>>());
net0->SetQueue(CreateObject<DropTailQueue<Packet>>());
net1->SetAddress(Mac48Address::Allocate());
net1->SetQueue(CreateObject<DropTailQueue<Packet>>());
net1->SetQueue(CreateObject<DropTailQueue<Packet>>());
net2->SetAddress(Mac48Address::Allocate());
net2->SetQueue(CreateObject<DropTailQueue<Packet>>());
net2->SetQueue(CreateObject<DropTailQueue<Packet>>());
net3->SetAddress(Mac48Address::Allocate());
net3->SetQueue(CreateObject<DropTailQueue<Packet>>());
net3->SetQueue(CreateObject<DropTailQueue<Packet>>());
swnet0->SetAddress(Mac48Address::Allocate());
swnet0->SetQueue(CreateObject<DropTailQueue<Packet>>());
swnet0->SetQueue(CreateObject<DropTailQueue<Packet>>());
swnet1->SetAddress(Mac48Address::Allocate());
swnet1->SetQueue(CreateObject<DropTailQueue<Packet>>());
swnet1->SetQueue(CreateObject<DropTailQueue<Packet>>());
//Add forwarding table
sw->AddForwardingTableEntry(Mac48Address::ConvertFrom(net1->GetAddress()), 10, {swnet1});
sw->AddForwardingTableEntry(Mac48Address::ConvertFrom(net0->GetAddress()), 20, {swnet0});
//Application description
//From switched network to 10Base-T1S
Ptr<EthernetGenerator> app0 = CreateObject<EthernetGenerator>();
app0->Setup(net0);
app0->SetAttribute("Address", AddressValue(net1->GetAddress()));
app0->SetAttribute("BurstSize", UintegerValue(5));
app0->SetAttribute("PayloadSize", UintegerValue(1400));
app0->SetAttribute("Period", TimeValue(Seconds(5)));
app0->SetAttribute("VlanID", UintegerValue(10));
app0->SetAttribute("PCP", UintegerValue(0));
n0->AddApplication(app0);
app0->SetStartTime(Seconds(0));
app0->SetStopTime(Seconds(10));
//From 10Base-T1S to switched network
Ptr<EthernetGenerator> app1 = CreateObject<EthernetGenerator>();
app1->Setup(net1);
app1->SetAttribute("Address", AddressValue(net0->GetAddress()));
app1->SetAttribute("BurstSize", UintegerValue(2));
app1->SetAttribute("PayloadSize", UintegerValue(100));
app1->SetAttribute("Period", TimeValue(Seconds(5)));
app1->SetAttribute("VlanID", UintegerValue(20));
app1->SetAttribute("PCP", UintegerValue(1));
n1->AddApplication(app1);
app1->SetStartTime(Seconds(0));
app1->SetStopTime(Seconds(10));
//Callback to trace the message being send and received
net0->TraceConnectWithoutContext("MacRx",
MakeCallback(&TsnMultiDropSwitchedBasicTestCase::ReceiveRxFrom10BaseT1SBus, this));
net1->TraceConnectWithoutContext("MacRx",
MakeCallback(&TsnMultiDropSwitchedBasicTestCase::ReceiveRxFromSwitchedNetwork, this));
//Execute the simulation
Simulator::Stop(Seconds(12));
Simulator::Run();
Simulator::Destroy();
NS_TEST_ASSERT_MSG_EQ(m_received_from_10BaseT1S_bus, 2 * 2 * (100 + 22), "4 Packets have been received two times by net0");
NS_TEST_ASSERT_MSG_EQ(m_received_from_switched_network, 2 * 5 * (1400 + 22), "10 Packets have been received two times by net1");
}
// The TestSuite class names the TestSuite, identifies what type of TestSuite,
// and enables the TestCases to be run. Typically, only the constructor for
// this class must be defined
/**
* \ingroup tsn-multidrop-tests
* TestSuite for module tsn with a focus on multidrop
*/
class TsnMultidropTestSuite : public TestSuite
{
public:
TsnMultidropTestSuite();
};
TsnMultidropTestSuite::TsnMultidropTestSuite()
: TestSuite("tsn-multidrop", UNIT)
{
LogComponentEnable("TsnMultidropTestSuite", LOG_LEVEL_ALL);
//Multidrop channel
AddTestCase(new TsnMultiDropBasicTestCase1Flow, TestCase::QUICK);
AddTestCase(new TsnMultiDropBasicTestCase3Flows, TestCase::QUICK);
// Latency with one flow on the channel
//Wait for 10Base-T1S init when producer is local nodeId = 0
AddTestCase(new TsnMultiDropLatencyTestCase1Flow(true, Time(NanoSeconds(0)), Time(NanoSeconds(((1400 + 22 + 8) + 1 * 20 + 4 * 32)*800 + 25))), TestCase::QUICK);
//Frame ready just before the opportunity when producer is local nodeId = 0
AddTestCase(new TsnMultiDropLatencyTestCase1Flow(true, Time(NanoSeconds((20 + 4 *32) * 800 - 1)), Time(NanoSeconds((1400 + 22 + 8)*800 + 1 + 25))), TestCase::QUICK);
//Wait for 10Base-T1S init when producer is local nodeId = 2
AddTestCase(new TsnMultiDropLatencyTestCase1Flow(false, Time(NanoSeconds(0)), Time(NanoSeconds(((1400 + 22 + 8) + 1 * 20 + (4 + 2) * 32)*800 + 25))), TestCase::QUICK);
//Latency with multiple flows on the channel
AddTestCase(new TsnMultiDropLatencyTestCase3Flows(1, 0, Time(NanoSeconds(0)), Time(NanoSeconds(((1400 + 22 + 8) + 1 * 20 + 4 * 32)*800 + 25))), TestCase::QUICK);
AddTestCase(new TsnMultiDropLatencyTestCase3Flows(2, 0, Time(NanoSeconds(0)), Time(NanoSeconds(((1400 + 22 + 8) + 2 * 20 + (4+2) * 32 + (1400 + 22 + 8 + 12 + 100 + 22 + 8 + 12))*800 + 25 * 3))), TestCase::QUICK);
AddTestCase(new TsnMultiDropLatencyTestCase3Flows(2, 0, Time(NanoSeconds(11)), Time(NanoSeconds(((1400 + 22 + 8) + 4 * 20 + (4+ 2 + 3 + 3) * 32 + (1042 * 2 + 1442 + 142))*800 + 25 * 3 - 11))), TestCase::QUICK);
AddTestCase(new TsnMultiDropLatencyTestCase3Flows(2, 1, Time(NanoSeconds(11)), Time(NanoSeconds(((1400 + 22 + 8) + 2 * 20 + (4+ 2) * 32 + (1442 + 142))*800 + 25 * 3 - 11))), TestCase::QUICK);
//Switched network connected to a multidrop channel
AddTestCase(new TsnMultiDropSwitchedBasicTestCase, TestCase::QUICK);
}
// Do not forget to allocate an instance of this TestSuite
/**
* \ingroup tsn-tests
* Static variable for test initialization
*/
static TsnMultidropTestSuite m_tsnMultidropTestSuite;
Reference in New Issue View Git Blame Copy Permalink