test_rtMore.cpp

Go to the documentation of this file.

 
 
#include <gtest/gtest.h>
 
#include <array>
#include <cstdint>
#include <string>
#include <vector>
 
#include "profinet/rpc.h"
#include "profinet/rt.h"
#include "profinet/util.h"
 
using namespace profinet;
using namespace profinet::rt;
 
namespace
{
IOCRConfig MakeConfig()
{
  IOCRConfig config;
  config.dataLength = 12;
  config.objects = {{.slot = 1,
                     .subslot = 1,
                     .frameOffset = 0,
                     .dataLength = 4,
                     .offsetIOPS = 4,
                     .offsetIOCS = 0},
                    {.slot = 2,
                     .subslot = 1,
                     .frameOffset = 6,
                     .dataLength = 2,
                     .offsetIOPS = 8,
                     .offsetIOCS = 10},
                    {.slot = 3,
                     .subslot = 1,
                     .frameOffset = 9,
                     .dataLength = 0,
                     .offsetIOCS = 11}};
  return config;
}
 
rpc::IOSlot MakeSlot(std::uint16_t slot,
                     std::uint16_t subslot,
                     std::uint16_t inputLength,
                     std::uint16_t outputLength)
{
  rpc::IOSlot s{};
  s.slot = slot;
  s.subslot = subslot;
  s.inputLength = inputLength;
  s.outputLength = outputLength;
  return s;
}
 
Bytes MakeEthernetFrame(const std::uint16_t etherType, const Bytes& rt)
{
  const MacAddress dst{0x02, 0, 0, 0, 0, 1};
  const MacAddress src{0x10, 0x11, 0x12, 0x13, 0x14, 0x15};
 
  Bytes out(dst.begin(), dst.end());
  out.insert(out.end(), src.begin(), src.end());
  wire::PutU16(out, etherType);
  out.insert(out.end(), rt.begin(), rt.end());
  return out;
}
 
} // namespace
 
namespace
{ 
class RtMoreTests : public ::testing::Test
{
 protected:
  static RTFrame MakeFrame()
  {
    RTFrame frame;
    frame.frameId = 0xC123;
    frame.cycleCounter = 0x4567;
    frame.dataStatus = 0;
    frame.transferStatus = 0xAA;
    frame.payload = {1, 2, 3};
    return frame;
  }
};
} // namespace
 
TEST_F(RtMoreTests, RTFrameStatusAccessorsCoverAllBits)
{
  RTFrame frame = MakeFrame();
 
  EXPECT_FALSE(frame.IsValid());
  EXPECT_FALSE(frame.IsRunning());
  EXPECT_FALSE(frame.IsOk());
  EXPECT_FALSE(frame.IsPrimary());
 
  frame.dataStatus = DATA_STATUS_VALID;
  EXPECT_TRUE(frame.IsValid());
  EXPECT_FALSE(frame.IsRunning());
  EXPECT_FALSE(frame.IsOk());
  EXPECT_FALSE(frame.IsPrimary());
 
  frame.dataStatus = DATA_STATUS_PROVIDER_RUN;
  EXPECT_FALSE(frame.IsValid());
  EXPECT_TRUE(frame.IsRunning());
 
  frame.dataStatus = DATA_STATUS_STATION_OK;
  EXPECT_FALSE(frame.IsValid());
  EXPECT_TRUE(frame.IsOk());
 
  frame.dataStatus = DATA_STATUS_STATE;
  EXPECT_TRUE(frame.IsPrimary());
}
 
TEST_F(RtMoreTests, RTFrameSerializationPreservesAllFields)
{
  const RTFrame frame = MakeFrame();
 
  const auto encoded = frame.ToBytes();
  const auto decoded = RTFrame::FromBytes(encoded);
 
  EXPECT_EQ(decoded.frameId, frame.frameId);
  EXPECT_EQ(decoded.cycleCounter, frame.cycleCounter);
  EXPECT_EQ(decoded.dataStatus, frame.dataStatus);
  EXPECT_EQ(decoded.transferStatus, frame.transferStatus);
  EXPECT_EQ(decoded.payload, frame.payload);
}
 
