protocol.h

Go to the documentation of this file.

 
 
#pragma once
 
#include <algorithm>
#include <array>
#include <cstdint>
#include <stdexcept>
#include <string>
#include <vector>
 
#include "profinet/indices.h"
#include "profinet/util.h"
#include "profinet/wire.h"
 
namespace profinet
{
 
using Bytes = std::vector<std::uint8_t>;
 
inline constexpr int blockHeaderLenght = 6;
 
// =============================================================================
// DCP - Discovery and Configuration Protocol
// =============================================================================
 
struct EthernetHeader
{
  MacAddress dst{};
 
  MacAddress src{};
 
  std::uint16_t type = 0;
 
  Bytes payload;
 
  static EthernetHeader Parse(const Bytes& data)
  {
    const int expectedEthernetHeaderSize = 14;
    if (data.size() < expectedEthernetHeaderSize)
    {
      throw std::runtime_error("EthernetHeader: insufficient data");
    }
    wire::Reader r(data);
    EthernetHeader h;
    h.dst = r.Fixed<macAddressLength>();
    h.src = r.Fixed<macAddressLength>();
    h.type = r.U16();
    h.payload = r.ReadBytes(r.Remaining());
    return h;
  }
 
  [[nodiscard]] Bytes ToBytes() const
  {
    Bytes out;
    wire::PutFixed(out, dst);
    wire::PutFixed(out, src);
    wire::PutU16(out, type);
    out.insert(out.end(), payload.begin(), payload.end());
    return out;
  }
};
 
struct EthernetVLANHeader
{
  MacAddress dst{};
 
  MacAddress src{};
 
  std::uint16_t tPid = 0;
 
  std::uint16_t tCI = 0;
 
  std::uint16_t type = 0;
 
  Bytes payload;
 
  static EthernetVLANHeader Parse(const Bytes& data)
  {
    const int expectedEthernetVLANHeaderSize = 14;
 
    if (data.size() < expectedEthernetVLANHeaderSize)
    {
      throw std::runtime_error("EthernetVLANHeader: insufficient data");
    }
    wire::Reader r(data);
    EthernetVLANHeader h;
    h.dst = r.Fixed<macAddressLength>();
    h.src = r.Fixed<macAddressLength>();
    h.tPid = r.U16();
    h.tCI = r.U16();
    h.type = r.U16();
    h.payload = r.ReadBytes(r.Remaining());
    return h;
  }
 
  [[nodiscard]] Bytes ToBytes() const
  {
    Bytes out;
    wire::PutFixed(out, dst);
    wire::PutFixed(out, src);
    wire::PutU16(out, tPid);
    wire::PutU16(out, tCI);
    wire::PutU16(out, type);
    out.insert(out.end(), payload.begin(), payload.end());
    return out;
  }
};
 
struct PNDCPHeader
{
  // NOLINTBEGIN(readability-identifier-naming)
  static constexpr std::uint16_t ETHER_TYPE = 0x8892;
 
  static constexpr std::uint8_t GET = 3;
 
  static constexpr std::uint8_t SET = 4;
 
  static constexpr std::uint8_t IDENTIFY = 5;
 
  static constexpr std::uint8_t HELLO = 6;
 
  static constexpr std::uint8_t REQUEST = 0;
 
  static constexpr std::uint8_t RESPONSE = 1;
 
  static constexpr std::uint8_t RESPONSE_UNSUPPORTED = 5;
  // NOLINTEND(readability-identifier-naming)
 
  std::uint16_t frameId = 0;
 
  std::uint8_t serviceId = 0;
 
  std::uint8_t serviceType = 0;
 
  std::uint32_t xId = 0;
 
  std::uint16_t respDelay = 0;
 
  std::uint16_t length = 0;
 
  Bytes payload;
 
  static constexpr std::size_t kFixedSize = 12;
 
  static PNDCPHeader Parse(const Bytes& data)
  {
    if (data.size() < kFixedSize)
    {
      throw std::runtime_error("PNDCPHeader: insufficient data");
    }
    wire::Reader r(data);
    PNDCPHeader h;
    h.frameId = r.U16();
    h.serviceId = r.U8();
    h.serviceType = r.U8();
    h.xId = r.U32();
    h.respDelay = r.U16();
    h.length = r.U16();
    h.payload = r.ReadBytes(r.Remaining());
    return h;
  }
 
  [[nodiscard]] Bytes ToBytes() const
  {
    Bytes out;
    wire::PutU16(out, frameId);
    wire::PutU8(out, serviceId);
    wire::PutU8(out, serviceType);
    wire::PutU32(out, xId);
    wire::PutU16(out, respDelay);
    wire::PutU16(out, length);
    out.insert(out.end(), payload.begin(), payload.end());
    return out;
  }
};
 
struct IPConfiguration
{
  std::string address;
 
  std::string netmask;
 
  std::string gateway;
};
 
struct PNDCPBlockRequest
{
  std::uint8_t option = 0;
 
  std::uint8_t suboption = 0;
 
  std::uint16_t length = 0;
 
  Bytes payload;
 
  static constexpr std::size_t kFixedSize = 4;
 
  static PNDCPBlockRequest Parse(const Bytes& data)
  {
    if (data.size() < kFixedSize)
    {
      throw std::runtime_error("PNDCPBlockRequest: insufficient data");
    }
    wire::Reader r(data);
    PNDCPBlockRequest b;
    b.option = r.U8();
    b.suboption = r.U8();
    b.length = r.U16();
    std::size_t avail = r.Remaining();
    b.payload = r.ReadBytes(std::min<std::size_t>(b.length, avail));
    return b;
  }
 
  [[nodiscard]] Bytes ToBytes() const
  {
    Bytes out;
    wire::PutU8(out, option);
    wire::PutU8(out, suboption);
    wire::PutU16(out, length);
    out.insert(out.end(), payload.begin(), payload.end());
    return out;
  }
 
  [[nodiscard]] IPConfiguration ParseIp() const
  {
    const int defaultIPConfigurationBlockLength = 12; // 3 (ip,mask,gw) x4 = 12
    if (payload.size() < defaultIPConfigurationBlockLength)
    {
      throw std::runtime_error("PNDCPBlockRequest: short IP payload");
    }
    const int ipAddressIndex = 0;
    const int netmaskIndex = 4;
    const int gatewayIndex = 8;
    return {
        .address = String2Ip(std::span(payload).subspan<ipAddressIndex, 4>()),
        .netmask = String2Ip(std::span(payload).subspan<netmaskIndex, 4>()),
        .gateway = String2Ip(std::span(payload).subspan<gatewayIndex, 4>())};
  }
};
 
struct PNDCPBlock
{
  std::uint8_t option = 0;
 
