virtual_auma_valve.h

Go to the documentation of this file.

 
#pragma once
 
#include <atomic>
#include <cstdint>
#include <functional>
#include <memory>
#include <mutex>
#include <optional>
#include <string>
#include <string_view>
#include <thread>
#include <vector>
 
#include "profinet/IOSignal.h"
#include "profinet/gsdml.h"
#include "profinet/rt.h"
#include "profinet/sim/in_memory_ethernet.h"
#include "profinet/util.h"
 
namespace profinet::sim
{
 
enum class VirtualAumaScenario
{
  Normal,
  Fault,
  BadIops,
  NoInput,
  SlowValve,
  Jammed,
  InvalidInput,
  DuplicateInput,
  OutOfOrderInput,
};
 
[[nodiscard]] const char* ToString(VirtualAumaScenario scenario) noexcept;
 
struct VirtualAumaValveConfiguration
{
  std::uint16_t inputSlot = 1;
  std::uint16_t inputSubslot = 1;
  std::uint16_t outputSlot = 2;
  std::uint16_t outputSubslot = 1;
 
  std::uint16_t initialPosition = 0;
  double travelUnitsPerSecond = 2500.0;
  double slowValveMultiplier = 0.25;
 
  std::string openCommand = "T_ID_CMD_0";
  std::string closeCommand = "T_ID_CMD_1";
  std::string stopCommand = "T_ID_CMD_2";
  std::string positionSetpoint = "T_ID_POSITIONSETPOINT";
  std::string speedSetpoint = "T_ID_SPEEDSETPOINT";
  std::string actualPosition = "T_ID_ACTPOS_E2";
  std::string faultSignal = "T_ID_FAULT1_0";
  std::string warningSignal = "T_ID_WARNING1_0";
 
  std::uint16_t alarmSourceReference = 42;
  std::uint16_t alarmDestinationReference = 1;
  bool emitAlarmNotification = true;
  bool emitRtaError = true;
 
  std::uint32_t alarmApi = 0;
 
  std::uint32_t alarmModuleIdent = 0x00008000U;
 
  std::uint32_t alarmSubmoduleIdent = 0x00002200U;
};
 
struct VirtualAumaAlarmEvent
{
  VirtualAumaScenario scenario = VirtualAumaScenario::Normal;
  std::uint8_t errorCode1 = 0;
  std::uint8_t errorCode2 = 0;
  std::uint16_t alarmSpecifier = 0;
  Bytes rtaErrorFrame;
  Bytes alarmNotificationFrame;
};
 
class VirtualAumaValve
{
 public:
  VirtualAumaValve(std::string name,
                   const gsdml::GSDMLDevice& gsdml,
                   MacAddress deviceMac,
                   rt::IOCRConfig inputIocr,
                   rt::IOCRConfig outputIocr,
                   VirtualAumaValveConfiguration config = {});
 
  ~VirtualAumaValve();
 
  VirtualAumaValve(const VirtualAumaValve&) = delete;
  VirtualAumaValve& operator=(const VirtualAumaValve&) = delete;
 
  void Start(InMemoryEthernetBus& bus);
 
  void Stop();
 
  void SetScenario(VirtualAumaScenario scenario);
 
  [[nodiscard]] VirtualAumaScenario Scenario() const noexcept;
 
  [[nodiscard]] std::uint16_t Position() const noexcept;
 
  [[nodiscard]] std::uint16_t TargetPosition() const noexcept;
 
  [[nodiscard]] bool FaultActive() const noexcept;
 
  [[nodiscard]] bool Moving() const noexcept;
 
  [[nodiscard]] const std::string& Name() const noexcept;
 
  [[nodiscard]] const MacAddress& DeviceMac() const noexcept;
 
  [[nodiscard]] std::uint16_t InputSlot() const noexcept;
 
  [[nodiscard]] std::uint16_t InputSubslot() const noexcept;
 
  [[nodiscard]] std::uint16_t OutputSlot() const noexcept;
 
  [[nodiscard]] std::uint16_t OutputSubslot() const noexcept;
 
  [[nodiscard]] const io::IoSignalCatalog& SignalCatalog() const noexcept;
 
  void OnFrame(std::function<void(const Bytes&)> callback);
 
  void OnAlarm(std::function<void(const VirtualAumaAlarmEvent&)> callback);
 
  [[nodiscard]] Bytes InputProcessData() const;
 
  [[nodiscard]] Bytes OutputProcessData() const;
 
 private:
  void Run();
 
  void ProcessOutputFrame(const Bytes& frame);
 
  void UpdateProcessModel(double elapsedSeconds);
 
  void DecodeCommands(const Bytes& outputData);
 
  void BuildInputProcessData();
 
  void SendInputFrame();
 
  void SetBitSignal(Bytes& data, std::string_view textId, bool value) const;
 
  void SetScalarSignal(Bytes& data, std::string_view textId, std::uint64_t value) const;
 
  [[nodiscard]] bool ReadBitSignal(const Bytes& data, std::string_view textId) const;
 
  [[nodiscard]] std::uint64_t ReadScalarSignal(const Bytes& data,
                                               std::string_view textId) const;
 
  [[nodiscard]] const io::IoSignal& RequireSignal(std::string_view textId,
                                                  io::IoSignalDirection direction) const;
 
  [[nodiscard]] Bytes BuildRtaErrorFrame(std::uint8_t errorCode1,
                                         std::uint8_t errorCode2) const;
 
  [[nodiscard]] Bytes BuildAlarmNotificationBlock(std::uint16_t alarmSpecifier) const;
 
  void EmitScenarioAlarms(VirtualAumaScenario scenario);
 
  void NotifyFrame(const Bytes& frame) const;
 
  void NotifyAlarm(const VirtualAumaAlarmEvent& event) const;
 
  std::string name;
  const gsdml::GSDMLDevice& gsdml;
  MacAddress deviceMac{};
  rt::IOCRConfig inputIocr;
  rt::IOCRConfig outputIocr;
  VirtualAumaValveConfiguration config;
  io::IoSignalCatalog catalog;
 
  std::unique_ptr<InMemoryEthernetSocket> socket;
  std::jthread worker;
  std::atomic<bool> running{false};
 
  mutable std::mutex stateMutex;
  VirtualAumaScenario scenario = VirtualAumaScenario::Normal;
  std::uint16_t position = 0;
  std::uint16_t targetPosition = 0;
  double commandSpeed = 1.0;
  bool opening = false;
  bool closing = false;
  bool moving = false;
  bool controllerKnown = false;
  MacAddress controllerMac{};
  std::uint16_t rxCycleCounter = 0;
  std::uint32_t inputFrameNumber = 0;
  std::uint16_t alarmSequence = 1;
  Bytes inputProcessData;
  Bytes outputProcessData;
  std::function<void(const Bytes&)> onFrame;
  std::function<void(const VirtualAumaAlarmEvent&)> onAlarm;
};
 
} // namespace profinet::sim