virtual_phoenix_plc.h

Go to the documentation of this file.

 
#pragma once
 
#include <cstdint>
#include <memory>
#include <mutex>
#include <optional>
#include <string>
#include <string_view>
#include <utility>
#include <vector>
 
#include "profinet/IOSignal.h"
#include "profinet/cyclic.h"
#include "profinet/gsdml.h"
#include "profinet/rt.h"
#include "profinet/sim/in_memory_ethernet.h"
#include "profinet/util.h"
 
namespace profinet::sim
{
 
class VirtualAumaValve;
 
struct VirtualPhoenixIoImage
{
  Bytes inputs;
  Bytes outputs;
};
 
class VirtualPhoenixPlc
{
 public:
  VirtualPhoenixPlc(std::string name,
                    const gsdml::GSDMLDevice& gsdml,
                    MacAddress controllerMac);
 
  ~VirtualPhoenixPlc();
 
  VirtualPhoenixPlc(const VirtualPhoenixPlc&) = delete;
  VirtualPhoenixPlc& operator=(const VirtualPhoenixPlc&) = delete;
 
  void Connect(asio::io_context& ioContext,
               InMemoryEthernetBus& bus,
               VirtualAumaValve& valve,
               rt::IOCRConfig inputIocr,
               rt::IOCRConfig outputIocr,
               int maxConsecutiveTimeouts = cyclic::DEFAULT_MAX_CONSECUTIVE_TIMEOUTS);
 
  void Disconnect(const std::string& valveName);
 
  void Stop();
 
  void SetOutput(const std::string& valveName,
                 std::string_view signalTextId,
                 double value);
 
  [[nodiscard]] std::optional<double> ReadInput(const std::string& valveName,
                                                std::string_view signalTextId) const;
 
  void SetLocalInputBytes(std::string_view signalTextId, const Bytes& data);
 
  void SetLocalInputValue(std::string_view signalTextId, double value);
 
  [[nodiscard]] std::optional<double> GetLocalInputValue(std::string_view signalTextId) const;
 
  void SetLocalOutputBytes(std::string_view signalTextId, const Bytes& data);
 
  [[nodiscard]] std::optional<Bytes> GetLocalOutputBytes(std::string_view signalTextId) const;
 
  void SetLocalOutputValue(std::string_view signalTextId, double value);
 
  [[nodiscard]] std::optional<double> GetLocalOutputValue(std::string_view signalTextId) const;
 
  [[nodiscard]] std::optional<Bytes> GetLocalInputBytes(std::string_view signalTextId) const;
 
  [[nodiscard]] const io::IoSignalCatalog& SignalCatalog() const noexcept;
 
  [[nodiscard]] const MacAddress& ControllerMac() const noexcept;
 
  [[nodiscard]] const std::string& Name() const noexcept;
 
  [[nodiscard]] std::size_t ConnectionCount() const;
 
  [[nodiscard]] std::optional<cyclic::CyclicState>
  ConnectionState(const std::string& valveName) const;
 
  [[nodiscard]] std::optional<cyclic::CyclicStatsSnapshot>
  ConnectionStats(const std::string& valveName) const;
 
  [[nodiscard]] std::string StatusReport() const;
 
 private:
  struct Connection
  {
    std::string name;
    VirtualAumaValve* valve = nullptr;
    std::unique_ptr<cyclic::CyclicController> controller;
    Bytes outputImage;
  };
 
  [[nodiscard]] Connection* FindConnection(const std::string& valveName);
 
  [[nodiscard]] const Connection* FindConnection(const std::string& valveName) const;
 
  [[nodiscard]] static const io::IoSignal*
  FindDeviceSignal(const VirtualAumaValve& valve,
                   std::string_view textId,
                   io::IoSignalDirection direction);
 
  [[nodiscard]] double DecodeSignal(const io::IoSignal& signal,
                                    const Bytes& data) const;
 
  [[nodiscard]] Bytes EncodeSignalValue(const io::IoSignal& signal,
                                        const Bytes& data,
                                        double value) const;
 
  [[nodiscard]] static std::size_t RequiredImageSize(const io::IoSignalCatalog& catalog);
 
  [[nodiscard]] const io::IoSignal* FindLocalInputSignal(std::string_view textId) const;
 
  [[nodiscard]] const io::IoSignal* FindLocalOutputSignal(std::string_view textId) const;
 
  [[nodiscard]] static std::pair<std::uint16_t, std::uint16_t> ResolveDeviceLocation(
      const io::IoSignal& signal,
      std::uint16_t defaultSlot,
      std::uint16_t defaultSubslot);
 
  std::string name;
  const gsdml::GSDMLDevice& gsdml;
  MacAddress controllerMac{};
  io::IoSignalCatalog catalog;
  mutable std::mutex mutex;
  std::vector<std::unique_ptr<Connection>> connections;
  VirtualPhoenixIoImage ioImage;
};
 
} // namespace profinet::sim