  std::uint8_t suboption = 0;
 
  std::uint16_t length = 0;
 
  std::uint16_t status = 0;
 
  Bytes payload;
 
  // NOLINTBEGIN(readability-identifier-naming)
  static constexpr std::pair<std::uint8_t, std::uint8_t> IP_MAC{1, 1};
 
  static constexpr std::pair<std::uint8_t, std::uint8_t> IP_ADDRESS{1, 2};
 
  static constexpr std::pair<std::uint8_t, std::uint8_t> IP_FULL_SUITE{1, 3};
 
  static constexpr std::pair<std::uint8_t, std::uint8_t> DEVICE_TYPE{2, 1};
 
  static constexpr std::pair<std::uint8_t, std::uint8_t> NAME_OF_STATION{2, 2};
 
  static constexpr std::pair<std::uint8_t, std::uint8_t> DEVICE_ID{2, 3};
 
  static constexpr std::pair<std::uint8_t, std::uint8_t> DEVICE_ROLE{2, 4};
 
  static constexpr std::pair<std::uint8_t, std::uint8_t> DEVICE_OPTIONS{2, 5};
 
  static constexpr std::pair<std::uint8_t, std::uint8_t> DEVICE_ALIAS{2, 6};
 
  static constexpr std::pair<std::uint8_t, std::uint8_t> DEVICE_INSTANCE{2, 7};
 
  static constexpr std::pair<std::uint8_t, std::uint8_t> DEVICE_OEM_ID{2, 8};
 
  static constexpr std::pair<std::uint8_t, std::uint8_t> ALL{0xFF, 0xFF};
  // NOLINTEND(readability-identifier-naming)
 
  static constexpr std::size_t kFixedSize = 6;
 
  static PNDCPBlock Parse(const Bytes& data)
  {
    if (data.size() < kFixedSize)
    {
      throw std::runtime_error("PNDCPBlock: insufficient data");
    }
    wire::Reader r(data);
    PNDCPBlock b;
    b.option = r.U8();
    b.suboption = r.U8();
    b.length = r.U16();
    b.status = r.U16();
    // payload_size_field="length", payload_offset=-2: payload length is
    // `length - 2` (the 2 bytes already consumed by `status`).
    std::size_t plSize = b.length >= 2 ? static_cast<std::size_t>(b.length - 2) : 0;
    std::size_t avail = r.Remaining();
    b.payload = r.ReadBytes(std::min(plSize, avail));
    return b;
  }
 
  [[nodiscard]] Bytes ToBytes() const
  {
    Bytes out;
    wire::PutU8(out, option);
    wire::PutU8(out, suboption);
    wire::PutU16(out, length);
    wire::PutU16(out, status);
    out.insert(out.end(), payload.begin(), payload.end());
    return out;
  }
 
  [[nodiscard]] IPConfiguration ParseIp() const
  {
    const int defaultIPConfigurationBlockLength = 12; // 3 (ip,mask,gw) x4 = 12
    if (payload.size() < defaultIPConfigurationBlockLength)
    {
      throw std::runtime_error("PNDCPBlock: short IP payload");
    }
    const int ipAddressIndex = 0;
    const int netmaskIndex = 4;
    const int gatewayIndex = 8;
    return {
        .address = String2Ip(std::span(payload).subspan<ipAddressIndex, 4>()),
        .netmask = String2Ip(std::span(payload).subspan<netmaskIndex, 4>()),
        .gateway = String2Ip(std::span(payload).subspan<gatewayIndex, 4>())};
  }
};
 
// =============================================================================
// DCE/RPC - Remote Procedure Call
// =============================================================================
 
inline constexpr std::array<std::uint8_t, 12> kPnUuidSuffix = {
    0x6C, 0x97, 0x11, 0xD1, 0x82, 0x71, 0x00, 0xA0, 0x24, 0x42, 0xDF, 0x7D};
 
struct PNRPCHeader
{
  // NOLINTBEGIN(readability-identifier-naming)
  static constexpr std::uint8_t REQUEST = 0x00;
 
  static constexpr std::uint8_t PING = 0x01;
 
  static constexpr std::uint8_t RESPONSE = 0x02;
 
  static constexpr std::uint8_t FAULT = 0x03;
 
  static constexpr std::uint8_t WORKING = 0x04;
 
  static constexpr std::uint8_t PONG = 0x05;
 
  static constexpr std::uint8_t REJECT = 0x06;
 
  static constexpr std::uint8_t ACK = 0x07;
 
  static constexpr std::uint8_t CANCEL = 0x08;
 
  static constexpr std::uint8_t FRAG_ACK = 0x09;
 
  static constexpr std::uint8_t CANCEL_ACK = 0x0A;
 
  static constexpr std::uint16_t CONNECT = 0x00;
 
  static constexpr std::uint16_t RELEASE = 0x01;
 
  static constexpr std::uint16_t READ = 0x02;
 
  static constexpr std::uint16_t WRITE = 0x03;
 
  static constexpr std::uint16_t CONTROL = 0x04;
 
  static constexpr std::uint16_t IMPLICIT_READ = 0x05;
 
  // NOLINTEND(readability-identifier-naming)
 
  std::uint8_t version = 4;
 
  std::uint8_t packetType = 0;
 
  std::uint8_t flags1 = 0;
 
  std::uint8_t flags2 = 0;
 
  std::array<std::uint8_t, 3> dataRepresentation{};
 
  std::uint8_t serialNrHigh = 0;
 
  std::array<std::uint8_t, uuidLenght> objectUuid{};
 
  std::array<std::uint8_t, uuidLenght> interfaceUuid{};
 
  std::array<std::uint8_t, uuidLenght> activityUuid{};
 
  std::uint32_t serverBootTime = 0;
 
  std::uint32_t interfaceVersion = 1;
 
  std::uint32_t sequenceNumber = 0;
 
  std::uint16_t operationNumber = 0;
 
  std::uint16_t interfaceHint = 0xFFFF;
 
  std::uint16_t activityHint = 0xFFFF;
 
  std::uint16_t lengthOfBody = 0;
 
  std::uint16_t fragmentNumber = 0;
 
  std::uint8_t authenticationProtocol = 0;
 
  std::uint8_t serialNrLow = 0;
 
  Bytes payload;
 
  static constexpr std::size_t kFixedSize = 80;
 
