rt.h

Go to the documentation of this file.

 
 
#pragma once
 
#include <cstdint>
#include <mutex>
#include <optional>
#include <string>
#include <vector>
 
#include "profinet/protocol.h"
#include "profinet/util.h"
 
namespace profinet::rt
{
 
// NOLINTBEGIN(readability-identifier-naming)
inline constexpr std::uint16_t ETHERTYPE_PROFINET = 0x8892;
inline constexpr std::uint16_t ETHERTYPE_VLAN = 0x8100;
inline constexpr std::uint16_t ETHERTYPE_VLAN_AD = 0x88A8;
inline constexpr std::uint16_t ETHERTYPE_VLAN_LEGACY = 0x9100;
/* Dit is oud en niet complient met std... denk ik
inline constexpr std::uint16_t FRAME_ID_RT_CLASS_1_MIN = 0x8000;
inline constexpr std::uint16_t FRAME_ID_RT_CLASS_1_MAX = 0xFBFF;
*/
// RTC1 (legacy RT_CLASS_1) cyclic frame ID range per IEC 61158-6-10;
// 0x8000-0xBFFF is a separate range (RT_CLASS_2 in pre-V2.3 spec naming)
inline constexpr std::uint16_t FRAME_ID_RT_CLASS_1_MIN = 0xC000;
inline constexpr std::uint16_t FRAME_ID_RT_CLASS_1_MAX = 0xF7FF;
 
inline constexpr std::uint16_t VLAN_TAG_RT = 0x8100C000;
 
inline constexpr std::uint16_t FRAME_ID_ALARM_HIGH = 0xFC01;
inline constexpr std::uint16_t FRAME_ID_ALARM_LOW = 0xFE01;
 
inline constexpr std::uint16_t IOCR_TYPE_INPUT = 1;
inline constexpr std::uint16_t IOCR_TYPE_OUTPUT = 2;
 
inline constexpr std::uint8_t RT_CLASS_1 = 0x01;
inline constexpr std::uint8_t RT_CLASS_2 = 0x02;
inline constexpr std::uint8_t RT_CLASS_3 = 0x03;
 
// DataStatus bit definitions
inline constexpr std::uint8_t DATA_STATUS_STATE = 0x01;
inline constexpr std::uint8_t DATA_STATUS_REDUNDANCY = 0x02;
inline constexpr std::uint8_t DATA_STATUS_VALID = 0x04;
inline constexpr std::uint8_t DATA_STATUS_RESERVED = 0x08;
inline constexpr std::uint8_t DATA_STATUS_PROVIDER_RUN = 0x10;
inline constexpr std::uint8_t DATA_STATUS_STATION_OK = 0x20;
inline constexpr std::uint8_t DATA_STATUS_IGNORE = 0x80;
 
// IOxS (Provider/Consumer Status) values
inline constexpr std::uint8_t IOXS_GOOD = 0x80;
 
inline constexpr std::uint8_t IOXS_DATA_STATE_GOOD = 0x80;
inline constexpr std::uint8_t IOXS_BAD = 0x00;
inline constexpr std::uint8_t IOXS_EXTENSION = 0x01;
// NOLINTEND(readability-identifier-naming)
 
struct IODataObject
{
  std::uint16_t slot = 0;
 
  std::uint16_t subslot = 0;
 
  std::uint16_t frameOffset = 0;
 
  std::uint16_t dataLength = 0;
 
  std::optional<std::uint16_t> offsetIOPS;
 
  std::optional<std::uint16_t> offsetIOCS;
 
  void Validate(std::size_t frameSize) const;
};
 
struct IOCRConfig
{
  std::uint16_t typeIOCR = 0;
 
  std::uint16_t referenceIOCR = 0;
 
  std::uint16_t frameId = 0;
 
  std::uint16_t sendClockFactor = 32;
 
  std::uint16_t reductionRatio = 32;
 
  std::uint16_t phase = 0;
 
  std::uint16_t watchdogFactor = 3;
 
  std::uint16_t dataLength = 40;
 
  std::vector<IODataObject> objects;
 
  [[nodiscard]] std::uint32_t CycleTimeUs() const
  {
    return static_cast<std::uint32_t>(reductionRatio) * sendClockFactor * 125 / 4;
  }
 