TEST_F(RtMoreTests, RTFrameFromBytesRejectsShortBuffers)
{
  constexpr std::size_t fixedHeaderSize = 6U;
 
  for (std::size_t length = 0; length < fixedHeaderSize; ++length)
  {
    EXPECT_THROW(RTFrame::FromBytes(Bytes(length, 0)), std::exception)
        << "length=" << length;
  }
}
 
TEST_F(RtMoreTests, RTFrameToStringIsNonEmpty)
{
  const auto text = MakeFrame().ToString();
 
  EXPECT_FALSE(text.empty());
}
 
TEST_F(RtMoreTests, ParseEthernetFrameRejectsShortFrames)
{
  for (std::size_t length = 0; length < 14U; ++length)
  {
    EXPECT_FALSE(ParseEthernetFrame(Bytes(length, 0)).has_value());
  }
}
 
TEST_F(RtMoreTests, ParseEthernetFrameAcceptsPriorityVlan)
{
  RTFrame frame = MakeFrame();
  const auto rt = frame.ToBytes();
 
  Bytes raw{
      0x02, 0, 0, 0, 0, 1, 0x10,
      0x11, 0x12, 0x13, 0x14, 0x15,
      0x81, 0x00, // 802.1Q VLAN TPID
      0xC0, 0x00, // PCP=6, DEI=0, VID=0
      0x88, 0x92  // PROFINET RT EtherType
  };
 
  raw.insert(raw.end(), rt.begin(), rt.end());
 
  const auto parsed = ParseEthernetFrame(raw);
 
  ASSERT_TRUE(parsed.has_value());
  EXPECT_EQ(parsed->frameId, frame.frameId);
  EXPECT_EQ(parsed->payload, frame.payload);
}
 
TEST_F(RtMoreTests, ParseEthernetFrameRejectsVlanNonProfinet)
{
  const auto rt = MakeFrame().ToBytes();
 
  Bytes raw{0x02, 0, 0, 0, 0, 1, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x81, 0x00, 0xC0, 0x00, 0x08, 0x00};
 
  raw.insert(raw.end(), rt.begin(), rt.end());
 
  EXPECT_FALSE(ParseEthernetFrame(raw).has_value());
}
 
TEST_F(RtMoreTests, CyclicDataBuilderSetIopsUpdatesDataObject)
{
  CyclicDataBuilder builder(MakeConfig());
 
  builder.SetIops(1, 1, 0x12);
  builder.Swap();
 
  const auto data = builder.Build();
 
  EXPECT_EQ(data[4], 0x12);
}
 
TEST_F(RtMoreTests, CyclicDataBuilderSetIocsUpdatesIocsOnlyObject)
{
  CyclicDataBuilder builder(MakeConfig());
 
  builder.SetIocs(3, 1, 0x34);
  builder.Swap();
 
  const auto data = builder.Build();
 
  EXPECT_EQ(data[11], 0x34);
}
 
TEST_F(RtMoreTests, CyclicDataBuilderSetIopsIgnoresIocsOnlyObject)
{
  CyclicDataBuilder builder(MakeConfig());
 
  builder.SetIops(3, 1, 0x55);
  builder.Swap();
 
  EXPECT_EQ(builder.Build()[11], 0U);
}
 
TEST_F(RtMoreTests, CyclicDataBuilderSetIocsUpdatesDataObject)
{
  CyclicDataBuilder builder(MakeConfig());
 
  builder.SetIocs(1, 1, 0x77);
  builder.Swap();
 
  EXPECT_EQ(builder.Build()[0], 0x77U);
}
 
TEST_F(RtMoreTests, CyclicDataBuilderSetAllIopsUpdatesAllDataObjects)
{
  CyclicDataBuilder builder(MakeConfig());
 
  builder.SetAllIops(0x66);
  builder.Swap();
 
  const auto data = builder.Build();
 
  EXPECT_EQ(data[4], 0x66);
  EXPECT_EQ(data[8], 0x66);
  EXPECT_EQ(data[11], 0U);
}
 