  static std::array<std::uint8_t, uuidLenght> IfaceUuidDevice()
  {
    return PrefixedUuid(0x00, 0x01);
  }
 
  static std::array<std::uint8_t, uuidLenght> IfaceUuidController()
  {
    return PrefixedUuid(0x00, 0x02);
  }
 
  static std::array<std::uint8_t, uuidLenght> IfaceUuidSupervisor()
  {
    return PrefixedUuid(0x00, 0x03);
  }
 
  static std::array<std::uint8_t, uuidLenght> IfaceUuidParamserver()
  {
    return PrefixedUuid(0x00, 0x04);
  }
 
  static PNRPCHeader Parse(const Bytes& data)
  {
    if (data.size() < kFixedSize)
    {
      throw std::runtime_error("PNRPCHeader: insufficient data");
    }
    wire::Reader r(data);
    PNRPCHeader h;
    h.version = r.U8();
    h.packetType = r.U8();
    h.flags1 = r.U8();
    h.flags2 = r.U8();
    h.dataRepresentation = r.Fixed<3>();
    h.serialNrHigh = r.U8();
    h.objectUuid = r.Fixed<uuidLenght>();
    h.interfaceUuid = r.Fixed<uuidLenght>();
    h.activityUuid = r.Fixed<uuidLenght>();
    h.serverBootTime = r.U32();
    h.interfaceVersion = r.U32();
    h.sequenceNumber = r.U32();
    h.operationNumber = r.U16();
    h.interfaceHint = r.U16();
    h.activityHint = r.U16();
    h.lengthOfBody = r.U16();
    h.fragmentNumber = r.U16();
    h.authenticationProtocol = r.U8();
    h.serialNrLow = r.U8();
    h.payload = r.ReadBytes(r.Remaining());
    return h;
  }
 
  [[nodiscard]] Bytes ToBytes() const
  {
    Bytes out;
    wire::PutU8(out, version);
    wire::PutU8(out, packetType);
    wire::PutU8(out, flags1);
    wire::PutU8(out, flags2);
    wire::PutFixed(out, dataRepresentation);
    wire::PutU8(out, serialNrHigh);
    wire::PutFixed(out, objectUuid);
    wire::PutFixed(out, interfaceUuid);
    wire::PutFixed(out, activityUuid);
    wire::PutU32(out, serverBootTime);
    wire::PutU32(out, interfaceVersion);
    wire::PutU32(out, sequenceNumber);
    wire::PutU16(out, operationNumber);
    wire::PutU16(out, interfaceHint);
    wire::PutU16(out, activityHint);
    wire::PutU16(out, lengthOfBody);
    wire::PutU16(out, fragmentNumber);
    wire::PutU8(out, authenticationProtocol);
    wire::PutU8(out, serialNrLow);
    out.insert(out.end(), payload.begin(), payload.end());
    return out;
  }
 
 private:
  static std::array<std::uint8_t, uuidLenght> PrefixedUuid(std::uint8_t b2, std::uint8_t b3)
  {
    std::array<std::uint8_t, uuidLenght> u{};
    u[0] = 0xDE;
    u[1] = 0xA0;
    u[2] = b2;
    u[3] = b3;
    std::ranges::copy(kPnUuidSuffix, u.begin() + 4);
    return u;
  }
};
 
struct PNNRDData
{
  std::uint32_t argsMaximumStatus = 0;
 
  std::uint32_t argsLength = 0;
 
  std::uint32_t maximumCount = 0;
 
  std::uint32_t offset = 0;
 
  std::uint32_t actualCount = 0;
 
  Bytes payload;
 
  static constexpr std::size_t kFixedSize = 20;
 
  static PNNRDData Parse(const Bytes& data)
  {
    if (data.size() < kFixedSize)
    {
      throw std::runtime_error("PNNRDData: insufficient data");
    }
    wire::Reader r(data);
    PNNRDData d;
    d.argsMaximumStatus = r.U32();
    d.argsLength = r.U32();
    d.maximumCount = r.U32();
    d.offset = r.U32();
    d.actualCount = r.U32();
    // Some devices' actual_count doesn't exactly match the remaining
    // bytes (padding, etc.); take whichever is smaller, matching the
    // defensive slicing rpc.py relies on when parsing responses.
    std::size_t take = std::min<std::size_t>(d.actualCount, r.Remaining());
    d.payload = r.ReadBytes(take);
    return d;
  }
 
  [[nodiscard]] Bytes ToBytes() const
  {
    Bytes out;
    wire::PutU32(out, argsMaximumStatus);
    wire::PutU32(out, argsLength);
    wire::PutU32(out, maximumCount);
    wire::PutU32(out, offset);
    wire::PutU32(out, actualCount);
    out.insert(out.end(), payload.begin(), payload.end());
    return out;
  }
};
 
struct PNIODHeader
{
  std::array<std::uint8_t, blockHeaderLenght> blockHeader{};
 
  std::uint16_t sequenceNumber = 0;
 
  std::array<std::uint8_t, uuidLenght> arUuid{};
 
  std::uint32_t api = 0;
 
  std::uint16_t slot = 0;
 
  std::uint16_t subslot = 0;
 
  std::uint16_t padding1 = 0;
 
  std::uint16_t index = 0;
 
  std::uint32_t length = 0;
 
  std::array<std::uint8_t, uuidLenght> targetArUuid{};
 
  std::array<std::uint8_t, 8> padding2{};
 
  Bytes payload;
 
  static constexpr std::size_t kFixedSize = 64;
 
  static PNIODHeader Parse(const Bytes& data)
  {
    if (data.size() < kFixedSize)
    {
      throw std::runtime_error("PNIODHeader: insufficient data");
    }
    wire::Reader r(data);
    PNIODHeader h;
    h.blockHeader = r.Fixed<blockHeaderLenght>();
    h.sequenceNumber = r.U16();
    h.arUuid = r.Fixed<uuidLenght>();
    h.api = r.U32();
    h.slot = r.U16();
    h.subslot = r.U16();
    h.padding1 = r.U16();
    h.index = r.U16();
    h.length = r.U32();
    h.targetArUuid = r.Fixed<uuidLenght>();
    h.padding2 = r.Fixed<8>();
    h.payload = r.ReadBytes(r.Remaining());
    return h;
  }
 
