test_regressionAuma.cpp

Go to the documentation of this file.

 
 
#include <gtest/gtest.h>
 
#include <algorithm>
#include <array>
#include <chrono>
#include <cstddef>
#include <cstdint>
#include <filesystem>
#include <memory>
#include <string>
#include <vector>
 
#include "profinet/gsdml.h"
#include "profinet/protocol.h"
#include "profinet/rpc.h"
#include "profinet/rt.h"
 
namespace profinet
{
namespace
{
using namespace profinet::rpc;
 
constexpr std::uint16_t kInputFrameId = 0x9000;
constexpr std::uint16_t kOutputFrameId = 0x8001;
constexpr std::uint16_t kSendClockFactor = 32;
constexpr std::uint16_t kReductionRatio = 8;
constexpr std::uint16_t kInputLength = 43;
constexpr std::uint16_t kOutputLength = 40;
constexpr std::uint16_t kAumaInputLength = 34;
constexpr std::uint16_t kAumaOutputLength = 16;
constexpr std::uint16_t kAumaInputOffset = 1;
constexpr std::uint16_t kAumaOutputOffset = 8;
constexpr std::uint16_t kAumaInputIopsOffset = 35;
constexpr std::uint8_t kOpen = 0x01;
constexpr std::uint8_t kNotOpen = 0x00;
 
constexpr MacAddress kIoControllerMac{0xA8, 0x74, 0x1D, 0x44, 0x7A, 0xBB};
constexpr MacAddress kAumaMac{0xA0, 0xD3, 0x85, 0x00, 0xF6, 0x13};
 
std::filesystem::path Fixture(const std::string& name)
{
  const std::array<std::filesystem::path, 4> paths{
      profinet::GetExecutableDirectory() / "gsdml" / name,
      profinet::GetExecutableDirectory() / "test_data" / "gsdml" / name,
      profinet::GetExecutableDirectory() / "tests" / "data" / "gsdml" / name,
      std::filesystem::current_path() / "tests" / "gsdml" / name};
 
  for (const auto& path : paths)
  {
    if (std::filesystem::exists(path))
    {
      return path;
    }
  }
 
  ADD_FAILURE() << "GSDML fixture not found: " << name;
  return {};
}
 
gsdml::GSDMLDevice Load(const std::string& name)
{
  const auto path = Fixture(name);
  return path.empty() ? gsdml::GSDMLDevice{} : gsdml::ParseGsdml(path.string());
}
 
const rpc::IOSlot* Slot(const std::vector<rpc::IOSlot>& slots, std::uint16_t slot, std::uint16_t subslot)
{
  const auto it = std::ranges::find_if(slots, [slot, subslot](const rpc::IOSlot& value)
  {
    return value.slot == slot && value.subslot == subslot;
  });
  return it == slots.end() ? nullptr : &(*it);
}
 
std::vector<Bytes> Blocks(const Bytes& data)
{
  std::vector<Bytes> result;
  std::size_t offset = 0;
  while (offset + blockHeaderLength <= data.size())
  {
    const auto header = PeekBlockHeader(data, offset);
    const std::size_t size = 4U + header.blockLength;
    if (size > data.size() - offset)
    {
      break;
    }
    result.emplace_back(data.begin() + offset, data.begin() + offset + size);
    offset += size;
  }
  return result;
}
 
rt::IOCRConfig CapturedInput()
{
  rt::IOCRConfig c;
  c.typeIOCR = rt::IOCR_TYPE_INPUT;
  c.referenceIOCR = 1;
  c.frameId = kInputFrameId;
  c.sendClockFactor = kSendClockFactor;
  c.reductionRatio = kReductionRatio;
  c.phase = 8;
  c.watchdogFactor = 3;
  c.dataLength = kInputLength;
  c.objects = {
      {.slot = 0, .subslot = 0x0001, .frameOffset = 0, .dataLength = 0, .offsetIOCS = 0},
      {.slot = 0, .subslot = 0x0002, .frameOffset = 1, .dataLength = 0, .offsetIOCS = 1},
      {.slot = 0, .subslot = 0x0003, .frameOffset = 2, .dataLength = 0, .offsetIOCS = 2},
      {.slot = 0, .subslot = 0x0004, .frameOffset = 3, .dataLength = 0, .offsetIOCS = 3},
      {.slot = 0, .subslot = 0x8000, .frameOffset = 4, .dataLength = 0, .offsetIOCS = 4},
      {.slot = 0, .subslot = 0x8001, .frameOffset = 5, .dataLength = 0, .offsetIOCS = 5},
      {.slot = 0, .subslot = 0x8002, .frameOffset = 6, .dataLength = 0, .offsetIOCS = 6},
      {.slot = 1, .subslot = 1, .frameOffset = kAumaInputOffset, .dataLength = kAumaInputLength, .offsetIOPS = kAumaInputIopsOffset},
      {.slot = 2, .subslot = 1, .frameOffset = 0, .dataLength = 0, .offsetIOCS = 42}};
  return c;
}
 
rt::IOCRConfig CapturedOutput()
{
  rt::IOCRConfig c;
  c.typeIOCR = rt::IOCR_TYPE_OUTPUT;
  c.referenceIOCR = 2;
  c.frameId = kOutputFrameId;
  c.sendClockFactor = kSendClockFactor;
  c.reductionRatio = kReductionRatio;
  c.phase = 8;
  c.watchdogFactor = 3;
  c.dataLength = kOutputLength;
  c.objects = {{.slot = 0, .subslot = 0x0001, .frameOffset = 0, .dataLength = 0, .offsetIOCS = 0},
               {.slot = 0, .subslot = 0x0002, .frameOffset = 1, .dataLength = 0, .offsetIOCS = 1},
               {.slot = 0, .subslot = 0x0003, .frameOffset = 2, .dataLength = 0, .offsetIOCS = 2},
               {.slot = 0, .subslot = 0x0004, .frameOffset = 3, .dataLength = 0, .offsetIOCS = 3},
               {.slot = 0, .subslot = 0x8000, .frameOffset = 4, .dataLength = 0, .offsetIOCS = 4},
               {.slot = 0, .subslot = 0x8001, .frameOffset = 5, .dataLength = 0, .offsetIOCS = 5},
               {.slot = 0, .subslot = 0x8002, .frameOffset = 6, .dataLength = 0, .offsetIOCS = 6},
               {.slot = 1, .subslot = 1, .frameOffset = 7, .dataLength = 0, .offsetIOCS = 7},
               {.slot = 2, .subslot = 1, .frameOffset = kAumaOutputOffset, .dataLength = kAumaOutputLength, .offsetIOPS = 24}};
  return c;
}
 
Bytes InputPayload(std::uint16_t position)
{
  Bytes payload(kInputLength, 0x80);
 
  // IOPS: 0x80 (Good)
  //     1... .... = DataState: Bad (0x0)
  //     .00. .... = Instance: 0x00
  //     ...0 000. = Reserved: 0x0
  //     .... ...0 = Extension: No IOxS octet follows (0x0)
 
  payload[0] = 0x80; // IOPS, see above
 
  // Input Byte 1 : Logical signals
  // BIdx 0 =End position OPEN
  // BIdx 1 =End position CLOSED
  // BIdx 2 =Setpoint position reach
  // BIdx 3 =Not ready REMOTE
  // BIdx 4 =Running OPEN
  // BIdx 5 =Running CLOSE
  // BIdx 6 =Warning
  // BIdx 7 =Fault
  payload[1] = 0x00; // Idle state
 
  // Input Byte 2 : Actuator signals
  // BIdx 0 = Thermal fault
  // BIdx 1 = Phase fault
  // BIdx 2 = Selector switch REMOTE
  // BIdx 3 = Selector switch LOCALE
  // BIdx 4 = Limit switch OPEN
  // BIdx 5 = Limit switch CLOSED
  // BIdx 6 = Torque switch OPEN
  // BIdx 7 = Torque switch CLOSED
  payload[2] = 0x04; // Bit 2 is set, so means Selector switch REMOTE is ON
 
  // Input Byte 3/4 : Actual position
  payload[3] = static_cast<std::uint8_t>(position >> 8U);
  payload[4] = static_cast<std::uint8_t>(position);
  payload[kAumaInputIopsOffset] = 0x80;
  // kAumaInputIopsOffset = 34 input bytes (Logic signals 1 byte, Actuator signals 1 byte, Actual position, 2 bytes, etc..) (+ 1 (next one = Iops)
  return payload;
}
 
class ConnectCapture final : public rpc::IRpcTransport
{
 public:
  Bytes SendReceive(const Bytes& request, std::chrono::milliseconds /*timeout*/) override
  {
    requests.push_back(request);
    const auto parsed = PNRPCHeader::Parse(request);
    PNRPCHeader response = parsed;
    response.packetType = PNRPCHeader::RESPONSE;
 
    Bytes blocks;
    for (const auto [type, frameId] : std::array<std::pair<std::uint16_t, std::uint16_t>, 2>{{{1, kInputFrameId}, {2, kOutputFrameId}}})
    {
      wire::PutU16(blocks, PNIOCRBlockRes::BLOCK_TYPE);
      wire::PutU16(blocks, PNIOCRBlockRes::kSize - 4);
      wire::PutU8(blocks, profinet::rpc::VERSION_HIGH);
      wire::PutU8(blocks, profinet::rpc::VERSION_LOW);
      wire::PutU16(blocks, type);
      wire::PutU16(blocks, type);
      wire::PutU16(blocks, frameId);
    }
 
    PNNRDData nrd;
    nrd.argsMaximumStatus = 0;
    nrd.argsLength = static_cast<std::uint32_t>(blocks.size());
    nrd.maximumCount = 1500;
    nrd.offset = 0;
    nrd.actualCount = static_cast<std::uint32_t>(blocks.size());
    nrd.payload = blocks;
    response.payload = nrd.ToBytes();
    response.lengthOfBody = static_cast<std::uint16_t>(response.payload.size());
    return response.ToBytes();
  }
 