  [[nodiscard]] double CycleTimeMs() const
  {
    return CycleTimeUs() / 1000.0;
  }
 
  [[nodiscard]] std::uint32_t WatchdogTimeUs() const
  {
    return static_cast<std::uint32_t>(watchdogFactor) * CycleTimeUs();
  }
 
  [[nodiscard]] bool IsInput() const
  {
    return typeIOCR == IOCR_TYPE_INPUT;
  }
 
  [[nodiscard]] bool IsOutput() const
  {
    return typeIOCR == IOCR_TYPE_OUTPUT;
  }
};
 
struct RTFrame
{
  std::uint16_t frameId = 0;
 
  std::uint16_t cycleCounter = 0;
 
  std::uint8_t dataStatus = 0;
 
  std::uint8_t transferStatus = 0;
 
  Bytes payload;
 
  // NOLINTBEGIN(readability-identifier-naming)
  static constexpr std::uint8_t DATA_VALID = DATA_STATUS_VALID;
 
  static constexpr std::uint8_t DATA_PRIMARY = DATA_STATUS_STATE;
 
  static constexpr std::uint8_t DATA_RUN = DATA_STATUS_PROVIDER_RUN;
 
  static constexpr std::uint8_t DATA_OK = DATA_STATUS_STATION_OK;
  // NOLINTEND(readability-identifier-naming)
 
  static RTFrame FromBytes(const Bytes& data);
 
  [[nodiscard]] Bytes ToBytes() const;
 
  [[nodiscard]] bool IsValid() const
  {
    return (dataStatus & DATA_STATUS_VALID) != 0;
  }
 
  [[nodiscard]] bool IsRunning() const
  {
    return (dataStatus & DATA_STATUS_PROVIDER_RUN) != 0;
  }
 
  [[nodiscard]] bool IsOk() const
  {
    return (dataStatus & DATA_STATUS_STATION_OK) != 0;
  }
 
  [[nodiscard]] bool IsPrimary() const
  {
    return (dataStatus & DATA_STATUS_STATE) != 0;
  }
 
  [[nodiscard]] std::string ToString() const;
};
 
class CyclicDataBuilder
{
 public:
  explicit CyclicDataBuilder(IOCRConfig config);
 
  void SetData(int slot, int subslot, const Bytes& data);
 
  Bytes GetData(int slot, int subslot) const;
 
  void SetIops(int slot, int subslot, std::uint8_t status = IOXS_GOOD);
 
  void SetIocs(int slot, int subslot, std::uint8_t status = IOXS_GOOD);
 
  void SetAllIops(std::uint8_t status = IOXS_GOOD);
 
  void SetAllIocs(std::uint8_t status = IOXS_GOOD);
 
  void Clear();
 
  void Swap();
 
  Bytes Build() const;
 
  void Load(const Bytes& payload);
 
  const IOCRConfig& Config() const
  {
    return config;
  }
 
 private:
  IOCRConfig config;
 
  Bytes writeBuffer;
 
  Bytes sendBuffer;
 
  mutable std::mutex writeLock;
 