  [[nodiscard]] Bytes ToBytes() const
  {
    Bytes out;
    wire::PutFixed(out, blockHeader);
    wire::PutU16(out, sequenceNumber);
    wire::PutFixed(out, arUuid);
    wire::PutU32(out, api);
    wire::PutU16(out, slot);
    wire::PutU16(out, subslot);
    wire::PutU16(out, padding1);
    wire::PutU16(out, index);
    wire::PutU32(out, length);
    wire::PutFixed(out, targetArUuid);
    wire::PutFixed(out, padding2);
    out.insert(out.end(), payload.begin(), payload.end());
    return out;
  }
};
 
struct PNBlockHeader
{
  // NOLINTBEGIN(readability-identifier-naming)
  static constexpr BlockType IODReadRequestHeader = BlockType::IoDataReadRequest; // 0x0009;
 
  static constexpr std::uint16_t IODReadResponseHeader = 0x8009;
 
  static constexpr std::uint16_t InM0 = 0x0020;
 
  static constexpr std::uint16_t InM0FilterDataSubModul = 0x0030;
 
  static constexpr std::uint16_t InM0FilterDataModul = 0x0031;
 
  static constexpr std::uint16_t InM0FilterDataDevice = 0x0032;
 
  static constexpr std::uint16_t DEFAULT_BLOCK_LENGTH = 60;
  // NOLINTEND(readability-identifier-naming)
 
  BlockType blockType = BlockType::Unknown;
 
  std::uint16_t blockLength = 0;
 
  std::uint8_t blockVersionHigh = 1;
 
  std::uint8_t blockVersionLow = 0;
 
  static constexpr std::size_t kSize = 6;
 
  static PNBlockHeader Parse(const Bytes& data)
  {
    if (data.size() < kSize)
    {
      throw std::runtime_error("PNBlockHeader: insufficient data");
    }
    wire::Reader r(data);
    PNBlockHeader h;
    h.blockType = static_cast<BlockType>(r.U16());
    h.blockLength = r.U16();
    h.blockVersionHigh = r.U8();
    h.blockVersionLow = r.U8();
    return h;
  }
 
  [[nodiscard]] Bytes ToBytes() const
  {
    Bytes out;
    wire::PutU16(out, static_cast<std::uint16_t>(blockType));
    wire::PutU16(out, blockLength);
    wire::PutU8(out, blockVersionHigh);
    wire::PutU8(out, blockVersionLow);
    return out;
  }
};
 
struct PNARBlockRequest
{
  std::array<std::uint8_t, blockHeaderLenght> blockHeader{};
 
  std::uint16_t arType = 0;
 
  std::array<std::uint8_t, uuidLenght> arUuid{};
 
  std::uint16_t sessionKey = 0;
 
  MacAddress cmInitiatorMacAddress{};
 
  std::array<std::uint8_t, uuidLenght> cmInitiatorObjectUuid{};
 
  std::uint32_t arProperties = 0;
 
  std::uint16_t cmInitiatorActivityTimeoutFactor = 0;
 
  std::uint16_t initiatorUdpRtport = 0;
 
  std::uint16_t stationNameLength = 0;
 
  Bytes cmInitiatorStationName;
 
  Bytes payload;
 
  static constexpr std::size_t kFixedSize = 58;
 
  static PNARBlockRequest Parse(const Bytes& data)
  {
    if (data.size() < kFixedSize)
    {
      throw std::runtime_error("PNARBlockRequest: insufficient data");
    }
    wire::Reader r(data);
    PNARBlockRequest b;
    b.blockHeader = r.Fixed<blockHeaderLenght>();
    b.arType = r.U16();
    b.arUuid = r.Fixed<uuidLenght>();
    b.sessionKey = r.U16();
    b.cmInitiatorMacAddress = r.Fixed<macAddressLength>();
    b.cmInitiatorObjectUuid = r.Fixed<uuidLenght>();
    b.arProperties = r.U32();
    b.cmInitiatorActivityTimeoutFactor = r.U16();
    b.initiatorUdpRtport = r.U16();
    b.stationNameLength = r.U16();
    b.cmInitiatorStationName = r.ReadBytes(std::min<std::size_t>(b.stationNameLength, r.Remaining()));
    b.payload = r.ReadBytes(r.Remaining());
    return b;
  }
 
  [[nodiscard]] Bytes ToBytes() const
  {
    Bytes out;
    wire::PutFixed(out, blockHeader);
    wire::PutU16(out, arType);
    wire::PutFixed(out, arUuid);
    wire::PutU16(out, sessionKey);
    wire::PutFixed(out, cmInitiatorMacAddress);
    wire::PutFixed(out, cmInitiatorObjectUuid);
    wire::PutU32(out, arProperties);
    wire::PutU16(out, cmInitiatorActivityTimeoutFactor);
    wire::PutU16(out, initiatorUdpRtport);
    wire::PutU16(out, stationNameLength);
    out.insert(out.end(), cmInitiatorStationName.begin(), cmInitiatorStationName.end());
    out.insert(out.end(), payload.begin(), payload.end());
    return out;
  }
};
 
struct PNIODReleaseBlock
{
  std::array<std::uint8_t, blockHeaderLenght> blockHeader{};
 
  std::uint16_t padding1 = 0;
 
  std::array<std::uint8_t, uuidLenght> arUuid{};
 
  std::uint16_t sessionKey = 0;
 
  std::uint16_t padding2 = 0;
 
  ControlCommand controlCommand = ControlCommand::Unknown;
 
  std::uint16_t controlBlockProperties = 0;
 
  static constexpr std::size_t kSize = 32;
 
  static PNIODReleaseBlock Parse(const Bytes& data)
  {
    if (data.size() < kSize)
    {
      throw std::runtime_error("PNIODReleaseBlock: insufficient data");
    }
    wire::Reader r(data);
    PNIODReleaseBlock b;
    b.blockHeader = r.Fixed<blockHeaderLenght>();
    b.padding1 = r.U16();
    b.arUuid = r.Fixed<uuidLenght>();
    b.sessionKey = r.U16();
    b.padding2 = r.U16();
    b.controlCommand = static_cast<ControlCommand>(r.U16());
    b.controlBlockProperties = r.U16();
    return b;
  }
 
  [[nodiscard]] Bytes ToBytes() const
  {
    Bytes out;
    wire::PutFixed(out, blockHeader);
    wire::PutU16(out, padding1);
    wire::PutFixed(out, arUuid);
    wire::PutU16(out, sessionKey);
    wire::PutU16(out, padding2);
    wire::PutU16(out, static_cast<std::uint16_t>(controlCommand));
    wire::PutU16(out, controlBlockProperties);
    return out;
  }
};
 
// =============================================================================
// I&M (Identification & Maintenance) Data
// =============================================================================
 
struct PNInM0
{
  // NOLINTBEGIN(readability-identifier-naming)
  static constexpr std::uint16_t IDX = 0xAFF0;
  // NOLINTEND(readability-identifier-naming)
 