TEST_F(RtMoreTests, CyclicDataBuilderSetAllIocsUpdatesAllIocs)
{
  rt::IOCRConfig config = MakeConfig();
  config.dataLength = 32;
 
  config.objects = {
      rt::IODataObject{
          .slot = 1,
          .subslot = 1,
          .frameOffset = 0,
          .dataLength = 4,
          .offsetIOPS = 4,
          .offsetIOCS = 5},
      rt::IODataObject{
          .slot = 2,
          .subslot = 1,
          .frameOffset = 6,
          .dataLength = 4,
          .offsetIOPS = 12,
          .offsetIOCS = 13},
      rt::IODataObject{
          .slot = 3,
          .subslot = 1,
          .frameOffset = 16,
          .dataLength = 4,
          .offsetIOPS = 20,
          .offsetIOCS = 21}};
 
  CyclicDataBuilder builder(config);
 
  builder.SetAllIocs(0x88U);
  builder.Swap();
 
  const auto data = builder.Build();
 
  EXPECT_EQ(data.at(5), 0x88U);
  EXPECT_EQ(data.at(13), 0x88U);
  EXPECT_EQ(data.at(21), 0x88U);
}
 
TEST_F(RtMoreTests, CyclicDataBuilderClearResetsBuffers)
{
  rt::IOCRConfig config;
  config.dataLength = 32;
 
  config.objects = {
      rt::IODataObject{
          .slot = 1,
          .subslot = 1,
          .frameOffset = 0,
          .dataLength = 4,
          .offsetIOPS = 4,
          .offsetIOCS = 5}};
 
  CyclicDataBuilder builder(config);
 
  builder.SetData(1, 1, {1, 2, 3, 4});
  builder.SetIocs(1, 1, 0x55U);
  builder.Swap();
 
  ASSERT_EQ(builder.Build().at(0), 1U);
  ASSERT_EQ(builder.Build().at(1), 2U);
  ASSERT_EQ(builder.Build().at(2), 3U);
  ASSERT_EQ(builder.Build().at(3), 4U);
  ASSERT_EQ(builder.Build().at(5), 0x55U);
 
  builder.Clear();
 
  // Clear() modifies the write buffer; Swap() promotes it to the send buffer.
  builder.Swap();
 
  EXPECT_EQ(builder.Build(), Bytes(32U, 0));
  EXPECT_EQ(builder.GetData(1, 1), Bytes(4U, 0));
}
 
TEST_F(RtMoreTests, CyclicDataBuilderLoadCopiesAndClearsRemainder)
{
  CyclicDataBuilder builder(MakeConfig());
 
  builder.Load({1, 2, 3});
  builder.Swap();
 
  const auto data = builder.Build();
 
  ASSERT_EQ(data.size(), 12U);
  EXPECT_EQ(data[0], 1U);
  EXPECT_EQ(data[1], 2U);
  EXPECT_EQ(data[2], 3U);
  EXPECT_EQ(data[3], 0U);
}
 
TEST_F(RtMoreTests, CyclicDataBuilderLoadTruncatesLongPayload)
{
  CyclicDataBuilder builder(MakeConfig());
 
  builder.Load(Bytes(32U, 0xAA));
  builder.Swap();
 
  const auto data = builder.Build();
 
  EXPECT_EQ(data.size(), 12U);
  EXPECT_EQ(data[0], 0xAAU);
  EXPECT_EQ(data[11], 0xAAU);
}
 
TEST_F(RtMoreTests, CyclicDataBuilderGetDataRejectsUnknownSlotSubslot)
{
  CyclicDataBuilder builder(MakeConfig());
 
  EXPECT_THROW(builder.GetData(9, 9), std::exception);
}
 
TEST_F(RtMoreTests, CyclicDataBuilderSetDataTruncatesOversizedData)
{
  rt::IOCRConfig config;
  config.dataLength = 16;
 
  config.objects = {
      rt::IODataObject{
          .slot = 1,
          .subslot = 1,
          .frameOffset = 2,
          .dataLength = 4,
          .offsetIOPS = 6,
          .offsetIOCS = 7}};
 
  CyclicDataBuilder builder(config);
 
  builder.SetData(1, 1, Bytes{0x01, 0x02, 0x03, 0x04, 0x05});
 
  EXPECT_EQ(builder.GetData(1, 1), (Bytes{0x01, 0x02, 0x03, 0x04}));
}
 
