rpc.h

Go to the documentation of this file.

 
 
#pragma once
 
#include <array>
#include <asio.hpp>
#include <chrono>
#include <cstdint>
#include <map>
#include <optional>
#include <string>
#include <vector>
 
#include "profinet/IRPCCon.h"
#include "profinet/blocks.h"
#include "profinet/dcp.h"
#include "profinet/diagnosis.h"
#include "profinet/exceptions.h"
#include "profinet/indices.h"
#include "profinet/protocol.h"
#include "profinet/rpcTransport.h"
#include "profinet/rpcTypes.h"
#include "profinet/util.h"
 
namespace profinet::rpc
{
 
struct BlockHeaderView
{
  std::uint16_t blockType;
  std::uint16_t blockLength;
};
 
inline BlockHeaderView PeekBlockHeader(const Bytes& data, std::size_t offset)
{
  return {
      .blockType = static_cast<std::uint16_t>((data[offset] << OneOctetShift) | data[offset + 1]),
      .blockLength = static_cast<std::uint16_t>((data[offset + 2] << OneOctetShift) | data[offset + 3])};
}
// =============================================================================
// UUID helpers (DCE/RPC mixed-endian format)
// =============================================================================
 
std::string UuidBytesToString(const std::array<std::uint8_t, uuidLenght>& data);
 
std::array<std::uint8_t, uuidLenght> StringToUuidBytes(const std::string& uuidStr);
 
// =============================================================================
// EPM (Endpoint Mapper)
// =============================================================================
 
struct EPMEndpoint
{
  std::string interfaceUuid;
 
  std::uint16_t interfaceVersionMajor = 0;
 
  std::uint16_t interfaceVersionMinor = 0;
 
  std::string objectUuid;
 
  std::string protocol;
 
  std::uint16_t port = 0;
 
  std::string ipAddress;
 
  std::string annotation;
 
  [[nodiscard]] std::string InterfaceName() const;
};
 
std::vector<EPMEndpoint> EpmLookup(asio::io_context& ioContext, const std::string& ip, std::uint16_t port = RPC_PORT,
                                   double timeoutSec = DEFAULT_TIMEOUT,
                                   std::optional<std::string> interfaceFilter = std::nullopt);
 
dcp::DCPDeviceDescription GetStationInfo(const EthernetSocket& sock,
                                         const MacAddress& src,
                                         const std::string& name,
                                         int timeoutSec = static_cast<int>(DEFAULT_TIMEOUT * 2));
 
// =============================================================================
// RPCCon - PROFINET DCE/RPC connection to an IO-Device
// =============================================================================
class RPCCon : public IRPCCon
{
 public:
  friend class RpcTest;
 
  RPCCon(RPCCon&&) = delete;
 
  RPCCon& operator=(RPCCon&&) = delete;
 
  explicit RPCCon(const dcp::DCPDeviceDescription& info, RPCConOptions options = {});
 
  ~RPCCon();
 
  RPCCon(const RPCCon&) = delete;
 
  RPCCon& operator=(const RPCCon&) = delete;
 
  std::optional<ConnectResult> Connect(std::optional<MacAddress> srcMac = std::nullopt,
                                       bool withAlarmCr = false,
                                       std::optional<IOCRSetup> iocrSetup = std::nullopt) override;
 
  PNIODHeader Read(std::uint32_t api, std::uint16_t slot, std::uint16_t subslot, std::uint16_t idx) override;
 
  PNIODHeader ReadImplicit(std::uint32_t api, std::uint16_t slot, std::uint16_t subslot, std::uint16_t idx) override;
 
  void Write(std::uint32_t api, std::uint16_t slot, std::uint16_t subslot, std::uint16_t idx,
             const Bytes& data) override;
 
  std::vector<blocks::WriteMultipleResult> WriteMultiple(const std::vector<WriteItem>& writes) override;
 
  Bytes ReadRaw(std::uint16_t idx, std::uint16_t slot = 0, std::uint16_t subslot = 1);
 
  PNInM0 ReadIm0(std::uint16_t slot = 0, std::uint16_t subslot = 1) override;
 
  PNInM1 ReadIm1(std::uint16_t slot = 0, std::uint16_t subslot = 1) override;
 
  PNInM2 ReadIm2(std::uint16_t slot = 0, std::uint16_t subslot = 1) override;
 
  PNInM3 ReadIm3(std::uint16_t slot = 0, std::uint16_t subslot = 1) override;
 
  PNInM4 ReadIm4(std::uint16_t slot = 0, std::uint16_t subslot = 1) override;
 
  PNInM5 ReadIm5(std::uint16_t slot = 0, std::uint16_t subslot = 1) override;
 
  PNInM6 ReadIm6(std::uint16_t slot = 0, std::uint16_t subslot = 1) override;
 
  PNInM7 ReadIm7(std::uint16_t slot = 0, std::uint16_t subslot = 1) override;
 
  PNInM8 ReadIm8(std::uint16_t slot = 0, std::uint16_t subslot = 1) override;
 
  PNInM9 ReadIm9(std::uint16_t slot = 0, std::uint16_t subslot = 1) override;
 
  PNInM10 ReadIm10(std::uint16_t slot = 0, std::uint16_t subslot = 1) override;
 