  std::array<std::uint8_t, blockHeaderLenght> blockHeader{};
 
  std::uint8_t vendorIdHigh = 0;
 
  std::uint8_t vendorIdLow = 0;
 
  std::string orderId;
 
  std::string imSerialNumber;
 
  std::uint16_t imHardwareRevision = 0;
 
  std::uint8_t swRevisionPrefix = 0;
 
  std::uint8_t imSwRevisionFunctionalEnhancement = 0;
 
  std::uint8_t imSwRevisionBugFix = 0;
 
  std::uint8_t imSwRevisionInternalChange = 0;
 
  std::uint16_t imRevisionCounter = 0;
 
  std::uint16_t imProfileId = 0;
 
  std::uint16_t imProfileSpecificType = 0;
 
  std::uint16_t imVersion = 0;
 
  std::uint16_t imSupported = 0;
 
  static constexpr std::size_t kSize = 60;
 
  [[nodiscard]] std::uint16_t VendorId() const
  {
    return static_cast<std::uint16_t>((vendorIdHigh << OneOctetShift) | vendorIdLow);
  }
 
  static PNInM0 Parse(const Bytes& data)
  {
    if (data.size() < kSize)
    {
      throw std::runtime_error("PNInM0: insufficient data");
    }
    wire::Reader r(data);
    PNInM0 v;
    v.blockHeader = r.Fixed<blockHeaderLenght>();
    v.vendorIdHigh = r.U8();
    v.vendorIdLow = r.U8();
    auto oid = r.ReadBytes(20);
    v.orderId = DecodeBytes(oid);
    auto sn = r.ReadBytes(16);
    v.imSerialNumber = DecodeBytes(sn);
    v.imHardwareRevision = r.U16();
    v.swRevisionPrefix = r.U8();
    v.imSwRevisionFunctionalEnhancement = r.U8();
    v.imSwRevisionBugFix = r.U8();
    v.imSwRevisionInternalChange = r.U8();
    v.imRevisionCounter = r.U16();
    v.imProfileId = r.U16();
    v.imProfileSpecificType = r.U16();
    v.imVersion = r.U16();
    v.imSupported = r.U16();
    return v;
  }
 
  bool operator==(const PNInM0&) const = default;
};
 
struct PNInM1
{
  // NOLINTBEGIN(readability-identifier-naming)
  static constexpr std::uint16_t IDX = 0xAFF1;
  // NOLINTEND(readability-identifier-naming)
 
  std::array<std::uint8_t, blockHeaderLenght> blockHeader{};
 
  std::string imTagFunction;
 
  std::string imTagLocation;
 
  static constexpr std::size_t kSize = 60;
 
  static PNInM1 Parse(const Bytes& data)
  {
    if (data.size() < kSize)
    {
      throw std::runtime_error("PNInM1: insufficient data");
    }
    wire::Reader r(data);
    PNInM1 v;
    v.blockHeader = r.Fixed<blockHeaderLenght>();
    v.imTagFunction = DecodeBytes(r.ReadBytes(32));
    v.imTagLocation = DecodeBytes(r.ReadBytes(22));
    return v;
  }
  bool operator==(const PNInM1&) const = default;
};
 
struct PNInM2
{
  // NOLINTBEGIN(readability-identifier-naming)
  static constexpr std::uint16_t IDX = 0xAFF2;
  // NOLINTEND(readability-identifier-naming)
 
  std::array<std::uint8_t, blockHeaderLenght> blockHeader{};
 
  std::string imDate;
 
  static constexpr std::size_t kSize = 22;
 
  static PNInM2 Parse(const Bytes& data)
  {
    if (data.size() < kSize)
    {
      throw std::runtime_error("PNInM2: insufficient data");
    }
    wire::Reader r(data);
    PNInM2 v;
    v.blockHeader = r.Fixed<blockHeaderLenght>();
    v.imDate = DecodeBytes(r.ReadBytes(16));
    return v;
  }
 
  bool operator==(const PNInM2&) const = default;
};
 
struct PNInM3
{
  // NOLINTBEGIN(readability-identifier-naming)
  static constexpr std::uint16_t IDX = 0xAFF3;
  // NOLINTEND(readability-identifier-naming)
 
  std::array<std::uint8_t, blockHeaderLenght> blockHeader{};
 
  std::string imDescriptor;
 
  static constexpr std::size_t kSize = 60;
 
  static PNInM3 Parse(const Bytes& data)
  {
    if (data.size() < kSize)
    {
      throw std::runtime_error("PNInM3: insufficient data");
    }
    wire::Reader r(data);
    PNInM3 v;
    v.blockHeader = r.Fixed<blockHeaderLenght>();
    v.imDescriptor = DecodeBytes(r.ReadBytes(54));
    return v;
  }
  bool operator==(const PNInM3&) const = default;
};
 
struct PNInM4
{
  // NOLINTBEGIN(readability-identifier-naming)
  static constexpr std::uint16_t IDX = 0xAFF4;
  // NOLINTEND(readability-identifier-naming)
 
  std::array<std::uint8_t, blockHeaderLenght> blockHeader{};
 
  std::array<std::uint8_t, 54> imSignature{};
 
  static constexpr std::size_t kSize = 60;
 
  static PNInM4 Parse(const Bytes& data)
  {
    if (data.size() < kSize)
    {
      throw std::runtime_error("PNInM4: insufficient data");
    }
    wire::Reader r(data);
    PNInM4 v;
    v.blockHeader = r.Fixed<blockHeaderLenght>();
    v.imSignature = r.Fixed<54>();
    return v;
  }
  bool operator==(const PNInM4&) const = default;
};
 
struct PNInM5
{
  // NOLINTBEGIN(readability-identifier-naming)
  static constexpr std::uint16_t IDX = 0xAFF5;
  // NOLINTEND(readability-identifier-naming)
 
  std::array<std::uint8_t, blockHeaderLenght> blockHeader{};
 
  std::string imAnnotation;
 
  static constexpr std::size_t kSize = 70;
 
  static PNInM5 Parse(const Bytes& data)
  {
    if (data.size() < kSize)
    {
      throw std::runtime_error("PNInM5: insufficient data");
    }
    wire::Reader r(data);
    PNInM5 v;
    v.blockHeader = r.Fixed<blockHeaderLenght>();
    v.imAnnotation = DecodeBytes(r.ReadBytes(64));
    return v;
  }
  bool operator==(const PNInM5&) const = default;
};
 
template <std::uint16_t Idx>
struct PNInMReserved
{
  // NOLINTBEGIN(readability-identifier-naming)
  static constexpr std::uint16_t IDX = Idx;
  // NOLINTEND(readability-identifier-naming)
 
