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 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 includeInInputIocr = false;
  bool includeInOutputIocr = false;
 
  bool inputIoData = false;
  bool outputIoData = false;
  bool inputIocs = false;
  bool outputIocs = false;
 
  bool operator==(const IOSlot&) 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;
 
  std::size_t dataLength = 43;
 
  [[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;
};
 
struct ConnectResult
{
  std::array<std::uint8_t, uuidLenght> arUuid{};
 
  std::uint16_t sessionKey = 0;
 
  std::uint16_t inputFrameId = 0;
 
  std::uint16_t outputFrameId = 0;
 
  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