TEST_F(RtMoreTests, CyclicDataBuilderSwapWithoutChangesPreservesData)
{
  CyclicDataBuilder builder(MakeConfig());
 
  builder.SetData(1, 1, {1, 2, 3, 4});
  builder.Swap();
  const auto before = builder.Build();
 
  builder.Swap();
  const auto after = builder.Build();
 
  EXPECT_EQ(after, before);
}
 
TEST_F(RtMoreTests, IOCRTimingHelpersCalculateCycleAndWatchdog)
{
  IOCRConfig config;
  config.sendClockFactor = 32;
  config.reductionRatio = 8;
  config.watchdogFactor = 3;
 
  EXPECT_EQ(config.CycleTimeUs(), 8000U);
  EXPECT_DOUBLE_EQ(config.CycleTimeMs(), 8.0);
  EXPECT_EQ(config.WatchdogTimeUs(), 24000U);
}
 
TEST_F(RtMoreTests, IOCRTypePredicatesCoverBothDirections)
{
  IOCRConfig config;
 
  config.typeIOCR = IOCR_TYPE_INPUT;
  EXPECT_TRUE(config.IsInput());
  EXPECT_FALSE(config.IsOutput());
 
  config.typeIOCR = IOCR_TYPE_OUTPUT;
  EXPECT_FALSE(config.IsInput());
  EXPECT_TRUE(config.IsOutput());
 
  config.typeIOCR = 0;
  EXPECT_FALSE(config.IsInput());
  EXPECT_FALSE(config.IsOutput());
}
 
TEST_F(RtMoreTests, BuildIocrConfigsHandlesEmptySlotList)
{
  const std::vector<rpc::IOSlot> slots;
 
  const auto [input, output] = BuildIocrConfigs(slots, 0xC001, 0x8001);
 
  EXPECT_TRUE(input.objects.empty());
  EXPECT_TRUE(output.objects.empty());
  EXPECT_EQ(input.dataLength, 40U);
  EXPECT_EQ(output.dataLength, 40U);
}
 