  void Send(const Bytes& data) override
  {
    sends.push_back(data);
  }
  void Open(const std::string& /*address*/, std::uint16_t /*port*/, bool /*isListener*/) override
  {
  }
  Bytes Receive(std::chrono::milliseconds /*timeout*/, asio::ip::udp::endpoint& /*remoteEndpoint*/) override
  {
    return {};
  }
  void SendTo(const Bytes& data, const asio::ip::udp::endpoint& /*targetEndpoint*/) override
  {
    sends.push_back(data);
  }
  void Close() noexcept override
  {
  }
 
  std::vector<Bytes> requests;
  std::vector<Bytes> sends;
};
 
dcp::DCPDeviceDescription AumaInfo()
{
  dcp::DCPDeviceDescription info(kAumaMac, {});
  info.name = "AUMA-SGx";
  info.ip = "127.0.0.1";
  info.vendorHigh = 0x01;
  info.vendorLow = 0x3F;
  info.deviceHigh = 0x00;
  info.deviceLow = 0x02;
  return info;
}
 
} // namespace
 
TEST(IoControllerAumaGsdml, AumaProfileMatchesCaptureDevice)
{
  const auto auma = Load("GSDML-V2.42-AUMA-SGX-20220920.xml");
  EXPECT_EQ(auma.vendorId, 0x013F);
  EXPECT_EQ(auma.deviceId, 0x0002);
  EXPECT_EQ(auma.dapModuleIdentNumber, 0x80010000U);
 
  const auto slots = auma.BuildIoSlots();
  const auto* input = Slot(slots, 1, 1);
  const auto* output = Slot(slots, 2, 1);
  ASSERT_NE(input, nullptr);
  ASSERT_NE(output, nullptr);
  EXPECT_EQ(input->moduleIdent, 0x00008000U);
  EXPECT_EQ(input->submoduleIdent, 0x00002200U);
  EXPECT_EQ(input->inputLength, kAumaInputLength);
  EXPECT_EQ(output->moduleIdent, 0x00008100U);
  EXPECT_EQ(output->submoduleIdent, 0x10001000U);
  EXPECT_EQ(output->outputLength, kAumaOutputLength);
}
 
TEST(IoControllerAumaGsdml, PhoenixProfileMatchesCaptureController)
{
  const auto phoenix = Load("GSDML-V2.45-Phoenix Contact-AXC F 1252-20250813.xml");
  EXPECT_EQ(phoenix.vendorId, 0x00B0);
  EXPECT_EQ(phoenix.deviceId, 0x0193);
  EXPECT_EQ(phoenix.dapModuleIdentNumber, 0x00000300U);
  EXPECT_NE(phoenix.FindModule("PNSlot1"), nullptr);
}
 
TEST(IoControllerAumaConnection, ConnectUsesCapturedNegotiatedFrameIdsAndTiming)
{
  auto transport = std::make_unique<ConnectCapture>();
  auto* capture = transport.get();
  auto control = std::make_unique<ConnectCapture>();
 
  rpc::RPCCon connection(AumaInfo(), {}, std::move(transport), std::move(control));
  const auto auma = Load("GSDML-V2.42-AUMA-SGX-20220920.xml");
  auto setup = rpc::IOCRSetup{};
  setup.slots = auma.BuildIoSlots();
  setup.sendClockFactor = kSendClockFactor;
  setup.reductionRatio = kReductionRatio;
  setup.watchdogFactor = 3;
  setup.dataHoldFactor = 6;
 
  const auto result = connection.Connect(kIoControllerMac, true, setup);
  ASSERT_TRUE(result.has_value());
  EXPECT_EQ(result->inputFrameId, kInputFrameId);
  EXPECT_EQ(result->outputFrameId, kOutputFrameId);
  ASSERT_EQ(capture->requests.size(), 1U);
 
  const auto rpcPacket = PNRPCHeader::Parse(capture->requests.front());
  const auto nrd = PNNRDData::Parse(rpcPacket.payload);
  const auto blocks = Blocks(nrd.payload);
  ASSERT_GE(blocks.size(), 4U);
 
  EXPECT_EQ(PeekBlockHeader(blocks[0], 0).blockType,
            static_cast<std::uint16_t>(BlockType::ApplicationRelationRequest));
  EXPECT_EQ(PeekBlockHeader(blocks[1], 0).blockType, static_cast<std::uint16_t>(PNIOCRBlockReqHeader::BLOCK_TYPE));
  EXPECT_EQ(PeekBlockHeader(blocks[2], 0).blockType, static_cast<std::uint16_t>(PNIOCRBlockReqHeader::BLOCK_TYPE));
 
  const auto input = PNIOCRBlockReqHeader::Parse(blocks[1]);
  const auto output = PNIOCRBlockReqHeader::Parse(blocks[2]);
  EXPECT_EQ(input.iocrType, 1);
  EXPECT_EQ(input.iocrReference, 1);
  EXPECT_EQ(input.dataLength, kInputLength);
  EXPECT_EQ(input.sendClockFactor, kSendClockFactor);
  EXPECT_EQ(input.reductionRatio, kReductionRatio);
  EXPECT_EQ(output.iocrType, 2);
  EXPECT_EQ(output.iocrReference, 2);
  EXPECT_EQ(output.dataLength, kOutputLength);
  EXPECT_EQ(output.sendClockFactor, kSendClockFactor);
  EXPECT_EQ(output.reductionRatio, kReductionRatio);
 
  const auto types = std::vector<std::uint16_t>{
      PeekBlockHeader(blocks[0], 0).blockType,
      PeekBlockHeader(blocks[1], 0).blockType,
      PeekBlockHeader(blocks[2], 0).blockType};
  const std::vector<std::uint16_t> expected = {
      static_cast<std::uint16_t>(BlockType::ApplicationRelationRequest),
      static_cast<std::uint16_t>(PNIOCRBlockReqHeader::BLOCK_TYPE),
      static_cast<std::uint16_t>(PNIOCRBlockReqHeader::BLOCK_TYPE)};
  EXPECT_EQ(types, expected);
}
 
TEST(IoControllerAumaCyclicIo, OutputOpenAndStopUseCapturedByte25)
{
  const auto config = CapturedOutput();
  rt::CyclicDataBuilder builder(config);
  // Output module from GSDML = slot 2, subslot = 1
  // Output Byte 1 : Commands
  // BIdx 0 =Fieldbus OPEN
  // BIdx 1 =Fieldbus CLOSE
  // BIdx 2 =Fieldbus SETPOINT
  // BIdx 3 =Fieldbus RESET
  // BIdx 4 =Fieldbus STOP
  // BIdx 5 =-
  // BIdx 6 =-
  // BIdx 7 =-
 
  builder.SetData(2, 1, Bytes{kOpen}); // kOpen = 0x01
  builder.Swap();
  auto openPayload = builder.Build();
  ASSERT_EQ(openPayload.size(), kOutputLength);
  EXPECT_EQ(openPayload[kAumaOutputOffset], kOpen);
 
  builder.SetData(2, 1, Bytes{kNotOpen}); // kNotOpen = 0x00
  builder.Swap();
  const auto stopOpenPayload = builder.Build();
  ASSERT_EQ(stopOpenPayload.size(), kOutputLength);
 
  EXPECT_EQ(stopOpenPayload[kAumaOutputOffset], kNotOpen); // kNotOpen = 0x00
 
  const rt::RTFrame openFrame{
      .frameId = kOutputFrameId,
      .cycleCounter = 1,
      .dataStatus = rt::DATA_STATUS_VALID | rt::DATA_STATUS_PROVIDER_RUN | rt::DATA_STATUS_STATION_OK | rt::DATA_STATUS_STATE,
      .transferStatus = 0,
      .payload = openPayload};
 
  const auto ethernet = rt::BuildEthernetFrame(kAumaMac, kIoControllerMac, openFrame);
 
  wire::Reader rh(ethernet);
  // EthernetHeader oh = EthernetHeader::Parse(ethernet);
  auto dst = rh.Fixed<macAddressLength>();
  auto src = rh.Fixed<macAddressLength>();
  auto etherFrametype = rh.U16();
  auto frameBytes = rh.ReadBytes(rh.Remaining());
 
  rt::RTFrame frame = rt::RTFrame::FromBytes(frameBytes);
 
  // Builder should create an IOCRConfig
  rt::IOCRConfig stopConfig;
  wire::Reader r(frame.payload);
  // stopConfig.typeIOCR = r.U16();
  auto dapIocr = r.U8();                           // device access point; submodule without output data
  auto prmIocr = r.U8();                           // parameter; submodule without output data
  auto pzsIocr = r.U8();                           // process data; submodule without output data
  auto fileTransferIocr = r.U8();                  // file transfer; submodule without output data
  auto interfaceIocr = r.U8();                     // Interface; submodule without output data
  auto port1Iocr = r.U8();                         // P1; submodule without output data
  auto port2Iocr = r.U8();                         // P2; submodule without output data
  auto inputIocr = r.U8();                         // inputIocr; submodule without output data
  auto outputbytes = r.Fixed<kAumaOutputLength>(); // Output process data
                                                   //
  auto outputIops = r.U8();                        // ? IOPS byte ??
  auto remainingData = r.ReadBytes(r.Remaining());
 
  wire::Reader outputProcessDataReader(outputbytes);
  // Output Byte 1 : Commands
  // BIdx 0 =Fieldbus OPEN
  // BIdx 1 =Fieldbus CLOSE
  // BIdx 2 =Fieldbus SETPOINT
  // BIdx 3 =Fieldbus RESET
  // BIdx 4 =Fieldbus STOP
  // BIdx 5 =-
  // BIdx 6 =-
  // BIdx 7 =-
  auto commands = outputProcessDataReader.U8();
  auto remainingOutputBytes = outputProcessDataReader.ReadBytes(outputProcessDataReader.Remaining());
 
  ASSERT_EQ(ethernet.size(), 60U);
  EXPECT_EQ(etherFrametype, PROFINET_ETHERTYPE);
  EXPECT_EQ(frame.frameId, kOutputFrameId);
 
  EXPECT_TRUE(commands & kOpen); // check if Fieldbus Open Command bit is set;
 
  for (const auto remainingOutputByte : remainingOutputBytes)
  {
    EXPECT_EQ(remainingOutputByte, 0x00);
  }
 
  const rt::RTFrame stopOpeningFrame{
      .frameId = kOutputFrameId,
      .cycleCounter = 1,
      .dataStatus = rt::DATA_STATUS_VALID | rt::DATA_STATUS_PROVIDER_RUN | rt::DATA_STATUS_STATION_OK | rt::DATA_STATUS_STATE,
      .transferStatus = 0,
      .payload = stopOpenPayload};
 
  const auto ethernetStopOpen = rt::BuildEthernetFrame(kAumaMac, kIoControllerMac, stopOpeningFrame);
 
  wire::Reader rhStopOpen(ethernetStopOpen);
  // EthernetHeader oh = EthernetHeader::Parse(ethernet);
  dst = rhStopOpen.Fixed<macAddressLength>();
  src = rhStopOpen.Fixed<macAddressLength>();
  etherFrametype = rhStopOpen.U16();
  frameBytes = rhStopOpen.ReadBytes(rhStopOpen.Remaining());
 
  frame = rt::RTFrame::FromBytes(frameBytes);
 
  // Builder should create an IOCRConfig
  rt::IOCRConfig configStopOpen;
  wire::Reader r2(frame.payload);
  // stopConfig.typeIOCR = r.U16();
  dapIocr = r2.U8();                           // device access point; submodule without output data
  prmIocr = r2.U8();                           // parameter; submodule without output data
  pzsIocr = r2.U8();                           // process data; submodule without output data
  fileTransferIocr = r2.U8();                  // file transfer; submodule without output data
  interfaceIocr = r2.U8();                     // Interface; submodule without output data
  port1Iocr = r2.U8();                         // P1; submodule without output data
  port2Iocr = r2.U8();                         // P2; submodule without output data
  inputIocr = r2.U8();                         // inputIocr; submodule without output data
  outputbytes = r2.Fixed<kAumaOutputLength>(); // Output process data
                                               //
  outputIops = r2.U8();                        // ? IOPS byte ??
  remainingData = r2.ReadBytes(r2.Remaining());
 
  wire::Reader outputProcessDataReaderStopOpen(outputbytes);
  // Output Byte 1 : Commands
  // BIdx 0 =Fieldbus OPEN
  // BIdx 1 =Fieldbus CLOSE
  // BIdx 2 =Fieldbus SETPOINT
  // BIdx 3 =Fieldbus RESET
  // BIdx 4 =Fieldbus STOP
  // BIdx 5 =-
  // BIdx 6 =-
  // BIdx 7 =-
  commands = outputProcessDataReaderStopOpen.U8();
  remainingOutputBytes = outputProcessDataReaderStopOpen.ReadBytes(outputProcessDataReaderStopOpen.Remaining());
 
  ASSERT_EQ(ethernet.size(), 60U);
  EXPECT_EQ(etherFrametype, PROFINET_ETHERTYPE);
  EXPECT_EQ(frame.frameId, kOutputFrameId);
 
  EXPECT_FALSE(commands & kOpen); // check if Fieldbus Open Command bit is unset;
 
  for (const auto remainingOutputByte : remainingOutputBytes)
  {
    EXPECT_EQ(remainingOutputByte, 0x00);
  }
}
 
TEST(IoControllerAumaCyclicIo, InputPositionSamplesRemainBigEndianAtCapturedBytes20And21)
{
  auto config = CapturedInput();
  rt::CyclicDataBuilder builder(config);
 
  constexpr std::array<std::uint16_t, 6> samples{
      0x0202, 0x0206, 0x0207, 0x020F, 0x0217, 0x0221};
 
  for (const auto sample : samples)
  {
    builder.Load(InputPayload(sample));
    builder.Swap();
    const auto payload = builder.Build();
    wire::Reader r(payload);
    auto iOps = r.U8();
    auto logicalSignals = r.U8();
    auto actuatorSignals = r.U8();
    auto actualPosition = r.U16();
 
    ASSERT_EQ(payload.size(), kInputLength);
    EXPECT_EQ(actualPosition, sample);
    EXPECT_EQ(payload[kAumaInputIopsOffset], 0x80);
    EXPECT_EQ(iOps, 0x80);
  }
}
 
TEST(IoControllerAumaCyclicIo, Layer2FramesMatchCaptureLengthsAndDirections)
{
  const auto output = rt::BuildEthernetFrame(
      kAumaMac, kIoControllerMac,
      rt::RTFrame{
          .frameId = kOutputFrameId,
          .cycleCounter = 1,
          .dataStatus = rt::DATA_STATUS_VALID | rt::DATA_STATUS_PROVIDER_RUN | rt::DATA_STATUS_STATION_OK | rt::DATA_STATUS_STATE,
          .transferStatus = 0,
          .payload = Bytes(kOutputLength, 0)});
  const auto input = rt::BuildEthernetFrame(
      kIoControllerMac, kAumaMac,
      rt::RTFrame{
          .frameId = kInputFrameId,
          .cycleCounter = 1,
          .dataStatus = rt::DATA_STATUS_VALID | rt::DATA_STATUS_PROVIDER_RUN | rt::DATA_STATUS_STATION_OK | rt::DATA_STATUS_STATE,
          .transferStatus = 0,
          .payload = Bytes(kInputLength, 0x80)});
 
  EXPECT_EQ(output.size(), 60U);
  EXPECT_EQ(input.size(), 63U);
 
  wire::Reader roh(output);
  auto dstOutput = roh.Fixed<macAddressLength>();
  auto srcOutput = roh.Fixed<macAddressLength>();
  auto etherFrametypeOutput = roh.U16();
  auto frameBytesOutput = roh.ReadBytes(roh.Remaining());
 
  rt::RTFrame frameOutput = rt::RTFrame::FromBytes(frameBytesOutput);
 
  EXPECT_EQ(frameOutput.frameId, kOutputFrameId);
 
  wire::Reader rih(input);
  auto dstInput = rih.Fixed<macAddressLength>();
  auto srcInput = rih.Fixed<macAddressLength>();
  auto etherFrametypeInput = rih.U16();
  auto frameBytesInput = rih.ReadBytes(rih.Remaining());
 
  rt::RTFrame frameInput = rt::RTFrame::FromBytes(frameBytesInput);
 
  EXPECT_EQ(frameInput.frameId, kInputFrameId);
}
 
TEST(IoControllerAumaCyclicIo, CapturedOneSecondOpenSequenceUsesEightMillisecondCycle)
{
  constexpr std::size_t kOpenFirstPacket = 431;
  constexpr std::size_t kStopFirstPacket = 709;
  constexpr std::size_t kFirstOpenPacket = 431;
  constexpr std::size_t kLastOpenPacket = 707;
  constexpr std::int64_t kObservedMicroseconds = 999951;
 
  EXPECT_EQ(kStopFirstPacket - kFirstOpenPacket, 278U);
  EXPECT_EQ(kLastOpenPacket - kFirstOpenPacket + 1U, 277U);
  EXPECT_EQ(kObservedMicroseconds / 125000, 7); // sanity check only
  EXPECT_NE(kOpenFirstPacket, 0U);
  EXPECT_EQ(kSendClockFactor * kReductionRatio * 125U / 4U, 8000U);
}
 
} // namespace profinet