  bool dirty = false;
};
/*
template <typename SlotT>
std::pair<IOCRConfig, IOCRConfig> BuildIocrConfigs(const std::vector<SlotT>& slots, std::uint16_t inputFrameId,
                                                   std::uint16_t outputFrameId,
                                                   std::uint16_t sendClockFactor = 32,
                                                   std::uint16_t reductionRatio = 32,
                                                   int watchdogFactor = 3)
{
  std::vector<IODataObject> inputObjects;
  int frameOffset = 0;
  for (const auto& s : slots)
  {
    if (s.inputLength > 0)
    {
      inputObjects.push_back(
          {s.slot, s.subslot, frameOffset, s.inputLength, frameOffset + s.inputLength, 0});
      frameOffset += s.inputLength + 1;
    }
  }
  for (const auto& s : slots)
  {
    if (s.inputLength == 0)
    {
      frameOffset += 1;
    }
  }
 
  IOCRConfig inputIocr;
  inputIocr.typeIOCR = IOCR_TYPE_INPUT;
  inputIocr.referenceIOCR = 1;
  inputIocr.frameId = inputFrameId;
  inputIocr.sendClockFactor = sendClockFactor;
  inputIocr.reductionRatio = reductionRatio;
  inputIocr.watchdogFactor = watchdogFactor;
  inputIocr.dataLength = std::max(40, frameOffset);
  inputIocr.objects = inputObjects;
 
  std::vector<IODataObject> outputObjects;
  frameOffset = 0;
  for (const auto& s : slots)
  {
    if (s.outputLength > 0)
    {
      outputObjects.push_back(
          {s.slot, s.subslot, frameOffset, s.outputLength, frameOffset + s.outputLength, 0});
      frameOffset += s.outputLength + 1;
    }
  }
  // IOCS entries for slots with no output data: submodules with input
  // but no output (e.g. DAP submodules) still need their IOCS
  // acknowledged in the output frame.
  for (const auto& s : slots)
  {
    if (s.outputLength == 0)
    {
      outputObjects.push_back({s.slot, s.subslot, frameOffset, 0, 0, frameOffset});
      frameOffset += 1;
    }
  }
 
  IOCRConfig outputIocr;
  outputIocr.typeIOCR = IOCR_TYPE_OUTPUT;
  outputIocr.referenceIOCR = 2;
  outputIocr.frameId = outputFrameId;
  outputIocr.sendClockFactor = sendClockFactor;
  outputIocr.reductionRatio = reductionRatio;
  outputIocr.watchdogFactor = watchdogFactor;
  outputIocr.dataLength = std::max(40, frameOffset);
  outputIocr.objects = outputObjects;
 
  return {inputIocr, outputIocr};
}
*/
template <typename SlotT>
std::pair<IOCRConfig, IOCRConfig> BuildIocrConfigs(
    const std::vector<SlotT>& slots,
    std::uint16_t inputFrameId,
    std::uint16_t outputFrameId,
    std::uint16_t sendClockFactor = 32,
    std::uint16_t reductionRatio = 32,
    int watchdogFactor = 3,
    std::uint16_t cSduLength = 40)
{
  // =========================================================================
  // INPUT IOCR
  //
  // Device -> Controller
  //
  // C_SDU layout:
  //
  //   1. IOCS for every configured submodule without input data
  //   2. Input process data
  //   3. IOPS for every configured submodule with input data
  //
  // For the AUMA GSDML:
  //
  //   8 IOCS bytes
  //   34 input bytes
  //   1 IOPS byte
  //   ----------------
  //   43 bytes total
  // =========================================================================
 
  std::vector<IODataObject> inputObjects;
  std::uint16_t inputFrameOffset = 0;
 
  // -------------------------------------------------------------------------
  // First: IOCS section.
  //
  // Every configured submodule that does not provide input process data
  // occupies one IOCS byte in the input IOCR.
  // -------------------------------------------------------------------------
  for (const auto& s : slots)
  {
    if (s.inputLength == 0 || s.outputLength > 0)
    {
      inputObjects.push_back(
          {
              s.slot,
              s.subslot,
              inputFrameOffset, // No process-data bytes.
              0,                // No input data.
              std::nullopt,     // No IOPS.
              inputFrameOffset  // IOCS position.
          });
 
      ++inputFrameOffset;
    }
  }
 
  // -------------------------------------------------------------------------
  // Second: input process data followed by IOPS.
  // -------------------------------------------------------------------------
  for (const auto& s : slots)
  {
    if (s.inputLength > 0)
    {
      const std::uint16_t dataOffset = inputFrameOffset - 1; // werkt nu ff bij auma maar niet goed vlgs mij.
      // auto it = std::find_if(inputObjects.begin(), inputObjects.end(), [&s](const IODataObject& inputObject)
      // {
      //   return inputObject.slot == s.slot && inputObject.subslot == s.subslot;
      // });
 
      // if (it != inputObjects.end())
      // {
      //   inputFrameOffset = it->frameOffset;
      // }
      // const std::uint16_t dataOffset = inputFrameOffset;
 
      inputFrameOffset += s.inputLength;
 
      const std::uint16_t iopsOffset = inputFrameOffset;
 
      ++inputFrameOffset;
 
      inputObjects.push_back(
          {
              s.slot,
              s.subslot,
              dataOffset,
              s.inputLength,
              iopsOffset,  // IOPS immediately after process data.
              std::nullopt // No IOCS for this input-data object.
          });
    }
  }
 
  IOCRConfig inputIocr;
  inputIocr.typeIOCR = IOCR_TYPE_INPUT;
  inputIocr.referenceIOCR = 1;
  inputIocr.frameId = inputFrameId;
  inputIocr.sendClockFactor = sendClockFactor;
  inputIocr.reductionRatio = reductionRatio;
  inputIocr.phase = 0;
  inputIocr.watchdogFactor = watchdogFactor;
  inputIocr.dataLength = std::max(inputFrameOffset, cSduLength);
  inputIocr.objects = std::move(inputObjects);
 
  for (const auto& object : inputIocr.objects)
  {
    object.Validate(inputIocr.dataLength);
  }
  // =========================================================================
  // OUTPUT IOCR
  //
  // Controller -> Device
  //
  // C_SDU layout:
  //
  //   1. IOCS for every configured submodule without output data
  //   2. Output process data
  //   3. IOPS for every configured submodule with output data
  //
  // For the AUMA GSDML:
  //
  //   8 IOCS bytes
  //   16 output bytes
  //   1 IOPS byte
  //   ----------------
  //   25 bytes total
  // =========================================================================
 
  std::vector<IODataObject> outputObjects;
  std::uint16_t outputFrameOffset = 0;
 
  // -------------------------------------------------------------------------
  // First: IOCS section.
  //
  // Every configured submodule that does not provide output process data
  // occupies one IOCS byte in the output IOCR.
  // -------------------------------------------------------------------------
  for (const auto& s : slots)
  {
    if (s.outputLength == 0)
    {
      outputObjects.push_back(
          {
              s.slot,
              s.subslot,
              outputFrameOffset, // No process-data bytes.
              0,                 // No output data.
              std::nullopt,      // No IOPS.
              outputFrameOffset  // IOCS position.
          });
 
      ++outputFrameOffset;
    }
    else if (s.inputLength > 0 && s.outputLength > 0)
    {
      outputObjects.push_back(
          {
              s.slot,
              s.subslot,
              outputFrameOffset, // No process-data bytes.
              s.outputLength,
              std::nullopt,     // No IOPS.
              outputFrameOffset // IOCS position.
          });
 
      ++outputFrameOffset;
    }
  }
 
  // -------------------------------------------------------------------------
  // Second: output process data followed by IOPS.
  // -------------------------------------------------------------------------
  for (const auto& s : slots)
  {
    if (s.outputLength > 0)
    {
      const std::uint16_t dataOffset = outputFrameOffset;
 
      outputFrameOffset += s.outputLength;
 
      const std::uint16_t iopsOffset = outputFrameOffset;
 
      ++outputFrameOffset;
 
      outputObjects.push_back(
          {
              s.slot,
              s.subslot,
              dataOffset,
              s.outputLength,
              // 42, // iopsOffset, // IOPS immediately after process data.
              iopsOffset,
              std::nullopt // No IOCS for this output-data object (was -1).
          });
    }
  }
 
  IOCRConfig outputIocr;
  outputIocr.typeIOCR = IOCR_TYPE_OUTPUT;
  outputIocr.referenceIOCR = 2;
  outputIocr.frameId = outputFrameId;
  outputIocr.sendClockFactor = sendClockFactor;
  outputIocr.reductionRatio = reductionRatio;
  outputIocr.phase = 0;
  outputIocr.watchdogFactor = watchdogFactor;
  outputIocr.dataLength = std::max(outputFrameOffset, cSduLength); // static_cast<std::uint16_t>(40));
  outputIocr.objects = std::move(outputObjects);
 
  for (const auto& object : outputIocr.objects)
  {
    object.Validate(outputIocr.dataLength);
  }
  return {std::move(inputIocr), std::move(outputIocr)};
}
 
Bytes BuildEthernetFrame(const MacAddress& dstMac, const MacAddress& srcMac, const RTFrame& rtFrame);
 
std::optional<RTFrame> ParseEthernetFrame(const Bytes& data);
 
} // namespace profinet::rt