TEST_F(RtMoreTests, BuildIocrConfigsCoversInputAndOutputBranches)
{
  const std::vector<rpc::IOSlot> slots{
      MakeSlot(1, 1, 0, 0), // input == 0, output == 0
      MakeSlot(2, 1, 4, 0), // input > 0, output == 0
      MakeSlot(3, 1, 0, 6), // input == 0, output > 0
      MakeSlot(4, 1, 3, 2)  // input > 0, output > 0
  };
 
  const auto [input, output] =
      BuildIocrConfigs(slots, 0xC001, 0xC002, 32, 8, 3, 43);
 
  ASSERT_EQ(input.objects.size(), 5U);
  ASSERT_EQ(output.objects.size(), 5U);
 
  // -------------------------------------------------------------------------
  // Input IOCR
  //
  // IOCS section:
  //   slot 1 -> IOCS @ 0
  //   slot 3 -> IOCS @ 1
  //   slot 4 -> IOCS @ 2
  //
  // Input data section:
  //   slot 2 -> data @ 3, length 4, IOPS @ 7
  //   slot 4 -> data @ 8, length 3, IOPS @ 11
  // -------------------------------------------------------------------------
 
  EXPECT_EQ(input.objects[0].slot, 1U);
  EXPECT_EQ(input.objects[0].subslot, 1U);
  EXPECT_EQ(input.objects[0].dataLength, 0U);
  EXPECT_EQ(input.objects[0].frameOffset, 0U);
  EXPECT_EQ(input.objects[0].offsetIOPS, std::nullopt);
  EXPECT_EQ(input.objects[0].offsetIOCS, 0U);
 
  EXPECT_EQ(input.objects[1].slot, 3U);
  EXPECT_EQ(input.objects[1].subslot, 1U);
  EXPECT_EQ(input.objects[1].dataLength, 0U);
  EXPECT_EQ(input.objects[1].frameOffset, 1U);
  EXPECT_EQ(input.objects[1].offsetIOPS, std::nullopt);
  EXPECT_EQ(input.objects[1].offsetIOCS, 1U);
 
  // Bidirectional submodule: IOCS entry in addition to input data entry.
  EXPECT_EQ(input.objects[2].slot, 4U);
  EXPECT_EQ(input.objects[2].subslot, 1U);
  EXPECT_EQ(input.objects[2].dataLength, 0U);
  EXPECT_EQ(input.objects[2].frameOffset, 2U);
  EXPECT_EQ(input.objects[2].offsetIOPS, std::nullopt);
  EXPECT_EQ(input.objects[2].offsetIOCS, 2U);
 
  EXPECT_EQ(input.objects[3].slot, 2U);
  EXPECT_EQ(input.objects[3].subslot, 1U);
  EXPECT_EQ(input.objects[3].dataLength, 4U);
  EXPECT_EQ(input.objects[3].frameOffset, 2U); // DIT LIJKT FOUT!
  EXPECT_EQ(input.objects[3].offsetIOPS, 7U);
  EXPECT_EQ(input.objects[3].offsetIOCS, std::nullopt);
 
  // Bidirectional submodule: input data entry as well as IOCS entry.
  EXPECT_EQ(input.objects[4].slot, 4U);
  EXPECT_EQ(input.objects[4].subslot, 1U);
  EXPECT_EQ(input.objects[4].dataLength, 3U);
  EXPECT_EQ(input.objects[4].frameOffset, 7U);
  EXPECT_EQ(input.objects[4].offsetIOPS, 11U);
  EXPECT_EQ(input.objects[4].offsetIOCS, std::nullopt);
 
  // -------------------------------------------------------------------------
  // Output IOCR
  //
  // IOCS section:
  //   slot 1 -> IOCS @ 0
  //   slot 2 -> IOCS @ 1
  //   slot 4 -> IOCS @ 2
  //
  // Output data section:
  //   slot 3 -> data @ 3, length 6, IOPS @ 9
  //   slot 4 -> data @ 10, length 2, IOPS @ 12
  // -------------------------------------------------------------------------
 
  EXPECT_EQ(output.objects[0].slot, 1U);
  EXPECT_EQ(output.objects[0].subslot, 1U);
  EXPECT_EQ(output.objects[0].dataLength, 0U);
  EXPECT_EQ(output.objects[0].frameOffset, 0U);
  EXPECT_EQ(output.objects[0].offsetIOPS, std::nullopt);
  EXPECT_EQ(output.objects[0].offsetIOCS, 0U);
 
  EXPECT_EQ(output.objects[1].slot, 2U);
  EXPECT_EQ(output.objects[1].subslot, 1U);
  EXPECT_EQ(output.objects[1].dataLength, 0U);
  EXPECT_EQ(output.objects[1].frameOffset, 1U);
  EXPECT_EQ(output.objects[1].offsetIOPS, std::nullopt);
  EXPECT_EQ(output.objects[1].offsetIOCS, 1U);
 
  // Bidirectional submodule: IOCS entry in addition to output data entry.
  EXPECT_EQ(output.objects[2].slot, 4U);
  EXPECT_EQ(output.objects[2].subslot, 1U);
  EXPECT_EQ(output.objects[2].dataLength, 2U);
  EXPECT_EQ(output.objects[2].frameOffset, 2U);
  EXPECT_EQ(output.objects[2].offsetIOPS, std::nullopt);
  EXPECT_EQ(output.objects[2].offsetIOCS, 2U);
 
  EXPECT_EQ(output.objects[3].slot, 3U);
  EXPECT_EQ(output.objects[3].subslot, 1U);
  EXPECT_EQ(output.objects[3].dataLength, 6U);
  EXPECT_EQ(output.objects[3].frameOffset, 3U);
  EXPECT_EQ(output.objects[3].offsetIOPS, 9U);
  EXPECT_EQ(output.objects[3].offsetIOCS, std::nullopt);
 
  // Bidirectional submodule: output data entry as well as IOCS entry.
  EXPECT_EQ(output.objects[4].slot, 4U);
  EXPECT_EQ(output.objects[4].subslot, 1U);
  EXPECT_EQ(output.objects[4].dataLength, 2U);
  EXPECT_EQ(output.objects[4].frameOffset, 10U);
  EXPECT_EQ(output.objects[4].offsetIOPS, 12U);
  EXPECT_EQ(output.objects[4].offsetIOCS, std::nullopt);
 
  // -------------------------------------------------------------------------
  // IOCR configuration.
  // -------------------------------------------------------------------------
 
  EXPECT_EQ(input.typeIOCR, IOCR_TYPE_INPUT);
  EXPECT_EQ(output.typeIOCR, IOCR_TYPE_OUTPUT);
 
  EXPECT_EQ(input.referenceIOCR, 1U);
  EXPECT_EQ(output.referenceIOCR, 2U);
 
  EXPECT_EQ(input.frameId, 0xC001U);
  EXPECT_EQ(output.frameId, 0xC002U);
 
  EXPECT_EQ(input.sendClockFactor, 32U);
  EXPECT_EQ(output.sendClockFactor, 32U);
 
  EXPECT_EQ(input.reductionRatio, 8U);
  EXPECT_EQ(output.reductionRatio, 8U);
 
  EXPECT_EQ(input.phase, 0U);
  EXPECT_EQ(output.phase, 0U);
 
  EXPECT_EQ(input.watchdogFactor, 3);
  EXPECT_EQ(output.watchdogFactor, 3);
 
  // The configured minimum C_SDU length is larger than the calculated
  // layouts, so both IOCRs are padded to 43 bytes.
  EXPECT_EQ(input.dataLength, 43U);
  EXPECT_EQ(output.dataLength, 43U);
}
 
