rpcTypes.h

Go to the documentation of this file.

 
#pragma once
 
#include <cstdint>
#include <optional>
#include <string>
#include <vector>
 
#include "profinet/blocks.h"
#include "profinet/dcp.h"
 
namespace profinet::rpc
{
// =============================================================================
// Constants
// =============================================================================
// NOLINTBEGIN(readability-identifier-naming)
inline constexpr std::uint16_t RPC_PORT = 0x8894;
inline constexpr std::uint16_t RPC_BIND_PORT = 0x8895;
 
inline const std::string UUID_NULL = "00000000-0000-0000-0000-000000000000";
inline const std::string UUID_EPM_V4 = "e1af8308-5d1f-11c9-91a4-08002b14a0fa";
inline const std::string UUID_PNIO_DEVICE = "dea00001-6c97-11d1-8271-00a02442df7d";
inline const std::string UUID_PNIO_CONTROLLER = "dea00002-6c97-11d1-8271-00a02442df7d";
inline const std::string UUID_PNIO_SUPERVISOR = "dea00003-6c97-11d1-8271-00a02442df7d";
inline const std::string UUID_PNIO_PARAMETER_SERVER = "dea00004-6c97-11d1-8271-00a02442df7d";
 
inline constexpr std::uint32_t PNIO_DEVICE_INTERFACE_VERSION = 1;
 
inline constexpr std::uint32_t EPM_LOOKUP = 0x02;
inline constexpr std::uint32_t EPM_INQUIRY_ALL = 0x00;
inline constexpr std::uint32_t EPM_INQUIRY_INTERFACE = 0x01;
 
inline constexpr double DEFAULT_TIMEOUT = 5.0;
inline constexpr double CONNECTION_TIMEOUT = 10.0;
 
// CONTROL block types / commands (subset of indices.h's catalog needed
// directly by RPCCon).
inline constexpr std::uint16_t BLOCK_IOD_CONTROL_PRM_END_REQ = 0x0110;
inline constexpr std::uint16_t BLOCK_IOD_CONTROL_APP_READY_REQ = 0x0112;
inline constexpr std::uint16_t BLOCK_IOD_CONTROL_APP_READY_RES = 0x8112;
inline constexpr std::uint16_t BLOCK_IOD_CONTROL_RT_CLASS_3_REQ = 0x0117;
inline constexpr std::uint16_t BLOCK_PRM_BEGIN_REQ = 0x0118;
inline constexpr std::uint16_t BLOCK_RELEASE_REQ = 0x0114;
 
inline constexpr std::uint16_t CONTROL_CMD_PRM_END = 0x0001;
inline constexpr std::uint16_t CONTROL_CMD_APP_READY = 0x0002;
inline constexpr std::uint16_t CONTROL_CMD_RELEASE = 0x0004;
inline constexpr std::uint16_t CONTROL_CMD_DONE = 0x0008;
inline constexpr std::uint16_t CONTROL_CMD_READY_FOR_COMPANION = 0x0010;
inline constexpr std::uint16_t CONTROL_CMD_READY_FOR_RT_CLASS_3 = 0x0020;
inline constexpr std::uint16_t CONTROL_CMD_PRM_BEGIN = 0x0040;
// NOLINTEND(readability-identifier-naming)
// =============================================================================
// IOCR (cyclic IO) configuration
// =============================================================================
 
struct IOSlot
{
  std::uint16_t slot = 0;
 
  std::uint16_t subslot = 0;
 
  std::uint16_t inputLength = 0;
 
  std::uint16_t outputLength = 0;
 
  std::uint32_t moduleIdent = 0;
 
  std::uint32_t submoduleIdent = 0;
 
  bool operator==(const IOSlot&) const = default;
};
 
enum class StartupMode : std::uint16_t
{
  Legacy,
  Advanced
};
 
struct ApplicationRelations
{
  std::uint16_t numberOfAr = 0;
 
  StartupMode startupMode = StartupMode::Legacy;
 
  std::vector<std::uint16_t> sendClockTimingProperties;
 
  std::vector<std::uint16_t> reductionRatioTimingProperties;
 
  bool operator==(const ApplicationRelations&) const = default;
};
 
struct IOCRSetup
{
  std::vector<IOSlot> slots;
 
  std::uint16_t sendClockFactor = 32;
 
  std::uint16_t reductionRatio = 32;
 
  std::uint16_t watchdogFactor = 6;
 
  std::uint16_t dataHoldFactor = 6;
 
  ApplicationRelations applicationRelations;
 