  PNInM11 ReadIm11(std::uint16_t slot = 0, std::uint16_t subslot = 1) override;
 
  PNInM12 ReadIm12(std::uint16_t slot = 0, std::uint16_t subslot = 1) override;
 
  PNInM13 ReadIm13(std::uint16_t slot = 0, std::uint16_t subslot = 1) override;
 
  PNInM14 ReadIm14(std::uint16_t slot = 0, std::uint16_t subslot = 1) override;
 
  PNInM15 ReadIm15(std::uint16_t slot = 0, std::uint16_t subslot = 1) override;
 
  AllIM ReadAllIm(std::uint16_t slot = 0, std::uint16_t subslot = 1) override;
 
  // =========================================================================
  // Configuration / diagnosis / topology (built on blocks.h/diagnosis.h)
  // =========================================================================
 
  blocks::ModuleDiffBlock ReadModuleDiff() override;
 
  diagnosis::DiagnosisData ReadDiagnosis(std::uint16_t slot = 0, std::uint16_t subslot = 0,
                                         std::uint16_t index = 0xF000) override;
 
  std::map<std::uint16_t, diagnosis::DiagnosisData> ReadAllDiagnosis() override;
 
  blocks::PDRealData ReadPdRealData() override;
 
  blocks::RealIdentificationData ReadRealIdentificationData() override;
 
  std::vector<blocks::SlotInfo> DiscoverSlots() override;
 
  std::pair<blocks::PDRealData, blocks::RealIdentificationData> DiscoverTopology() override;
 
  std::map<std::uint16_t, IndexProbeResult> EnumerateIndices(
      std::uint16_t slot = 0, std::uint16_t subslot = 1,
      std::optional<std::vector<std::uint16_t>> customIndices = std::nullopt) override;
 
  Bytes PrmBegin() override;
 
  Bytes PrmEnd() override;
 
  Bytes ReadyForRtClass3() override;
 
  Bytes ApplicationReady(double timeoutSec = 30.0) override;
 
  void Disconnect() override;
 
  void Close() noexcept override;
 
  [[nodiscard]] bool IsConnected() const override
  {
    return live;
  }
 
  [[nodiscard]] const dcp::DCPDeviceDescription& Info() const override
  {
    return info;
  }
 
  [[nodiscard]] const std::array<std::uint8_t, uuidLenght>& ArUuid() const
  {
    return arUuid;
  }
 
  [[nodiscard]] std::uint16_t SessionKey() const
  {
    return sessionKey;
  }
 
  [[nodiscard]] std::uint16_t LocalAlarmRef() const override
  {
    return alarmRef;
  }
 
  [[nodiscard]] int DeviceAlarmRef() const override
  {
    return deviceAlarmRef;
  }
 
  [[nodiscard]] bool HasAlarmCr() const override
  {
    return alarmCrEnabled;
  }
 
  [[nodiscard]] asio::io_context& IoContext() override
  {
    return ioContext;
  }
 
 private:
  PNRPCHeader CreateRpc(std::uint16_t operation, const Bytes& nrd);
 
  static PNNRDData CreateNrd(const Bytes& payload);
 
  [[nodiscard]] Bytes BuildAlarmCrBlock(int transport = 0, int priority = 0) const;
 
  static int ParseAlarmCrResponse(const Bytes& responseData);
 
  static Bytes BuildIocrBlock(int iocrType, int iocrReference, const IOCRSetup& setup);
 
  static Bytes BuildExpectedSubmoduleBlock(const IOCRSetup& setup);
 
  static Bytes BuildUnifiedExpectedSubmoduleBlock(const IOCRSetup& setup);
 
  static std::uint16_t ParseIocrResponse(const Bytes& responseData, int iocrType);
 
  PNRPCHeader SendReceive(const PNRPCHeader& request);
 
  void CloseSockets() noexcept;
 
  void CheckTimeout();
 
  Bytes SendControl(BlockType blockType, ControlCommand controlCommand, bool waitResponse = true,
                    const Bytes& subBlocks = {});
 
  dcp::DCPDeviceDescription info;
 
  double timeout;
 
  std::array<std::uint8_t, uuidLenght> arUuid{};
 
  std::array<std::uint8_t, uuidLenght> activityUuid{};
 
  std::array<std::uint8_t, uuidLenght> localObjectUuid{};
 
  std::array<std::uint8_t, uuidLenght> remoteObjectUuid{};
 
  bool live = false;
 
  std::chrono::steady_clock::time_point liveMonotonic{};
 
  std::optional<MacAddress> srcMac;
 
  std::uint16_t sessionKey = 0;
 
  // std::uint16_t alarmRef = 1;
  std::uint16_t alarmRef = 0x8001;
 
  int deviceAlarmRef = 0;
 
  bool alarmCrEnabled = false;
 
  std::uint32_t sequenceNumber = 0;
 
  int iocrRefCounter = 1;
 
  int inputIocrRef = 0;
 
  int outputIocrRef = 0;
 
  std::uint16_t inputFrameId = 0;
 
  std::uint16_t outputFrameId = 0;
 
  std::optional<IOCRSetup> iocrSetup;
 
  asio::io_context ioContext{};
 
  std::unique_ptr<RpcTransport> rpcTransport;
  std::unique_ptr<RpcTransport> ccontrolTransport;
};
 
} // namespace profinet::rpc