virtual_profinet_rpc_device.h

Go to the documentation of this file.

 
#pragma once
 
#include <array>
#include <asio.hpp>
#include <atomic>
#include <condition_variable>
#include <cstdint>
#include <mutex>
#include <string>
#include <thread>
#include <vector>
 
#include "profinet/protocol.h"
#include "profinet/rpc.h"
 
namespace profinet::sim
{
 
enum class VirtualProfinetDeviceState
{
  Idle,
  Connected,
  Parameterizing,
  Parameterized,
  ApplicationReady,
  Released,
  Fault
};
 
[[nodiscard]] const char* ToString(VirtualProfinetDeviceState state) noexcept;
 
struct VirtualProfinetDeviceConfiguration
{
  std::uint16_t rpcPort = 34965;
 
  std::uint16_t controllerCcontrolPort = rpc::RPC_PORT;
 
  std::string controllerAddress = "127.0.0.1";
 
  std::string stationName = "valve2";
 
  MacAddress deviceMac{0xA0, 0xD3, 0x85, 0x00, 0xF6, 0x13};
 
  std::uint16_t vendorId = 0x013F;
 
  std::uint16_t deviceId = 0x0002;
 
  std::chrono::milliseconds applicationReadyDelay{10};
 
  std::uint16_t inputFrameId = 0xC000;
 
  std::uint16_t outputFrameId = 0xC001;
 
  std::uint16_t deviceAlarmReference = 42;
 
  bool requireBothIocrs = true;
 
  bool requireExpectedSubmodules = true;
 
  bool requireAlarmCr = true;
 
  bool automaticApplicationReady = true;
};
 
class VirtualProfinetRpcDevice
{
 public:
  explicit VirtualProfinetRpcDevice(
      VirtualProfinetDeviceConfiguration config = {});
 
  ~VirtualProfinetRpcDevice();
 
  VirtualProfinetRpcDevice(const VirtualProfinetRpcDevice&) = delete;
  VirtualProfinetRpcDevice& operator=(const VirtualProfinetRpcDevice&) = delete;
 
  void Start();
 
  void Stop() noexcept;
 
  [[nodiscard]] VirtualProfinetDeviceState State() const noexcept;
 
  [[nodiscard]] std::size_t ConnectCount() const noexcept;
 
  [[nodiscard]] std::size_t PrmBeginCount() const noexcept;
 
  [[nodiscard]] std::size_t PrmEndCount() const noexcept;
 
  [[nodiscard]] std::size_t ApplicationReadyRequestCount() const noexcept;
 
  [[nodiscard]] std::size_t ApplicationReadyResponseCount() const noexcept;
 
  [[nodiscard]] std::size_t ReleaseCount() const noexcept;
 
  [[nodiscard]] bool SawInputIocr() const noexcept;
 
  [[nodiscard]] bool SawOutputIocr() const noexcept;
 
  [[nodiscard]] bool SawExpectedSubmodules() const noexcept;
 
  [[nodiscard]] bool SawAlarmCr() const noexcept;
 
  [[nodiscard]] std::string LastError() const;
 
  [[nodiscard]] bool WaitForState(
      VirtualProfinetDeviceState expected,
      std::chrono::milliseconds timeout) const;
 
  [[nodiscard]] std::uint16_t RpcPort() const noexcept;
 
 private:
  void Run();
 
  void HandlePacket(const PNRPCHeader& request,
                    const asio::ip::udp::endpoint& sender);
 
  void HandleConnect(const PNRPCHeader& request,
                     const asio::ip::udp::endpoint& sender);
 
  void HandleControl(const PNRPCHeader& request,
                     const asio::ip::udp::endpoint& sender);
 
  void HandleApplicationReadyResponse(const PNRPCHeader& response);
 
  bool ValidateConnect(const Bytes& nrdPayload);
 
  void SendResponse(const PNRPCHeader& request,
                    const Bytes& nrdPayload,
                    const asio::ip::udp::endpoint& sender);
 
  void SendApplicationReady();
 
  static Bytes MakeNrd(const Bytes& payload);
 
  static PNRPCHeader MakeResponse(const PNRPCHeader& request,
                                  const Bytes& nrdPayload);
 
  static Bytes MakeIocrResponse(
      const PNIOCRBlockReqHeader& request,
      std::uint16_t frameId);
 
  static Bytes MakeAlarmCrResponse(std::uint16_t deviceAlarmReference);
 
  static bool ContainsBlock(const Bytes& data, BlockType blockType);
 
  static void ParseArIdentity(
      const Bytes& connectPayload,
      std::array<std::uint8_t, uuidLenght>& arUuid,
      std::uint16_t& sessionKey);
  void WakeWorker() noexcept;
 
  void ScheduleApplicationReady();
 
  VirtualProfinetDeviceConfiguration config;
  mutable std::mutex mutex;
  mutable std::condition_variable stateCondition;
 
  std::atomic<bool> running{false};
  std::thread worker;
  std::thread applicationReadyWorker;
 
  std::unique_ptr<asio::io_context> ioContext;
  std::unique_ptr<asio::ip::udp::socket> socket;
 
  VirtualProfinetDeviceState state = VirtualProfinetDeviceState::Idle;
  std::size_t connectCount = 0;
  std::size_t prmBeginCount = 0;
  std::size_t prmEndCount = 0;
  std::size_t applicationReadyRequestCount = 0;
  std::size_t applicationReadyResponseCount = 0;
  std::size_t releaseCount = 0;
 
  bool sawInputIocr = false;
  bool sawOutputIocr = false;
  bool sawExpectedSubmodules = false;
  bool sawAlarmCr = false;
 
  std::string lastError;
  std::array<std::uint8_t, uuidLenght> arUuid{};
  std::uint16_t sessionKey = 0;
  std::optional<asio::ip::udp::endpoint> controllerEndpoint;
  std::optional<PNRPCHeader> lastApplicationReadyRequest;
};
 
} // namespace profinet::sim