  std::array<std::uint8_t, blockHeaderLenght> blockHeader{};
 
  Bytes payload;
 
  static PNInMReserved Parse(const Bytes& data)
  {
    if (data.size() < 6)
    {
      throw std::runtime_error("PNInMReserved: insufficient data");
    }
    wire::Reader r(data);
    PNInMReserved v;
    v.blockHeader = r.Fixed<blockHeaderLenght>();
    v.payload = r.ReadBytes(r.Remaining());
    return v;
  }
 
  bool operator==(const PNInMReserved&) const = default;
};
 
using PNInM6 = PNInMReserved<0xAFF6>;
using PNInM7 = PNInMReserved<0xAFF7>;
using PNInM8 = PNInMReserved<0xAFF8>;
using PNInM9 = PNInMReserved<0xAFF9>;
using PNInM10 = PNInMReserved<0xAFFA>;
using PNInM11 = PNInMReserved<0xAFFB>;
using PNInM12 = PNInMReserved<0xAFFC>;
using PNInM13 = PNInMReserved<0xAFFD>;
using PNInM14 = PNInMReserved<0xAFFE>;
using PNInM15 = PNInMReserved<0xAFFF>;
 
// =============================================================================
// IOCR (IO Connection Relationship) Blocks
// =============================================================================
 
struct IOCRAPIObject
{
  std::uint16_t slotNumber = 0;
 
  std::uint16_t subslotNumber = 0;
 
  std::uint16_t frameOffset = 0;
 
  static constexpr std::size_t kSize = 6;
 
  static IOCRAPIObject Parse(const Bytes& data)
  {
    if (data.size() < kSize)
    {
      throw std::runtime_error("IOCRAPIObject: insufficient data");
    }
    wire::Reader r(data);
    IOCRAPIObject o;
    o.slotNumber = r.U16();
    o.subslotNumber = r.U16();
    o.frameOffset = r.U16();
    return o;
  }
 
  [[nodiscard]] Bytes ToBytes() const
  {
    Bytes out;
    wire::PutU16(out, slotNumber);
    wire::PutU16(out, subslotNumber);
    wire::PutU16(out, frameOffset);
    return out;
  }
};
 
struct PNIOCRBlockRes
{
  // NOLINTBEGIN(readability-identifier-naming)
  static constexpr std::uint16_t BLOCK_TYPE = 0x8102;
  // NOLINTEND(readability-identifier-naming)
 
  std::array<std::uint8_t, blockHeaderLenght> blockHeader{};
 
  std::uint16_t iocrType = 0;
 
  std::uint16_t iocrReference = 0;
 
  std::uint16_t frameId = 0;
 
  static constexpr std::size_t kSize = 12;
 
  static PNIOCRBlockRes Parse(const Bytes& data)
  {
    if (data.size() < kSize)
    {
      throw std::runtime_error("PNIOCRBlockRes: insufficient data");
    }
    wire::Reader r(data);
    PNIOCRBlockRes b;
    b.blockHeader = r.Fixed<blockHeaderLenght>();
    b.iocrType = r.U16();
    b.iocrReference = r.U16();
    b.frameId = r.U16();
    return b;
  }
};
 
struct PNIOCRBlockReqHeader
{
  // NOLINTBEGIN(readability-identifier-naming)
  static constexpr BlockType BLOCK_TYPE = BlockType::IoCrRequest;
  // NOLINTEND(readability-identifier-naming)
 
  std::array<std::uint8_t, blockHeaderLenght> blockHeader{};
 
  std::uint16_t iocrType = 0;
 
  std::uint16_t iocrReference = 0;
 
  std::uint16_t etherTypeLT = PROFINET_ETHERTYPE;
 
  std::uint32_t iocrProperties = 0;
 
  std::uint16_t dataLength = 0;
 
  std::uint16_t frameId = 0;
 
  std::uint16_t sendClockFactor = 32;
 
  std::uint16_t reductionRatio = 1;
 
  std::uint16_t phase = 1;
 
  std::uint16_t sequence = 0;
 
  std::uint32_t frameSendOffset = 0;
 
  std::uint16_t watchdogFactor = 3;
 
  std::uint16_t dataHoldFactor = 3;
 
  std::uint16_t iocrTagHeader = 0xC000;
 
  MacAddress iocrMulticastMac{};
 
  std::uint16_t numberOfApis = 1;
 
  static constexpr std::size_t kSize = 46;
 
  [[nodiscard]] static PNIOCRBlockReqHeader Parse(const Bytes& data)
  {
    if (data.size() < kSize)
    {
      throw std::runtime_error(
          "IOCRBlockReq too short, insufficient data: " +
          std::to_string(data.size()) +
          " bytes, expected at least " +
          std::to_string(kSize));
    }
 
    wire::Reader r(data);
    PNIOCRBlockReqHeader b;
 
    b.blockHeader = r.Fixed<blockHeaderLenght>();
    b.iocrType = r.U16();
    b.iocrReference = r.U16();
    b.etherTypeLT = r.U16();
    b.iocrProperties = r.U32();
    b.dataLength = r.U16();
    b.frameId = r.U16();
    b.sendClockFactor = r.U16();
    b.reductionRatio = r.U16();
    b.phase = r.U16();
    b.sequence = r.U16();
    b.frameSendOffset = r.U32();
    b.watchdogFactor = r.U16();
    b.dataHoldFactor = r.U16();
    b.iocrTagHeader = r.U16();
    b.iocrMulticastMac = r.Fixed<macAddressLength>();
    b.numberOfApis = r.U16();
 
    return b;
  }
 
  [[nodiscard]] Bytes ToBytes() const
  {
    Bytes out;
    wire::PutFixed(out, blockHeader);
    wire::PutU16(out, iocrType);
    wire::PutU16(out, iocrReference);
    wire::PutU16(out, etherTypeLT);
    wire::PutU32(out, iocrProperties);
    wire::PutU16(out, dataLength);
    wire::PutU16(out, frameId);
    wire::PutU16(out, sendClockFactor);
    wire::PutU16(out, reductionRatio);
    wire::PutU16(out, phase);
    wire::PutU16(out, sequence);
    wire::PutU32(out, frameSendOffset);
    wire::PutU16(out, watchdogFactor);
    wire::PutU16(out, dataHoldFactor);
    wire::PutU16(out, iocrTagHeader);
    wire::PutFixed(out, iocrMulticastMac);
    wire::PutU16(out, numberOfApis);
    return out;
  }
};
 
// =============================================================================
// AlarmCR (Alarm Connection Relationship) Blocks
// =============================================================================
 
struct PNAlarmCRBlockReq
{
  // NOLINTBEGIN(readability-identifier-naming)
  static constexpr BlockType BLOCK_TYPE = BlockType::AlarmCrRequest;
 
