test_cyclicControllerConformance.cpp

Go to the documentation of this file.

 
 
#include <gtest/gtest.h>
 
#include <array>
#include <cstdint>
 
#include "profinet/cyclic.h"
#include "profinet/rt.h"
 
namespace
{
constexpr std::array<std::uint8_t, 6> kControllerMac{0x00, 0x11, 0x22, 0x33, 0x44, 0x55};
constexpr std::array<std::uint8_t, 6> kDeviceMac{0x02, 0x00, 0x00, 0x00, 0x00, 0x01};
constexpr std::array<std::uint8_t, 4> kVlanTag{0x81, 0x00, 0xC0, 0x00};
constexpr std::uint16_t kProfinetEtherType = 0x8892;
} // namespace
 
namespace profinet::cyclic
{
 
class CyclicControllerConformanceTest : public ::testing::Test
{
 protected:
  void SetUp() override
  {
    controller = MakeController();
  }
 
  void InvokeTransition(profinet::cyclic::CyclicState state)
  {
    controller->Transition(state);
  }
 
  void InvokeTxCycle()
  {
    controller->TxCycle();
  }
 
  void InvokeProcessInputFrame(const Bytes& data)
  {
    controller->ProcessInputFrame(data);
  }
 
  std::unique_ptr<CyclicController> controller;
 
  static profinet::rt::IOCRConfig MakeInputIocr()
  {
    profinet::rt::IOCRConfig config;
 
    config.typeIOCR = profinet::rt::IOCR_TYPE_INPUT;
    config.referenceIOCR = 1;
    config.frameId = 0xC001;
    config.sendClockFactor = 1;
    config.reductionRatio = 1;
    config.watchdogFactor = 3;
    config.dataLength = 40;
 
    config.objects.push_back(profinet::rt::IODataObject{
        .slot = 1,
        .subslot = 1,
        .frameOffset = 0,
        .dataLength = 4,
        .offsetIOPS = 4});
 
    return config;
  }
 
  static profinet::rt::IOCRConfig MakeOutputIocr()
  {
    profinet::rt::IOCRConfig config;
 
    config.typeIOCR = profinet::rt::IOCR_TYPE_OUTPUT;
    config.frameId = 0xC000;
    // config.referenceIOCR = 2;
    config.sendClockFactor = 32;
    config.reductionRatio = 32;
    config.watchdogFactor = 3;
    config.dataLength = 40;
 
    config.objects.push_back(profinet::rt::IODataObject{
        .slot = 1,
        .subslot = 1,
        .frameOffset = 0,
        .dataLength = 4,
        .offsetIOPS = 4,
        .offsetIOCS = 5,
    });
 
    return config;
  }
 
  static std::unique_ptr<profinet::cyclic::CyclicController> MakeController()
  {
    asio::io_context ioContext;
    return std::make_unique<CyclicController>(
        ioContext,
        "eth0",
        kControllerMac,
        kDeviceMac,
        MakeInputIocr(),
        MakeOutputIocr());
  }
 
  static profinet::Bytes BuildInputFrame(bool vlan = false, std::uint8_t transferStatus = 0, profinet::Bytes payload = {})
  {
    if (payload.empty())
    {
      payload = {0xAA, 0xBB, 0xCC, 0xDD, 0x80};
 
      payload.resize(40U, 0x00);
    }
 
    profinet::rt::RTFrame rt;
 
    rt.frameId = 0xC001;
    rt.cycleCounter = 1;
    rt.dataStatus = profinet::rt::RTFrame::DATA_VALID | profinet::rt::RTFrame::DATA_RUN;
    rt.transferStatus = transferStatus;
    rt.payload = std::move(payload);
 
    profinet::Bytes frame;
 
    frame.insert(frame.end(), kControllerMac.begin(), kControllerMac.end());
 
    frame.insert(frame.end(), kDeviceMac.begin(), kDeviceMac.end());
 
    if (vlan)
    {
      frame.insert(frame.end(), kVlanTag.begin(), kVlanTag.end());
    }
 
    frame.push_back(static_cast<std::uint8_t>((kProfinetEtherType >> 8U) & 0xFFU));
 
    frame.push_back(static_cast<std::uint8_t>(kProfinetEtherType & 0xFFU));
 
    const profinet::Bytes rtBytes = rt.ToBytes();
 
    frame.insert(frame.end(), rtBytes.begin(), rtBytes.end());
 
    return frame;
  }
};
 
TEST_F(CyclicControllerConformanceTest, UntaggedInputFrameIsAccepted)
{
  InvokeTransition(profinet::cyclic::CyclicState::Running);
  InvokeProcessInputFrame(BuildInputFrame());
 
  EXPECT_EQ(controller->StatsSnapshot().framesReceived, 1U);
 
  const auto data = controller->GetInputData(1, 1);
 
  ASSERT_TRUE(data.has_value());
 
  EXPECT_EQ(*data, profinet::Bytes({0xAA, 0xBB, 0xCC, 0xDD}));
}
 
TEST_F(CyclicControllerConformanceTest, VlanTaggedInputFrameIsAccepted)
{
  InvokeTransition(profinet::cyclic::CyclicState::Running);
  InvokeProcessInputFrame(BuildInputFrame(true));
 
  EXPECT_EQ(controller->StatsSnapshot().framesReceived, 1U);
 
  const auto data = controller->GetInputData(1, 1);
 
  ASSERT_TRUE(data.has_value());
 
  EXPECT_EQ(*data, profinet::Bytes({0xAA, 0xBB, 0xCC, 0xDD}));
}
 
TEST_F(CyclicControllerConformanceTest, NonZeroTransferStatusIsRejected)
{
  InvokeTransition(profinet::cyclic::CyclicState::Running);
  InvokeProcessInputFrame(BuildInputFrame(false, 1));
 
  EXPECT_EQ(controller->StatsSnapshot().framesInvalid, 1U);
  EXPECT_FALSE(controller->GetInputData(1, 1).has_value());
}
 
TEST_F(CyclicControllerConformanceTest, TxContinuesWhileControllerIsInFault)
{
  InvokeTransition(profinet::cyclic::CyclicState::Fault);
  InvokeTxCycle();
 
  EXPECT_EQ(controller->StatsSnapshot().framesSent, 1U);
}
} // namespace profinet::cyclic