TEST_F(RtMoreTests, BuildIocrConfigsUsesMinimumCSduLength)
{
  const std::vector<rpc::IOSlot> slots{
      MakeSlot(1, 1, 0, 0)};
 
  const auto [input, output] =
      BuildIocrConfigs(slots, 0xC001, 0xC002, 32, 8, 3, 43);
 
  EXPECT_EQ(input.dataLength, 43U);
  EXPECT_EQ(output.dataLength, 43U);
}
 
TEST_F(RtMoreTests, BuildIocrConfigsUsesCalculatedSizeWhenLarger)
{
  const std::vector<rpc::IOSlot> slots{
      MakeSlot(1, 1, 0, 0),
      MakeSlot(2, 1, 20, 20),
      MakeSlot(3, 1, 20, 20)};
 
  const auto [input, output] =
      BuildIocrConfigs(slots, 0xC001, 0xC002, 32, 8, 3, 1);
 
  EXPECT_GT(input.dataLength, 1U);
  EXPECT_GT(output.dataLength, 1U);
}
 
TEST_F(RtMoreTests, CyclicDataBuilderSetDataRejectsUnknownSlotSubslot)
{
  CyclicDataBuilder builder(MakeConfig());
 
  EXPECT_THROW(builder.SetData(9, 9, {1, 2, 3}), std::invalid_argument);
}
 
TEST_F(RtMoreTests, CyclicDataBuilderSwapPromotesDirtyBuffer)
{
  CyclicDataBuilder builder(MakeConfig());
 
  builder.SetData(1, 1, {0x11, 0x22, 0x33, 0x44});
 
  ASSERT_EQ(builder.Build(), Bytes(12U, 0));
 
  builder.Swap();
 
  EXPECT_EQ(builder.Build().at(0), 0x11U);
  EXPECT_EQ(builder.Build().at(1), 0x22U);
  EXPECT_EQ(builder.Build().at(2), 0x33U);
  EXPECT_EQ(builder.Build().at(3), 0x44U);
}
 
TEST_F(RtMoreTests, CyclicDataBuilderConfigReturnsConfiguration)
{
  const auto config = MakeConfig();
  CyclicDataBuilder builder(config);
 
  EXPECT_EQ(builder.Config().dataLength, config.dataLength);
  ASSERT_EQ(builder.Config().objects.size(), config.objects.size());
}