  [[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::vector<std::string> Validate() const;
 
  bool operator==(const IOCRSetup&) const = default;
};
namespace raw
{
enum class Flags1 : std::uint8_t
{
  None = 0x00,
 
  Reserved1 = 1 << 7,
 
  Broadcast = 1 << 6,
 
  Idempotent = 1 << 5,
 
  Maybe = 1 << 4,
 
  NoFack = 1 << 3,
 
  Fragment = 1 << 2,
 
  LastFragment = 1 << 1,
 
  Reserved0 = 1 << 0
};
 
[[nodiscard]] constexpr Flags1 operator|(Flags1 lhs, Flags1 rhs) noexcept
{
  return static_cast<Flags1>(static_cast<std::uint8_t>(lhs) | static_cast<std::uint8_t>(rhs));
}
 
[[nodiscard]] constexpr Flags1 operator&(Flags1 lhs, Flags1 rhs) noexcept
{
  return static_cast<Flags1>(static_cast<std::uint8_t>(lhs) & static_cast<std::uint8_t>(rhs));
}
 
[[nodiscard]] constexpr std::uint8_t operator&(std::uint8_t lhs, Flags1 rhs) noexcept
{
  return lhs & static_cast<std::uint8_t>(rhs);
}
 
[[nodiscard]] constexpr std::uint8_t operator&(Flags1 lhs, std::uint8_t rhs) noexcept
{
  return static_cast<std::uint8_t>(lhs) & rhs;
}
 
[[nodiscard]] constexpr std::uint8_t operator|(std::uint8_t lhs, Flags1 rhs) noexcept
{
  return lhs | static_cast<std::uint8_t>(rhs);
}
 
[[nodiscard]] constexpr std::uint8_t operator|(Flags1 lhs, std::uint8_t rhs) noexcept
{
  return static_cast<std::uint8_t>(lhs) | rhs;
}
 
[[nodiscard]] constexpr bool HasFlag(Flags1 flags, Flags1 test) noexcept
{
  return (flags & test) == test;
}
 
[[nodiscard]] constexpr bool HasFlag(std::uint8_t flags, Flags1 test) noexcept
{
  const auto testVal = static_cast<std::uint8_t>(test);
  return (flags & testVal) == testVal;
}
 
[[nodiscard]] constexpr bool HasFlag(Flags1 flags, std::uint8_t test) noexcept
{
  return (static_cast<std::uint8_t>(flags) & test) == test;
}
 
struct RawRpcHeader
{
  static constexpr std::uint8_t kLittleEndianDrepFlag = 0x10U;
 
  std::uint8_t version{};
 
  std::uint8_t packetType{};
 
  std::uint8_t flags1{};
 
  std::uint8_t flags2{};
 
  std::uint8_t serialHigh{};
 
  std::array<std::uint8_t, 3> drep{};
 
  std::array<std::uint8_t, uuidLenght> objectUuid{};
 
  std::array<std::uint8_t, uuidLenght> interfaceUuid{};
 
  std::array<std::uint8_t, uuidLenght> activityUuid{};
 
  std::uint32_t interfaceVersion{};
 
  std::uint32_t sequenceNumber{};
 
  std::uint16_t operationNumber{};
 
  std::uint8_t serialLow{};
 
  bool isLittleEndian{};
 
  Bytes payload;
};
 
std::optional<RawRpcHeader> ParseRawRpcHeader(const Bytes& data);
} // namespace raw
 
struct ConnectResult
{
  std::array<std::uint8_t, uuidLenght> arUuid{};
 
  std::uint16_t sessionKey = 0;
 
  std::uint16_t inputFrameId = 0;
 
  std::uint16_t outputFrameId = 0;
 
  std::optional<raw::RawRpcHeader> header;
 
  int deviceAlarmRef = 0;
 
  [[nodiscard]] bool HasCyclic() const
  {
    return inputFrameId != 0 || outputFrameId != 0;
  }
};
 
// =============================================================================
// RPCCon - PROFINET DCE/RPC connection to an IO-Device
// =============================================================================
struct WriteItem
{
  std::uint16_t slot = 0;
  std::uint16_t subslot = 0;
  std::uint16_t index = 0;
  Bytes data;
  std::uint32_t api = 0;
};
 
struct AllIM
{
  std::optional<PNInM0> im0;
  std::optional<PNInM1> im1;
  std::optional<PNInM2> im2;
  std::optional<PNInM3> im3;
  std::optional<PNInM4> im4;
  std::optional<PNInM5> im5;
  std::optional<PNInM6> im6;
  std::optional<PNInM7> im7;
  std::optional<PNInM8> im8;
  std::optional<PNInM9> im9;
  std::optional<PNInM10> im10;
  std::optional<PNInM11> im11;
  std::optional<PNInM12> im12;
  std::optional<PNInM13> im13;
  std::optional<PNInM14> im14;
  std::optional<PNInM15> im15;
 
  bool operator==(const AllIM&) const = default;
};
struct IndexProbeResult
{
  std::string status;
  std::string name;
  std::size_t size = 0;
  std::string error;
  std::uint8_t errorCode1 = 0;
  std::uint8_t errorCode2 = 0;
};
 
struct RPCConOptions
{
  double timeoutSec = DEFAULT_TIMEOUT;
 
  std::uint16_t rpcPort = RPC_PORT;
};
} // namespace profinet::rpc