  static constexpr std::uint16_t DEFAULT_RTA_TIMEOUT_FACTOR = 1;
 
  static constexpr std::uint16_t DEFAULT_RTA_RETRIES = 3;
 
  static constexpr std::uint16_t DEFAULT_MAX_ALARM_DATA_LENGTH = 200;
 
  static constexpr std::uint16_t DEFAULT_TAG_HEADER_HIGH = 0xC000;
 
  static constexpr std::uint16_t DEFAULT_TAG_HEADER_LOW = 0xA000;
  // NOLINTEND(readability-identifier-naming)
 
  std::array<std::uint8_t, blockHeaderLenght> blockHeader{};
 
  std::uint16_t alarmCrType = 1;
 
  std::uint16_t etherTypeLT = 0x8892;
 
  std::uint32_t alarmCrProperties = 0;
 
  std::uint16_t rtaTimeoutFactor = DEFAULT_RTA_TIMEOUT_FACTOR;
 
  std::uint16_t rtaRetries = DEFAULT_RTA_RETRIES;
 
  std::uint16_t localAlarmReference = 0;
 
  std::uint16_t maxAlarmDataLength = DEFAULT_MAX_ALARM_DATA_LENGTH;
 
  std::uint16_t alarmCrTagHeaderHigh = DEFAULT_TAG_HEADER_HIGH;
 
  std::uint16_t alarmCrTagHeaderLow = DEFAULT_TAG_HEADER_LOW;
 
  static constexpr std::size_t kSize = 26;
 
  [[nodiscard]] Bytes ToBytes() const
  {
    Bytes out;
    wire::PutFixed(out, blockHeader);
    wire::PutU16(out, alarmCrType);
    wire::PutU16(out, etherTypeLT);
    wire::PutU32(out, alarmCrProperties);
    wire::PutU16(out, rtaTimeoutFactor);
    wire::PutU16(out, rtaRetries);
    wire::PutU16(out, localAlarmReference);
    wire::PutU16(out, maxAlarmDataLength);
    wire::PutU16(out, alarmCrTagHeaderHigh);
    wire::PutU16(out, alarmCrTagHeaderLow);
    return out;
  }
};
 
struct PNAlarmCRBlockRes
{
  // NOLINTBEGIN(readability-identifier-naming)
  static constexpr std::uint16_t BLOCK_TYPE = 0x8103;
  // NOLINTEND(readability-identifier-naming)
 
  std::array<std::uint8_t, blockHeaderLenght> blockHeader{};
 
  std::uint16_t alarmCrType = 0;
 
  std::uint16_t localAlarmReference = 0;
 
  std::uint16_t maxAlarmDataLength = 0;
 
  static constexpr std::size_t kSize = 12;
 
  static PNAlarmCRBlockRes Parse(const Bytes& data)
  {
    if (data.size() < kSize)
    {
      throw std::runtime_error("PNAlarmCRBlockRes: insufficient data");
    }
    wire::Reader r(data);
    PNAlarmCRBlockRes b;
    b.blockHeader = r.Fixed<blockHeaderLenght>();
    b.alarmCrType = r.U16();
    b.localAlarmReference = r.U16();
    b.maxAlarmDataLength = r.U16();
    return b;
  }
};
 
// =============================================================================
// Alarm Notification PDUs
// =============================================================================
 
struct PNAlarmNotificationPDU
{
  // NOLINTBEGIN(readability-identifier-naming)
  static constexpr std::uint16_t BLOCK_ALARM_HIGH = 0x0001;
 
  static constexpr std::uint16_t BLOCK_ALARM_LOW = 0x0002;
 
  static constexpr std::uint16_t BLOCK_ALARM_ACK_HIGH = 0x8001;
 
  static constexpr std::uint16_t BLOCK_ALARM_ACK_LOW = 0x8002;
  // NOLINTEND(readability-identifier-naming)
 
  std::array<std::uint8_t, blockHeaderLenght> blockHeader{};
 
  std::uint16_t alarmType = 0;
 
  std::uint32_t api = 0;
 
  std::uint16_t slotNumber = 0;
 
  std::uint16_t subslotNumber = 0;
 
  std::uint32_t moduleIdentNumber = 0;
 
  std::uint32_t submoduleIdentNumber = 0;
 
  std::uint16_t alarmSpecifier = 0;
 
  Bytes payload;
 
  static constexpr std::size_t kFixedSize = 26;
 
  static PNAlarmNotificationPDU Parse(const Bytes& data)
  {
    if (data.size() < kFixedSize)
    {
      throw std::runtime_error("PNAlarmNotificationPDU: insufficient data");
    }
    wire::Reader r(data);
    PNAlarmNotificationPDU p;
    p.blockHeader = r.Fixed<blockHeaderLenght>();
    p.alarmType = r.U16();
    p.api = r.U32();
    p.slotNumber = r.U16();
    p.subslotNumber = r.U16();
    p.moduleIdentNumber = r.U32();
    p.submoduleIdentNumber = r.U32();
    p.alarmSpecifier = r.U16();
    p.payload = r.ReadBytes(r.Remaining());
    return p;
  }
};
 
struct PNAlarmAckPDU
{
  std::array<std::uint8_t, blockHeaderLenght> blockHeader{};
 
  AlarmType alarmType = AlarmType::Unknown;
 
  std::uint32_t api = 0;
 
  std::uint16_t slotNumber = 0;
 
  std::uint16_t subslotNumber = 0;
 
  std::uint16_t alarmSpecifier = 0;
 
  std::uint32_t statusPNIO = 0;
 
  static constexpr std::size_t kSize = 22;
 
  [[nodiscard]] Bytes ToBytes() const
  {
    Bytes out;
    wire::PutFixed(out, blockHeader);
    wire::PutU16(out, static_cast<std::uint16_t>(alarmType));
    wire::PutU32(out, api);
    wire::PutU16(out, slotNumber);
    wire::PutU16(out, subslotNumber);
    wire::PutU16(out, alarmSpecifier);
    wire::PutU32(out, statusPNIO);
    return out;
  }
};
 
struct PNRTAHeader
{
  // NOLINTBEGIN(readability-identifier-naming)
  static constexpr std::uint8_t RTA_TYPE_DATA = 0x01;
 
  static constexpr std::uint8_t RTA_TYPE_NACK = 0x02;
 
  static constexpr std::uint8_t RTA_TYPE_ACK = 0x03;
 
  static constexpr std::uint8_t RTA_TYPE_ERR = 0x04;
 
  static constexpr std::uint8_t VERSION_1 = 0x01;
 
  static constexpr std::uint8_t VERSION_2 = 0x02;
 
  static constexpr std::uint8_t ADD_FLAGS_WINDOW_1 = 0x01;
 
  static constexpr std::uint8_t ADD_FLAGS_TACK = 0x10;
 
  // NOLINTEND(readability-identifier-naming)
 
  std::uint16_t alarmDstEndpoint = 0;
 
  std::uint16_t alarmSrcEndpoint = 0;
 
  std::uint8_t pduType = 0;
 
  std::uint8_t addFlags = 0;
 
  std::uint16_t sendSeqNum = 0;
 
  std::uint16_t ackSeqNum = 0;
 
  std::uint16_t variablePartLenght = 0;
 
  Bytes payload;
 
  static constexpr std::size_t kFixedSize = 12;
 
  static PNRTAHeader Parse(const Bytes& data)
  {
    if (data.size() < kFixedSize)
    {
      throw std::runtime_error("PNRTAHeader: insufficient data");
    }
    wire::Reader r(data);
    PNRTAHeader h;
    h.alarmDstEndpoint = r.U16();
    h.alarmSrcEndpoint = r.U16();
    h.pduType = r.U8();
    h.addFlags = r.U8();
    h.sendSeqNum = r.U16();
    h.ackSeqNum = r.U16();
    h.variablePartLenght = r.U16();
    h.payload = r.ReadBytes(r.Remaining());
    return h;
  }
 
  [[nodiscard]] Bytes ToBytes() const
  {
    Bytes out;
    wire::PutU16(out, alarmDstEndpoint);
    wire::PutU16(out, alarmSrcEndpoint);
    wire::PutU8(out, pduType);
    wire::PutU8(out, addFlags);
    wire::PutU16(out, sendSeqNum);
    wire::PutU16(out, ackSeqNum);
    wire::PutU16(out, variablePartLenght);
    out.insert(out.end(), payload.begin(), payload.end());
    return out;
  }
};
 
// =============================================================================
// ExpectedSubmodule Blocks (0x0104)
// =============================================================================
 
struct PNExpectedSubmoduleDataDescription
{
  std::uint16_t dataDescription = 0;
 
  std::uint16_t submoduleDataLength = 0;
 
  std::uint8_t lengthIocs = 0;
 
  std::uint8_t lengthIops = 0;
 
  static constexpr std::size_t kSize = 6;
 
  [[nodiscard]] Bytes ToBytes() const
  {
    Bytes out;
    wire::PutU16(out, dataDescription);
    wire::PutU16(out, submoduleDataLength);
    wire::PutU8(out, lengthIocs);
    wire::PutU8(out, lengthIops);
    return out;
  }
};
 
// =============================================================================
// IOD Write/Read Request Blocks
// =============================================================================
 
struct PNIODWriteReq
{
  // NOLINTBEGIN(readability-identifier-naming)
  static constexpr std::uint16_t BLOCK_TYPE = 0x0008;
  // NOLINTEND(readability-identifier-naming)
 
  std::array<std::uint8_t, blockHeaderLenght> blockHeader{};
 
  std::uint16_t seqNum = 0;
 
  std::array<std::uint8_t, uuidLenght> arUuid{};
 
  std::uint32_t api = 0;
 
  std::uint16_t slot = 0;
 
  std::uint16_t subslot = 0;
 
  std::uint16_t padding = 0;
 
  std::uint16_t index = 0;
 
  std::uint32_t recordDataLength = 0;
 
  std::array<std::uint8_t, 24> rwPadding{};
 
  Bytes payload;
 
  static constexpr std::size_t kFixedSize = 64;
 
  [[nodiscard]] Bytes ToBytes() const
  {
    Bytes out;
    wire::PutFixed(out, blockHeader);
    wire::PutU16(out, seqNum);
    wire::PutFixed(out, arUuid);
    wire::PutU32(out, api);
    wire::PutU16(out, slot);
    wire::PutU16(out, subslot);
    wire::PutU16(out, padding);
    wire::PutU16(out, index);
    wire::PutU32(out, recordDataLength);
    wire::PutFixed(out, rwPadding);
    out.insert(out.end(), payload.begin(), payload.end());
    return out;
  }
};
 
struct PNIODWriteRes
{
  // NOLINTBEGIN(readability-identifier-naming)
  static constexpr std::uint16_t BLOCK_TYPE = 0x8008;
  // NOLINTEND(readability-identifier-naming)
 
  std::array<std::uint8_t, blockHeaderLenght> blockHeader{};
 
  std::uint16_t seqNum = 0;
 
  std::array<std::uint8_t, uuidLenght> arUuid{};
 
  std::uint32_t api = 0;
 
  std::uint16_t slot = 0;
 
  std::uint16_t subslot = 0;
 
  std::uint16_t padding = 0;
 
  std::uint16_t index = 0;
 
  std::uint32_t recordDataLength = 0;
 
  std::uint16_t additionalValue1 = 0;
 
  std::uint16_t additionalValue2 = 0;
 
  std::uint32_t status = 0;
 
  std::array<std::uint8_t, 16> rwPadding{};
 
  static constexpr std::size_t kSize = 64;
 
  static PNIODWriteRes Parse(const Bytes& data)
  {
    if (data.size() < kSize)
    {
      throw std::runtime_error("PNIODWriteRes: insufficient data");
    }
    wire::Reader r(data);
    PNIODWriteRes b;
    b.blockHeader = r.Fixed<blockHeaderLenght>();
    b.seqNum = r.U16();
    b.arUuid = r.Fixed<uuidLenght>();
    b.api = r.U32();
    b.slot = r.U16();
    b.subslot = r.U16();
    b.padding = r.U16();
    b.index = r.U16();
    b.recordDataLength = r.U32();
    b.additionalValue1 = r.U16();
    b.additionalValue2 = r.U16();
    b.status = r.U32();
    b.rwPadding = r.Fixed<16>();
    return b;
  }
};
 
} // namespace profinet