virtual_auma_valve.cpp

Go to the documentation of this file.

 
 
#include "profinet/sim/virtual_auma_valve.h"
 
#include <algorithm>
#include <cmath>
#include <stdexcept>
#include <string>
#include <string_view>
 
#include "profinet/wire.h"
 
namespace profinet::sim
{
 
namespace
{
 
constexpr std::uint8_t kRtaVersion = 1;
constexpr std::uint8_t kRtaDataPduType = 0x01;
constexpr std::uint8_t kRtaErrorPduType = 0x0F;
constexpr std::uint8_t kRtaAdditionalFlags = 0x90;
constexpr std::uint16_t kAlarmFrameId = rt::FRAME_ID_ALARM_LOW;
constexpr std::uint16_t kMaxPosition = 10000;
 
const gsdml::GSDMLSubmodule& RequireSubmodule(const gsdml::GSDMLDevice& device,
                                              const std::string& moduleId,
                                              const std::string& submoduleId)
{
  const auto* module = device.FindModule(moduleId);
  if (module == nullptr)
  {
    throw std::invalid_argument("AUMA GSDML is missing module '" + moduleId + "'");
  }
 
  const auto inlineIt = module->submodules.find(submoduleId);
  if (inlineIt != module->submodules.end())
  {
    return inlineIt->second;
  }
 
  const auto* submodule = device.FindSubmodule(submoduleId);
  if (submodule == nullptr)
  {
    throw std::invalid_argument("AUMA GSDML is missing submodule '" + submoduleId + "'");
  }
  return *submodule;
}
 
bool ReadMacs(const Bytes& frame, MacAddress& destination, MacAddress& source)
{
  if (frame.size() < 12U)
  {
    return false;
  }
  std::copy_n(frame.begin(), destination.size(), destination.begin());
  std::copy_n(frame.begin() + 6, source.size(), source.begin());
  return true;
}
 
void ValidateRange(const io::IoSignal& signal, const std::size_t dataSize)
{
  if (signal.byteOffset > dataSize || signal.byteLength > dataSize - signal.byteOffset)
  {
    throw std::out_of_range("AUMA signal lies outside its process-data object: " + signal.textId);
  }
}
 
const io::IoSignal* FindSignal(const io::IoSignalCatalog& catalog,
                               const std::string_view textId,
                               const io::IoSignalDirection direction)
{
  const auto& signals = direction == io::IoSignalDirection::Sensor
                            ? catalog.Sensors()
                            : catalog.Actuators();
  const io::IoSignal* result = nullptr;
  for (const auto& signal : signals)
  {
    if (signal.textId != textId)
    {
      continue;
    }
    if (result != nullptr)
    {
      throw std::invalid_argument("AUMA simulator signal is not unique: " + std::string(textId));
    }
    result = &signal;
  }
  return result;
}
 
Bytes BuildRtaEthernetFrame(const MacAddress& destination,
                            const MacAddress& source,
                            const std::uint16_t frameId,
                            const Bytes& rta,
                            const bool vlan)
{
  Bytes frame;
  frame.insert(frame.end(), destination.begin(), destination.end());
  frame.insert(frame.end(), source.begin(), source.end());
  if (vlan)
  {
    wire::PutU16(frame, 0x8100U);
    wire::PutU16(frame, 0xC000U);
  }
  wire::PutU16(frame, rt::ETHERTYPE_PROFINET);
  wire::PutU16(frame, frameId);
  frame.insert(frame.end(), rta.begin(), rta.end());
  return frame;
}
 
} // namespace
 
const char* ToString(const VirtualAumaScenario scenario) noexcept
{
  switch (scenario)
  {
    case VirtualAumaScenario::Normal:
      return "normal";
    case VirtualAumaScenario::Fault:
      return "fault";
    case VirtualAumaScenario::BadIops:
      return "bad-iops";
    case VirtualAumaScenario::NoInput:
      return "no-input";
    case VirtualAumaScenario::SlowValve:
      return "slow-valve";
    case VirtualAumaScenario::Jammed:
      return "jammed";
    case VirtualAumaScenario::InvalidInput:
      return "invalid-input";
    case VirtualAumaScenario::DuplicateInput:
      return "duplicate-input";
    case VirtualAumaScenario::OutOfOrderInput:
      return "out-of-order-input";
  }
  return "unknown";
}
 
VirtualAumaValve::VirtualAumaValve(std::string nameRef,
                                   const gsdml::GSDMLDevice& gsdmlRef,
                                   MacAddress deviceMacRef,
                                   rt::IOCRConfig inputIocrRef,
                                   rt::IOCRConfig outputIocrRef,
                                   VirtualAumaValveConfiguration configRef)
    : name(std::move(nameRef)),
      gsdml(gsdmlRef),
      deviceMac(deviceMacRef),
      inputIocr(std::move(inputIocrRef)),
      outputIocr(std::move(outputIocrRef)),
      config(std::move(configRef)),
      catalog(io::IoSignalCatalog::FromGsdml(this->gsdml)),
      position(this->config.initialPosition),
      targetPosition(this->config.initialPosition)
{
  const auto* inputSubmodule =
      &RequireSubmodule(this->gsdml, "ID_MODULE_ADI_IN_0", "ID_SUBMOD_ADI_IN_0");
  const auto* outputSubmodule =
      &RequireSubmodule(this->gsdml, "ID_MODULE_ADI_OUT_0", "ID_SUBMOD_ADI_OUT_0");
 
  (void)RequireSignal(config.actualPosition, io::IoSignalDirection::Sensor);
  (void)RequireSignal(config.openCommand, io::IoSignalDirection::Actuator);
  (void)RequireSignal(config.closeCommand, io::IoSignalDirection::Actuator);
  (void)RequireSignal(config.stopCommand, io::IoSignalDirection::Actuator);
 
  if (config.initialPosition > kMaxPosition)
  {
    throw std::invalid_argument("AUMA initial position must be in range 0..10000");
  }
  if (config.travelUnitsPerSecond <= 0.0)
  {
    throw std::invalid_argument("AUMA travelUnitsPerSecond must be greater than zero");
  }
  if (config.slowValveMultiplier <= 0.0 || config.slowValveMultiplier > 1.0)
  {
    throw std::invalid_argument("AUMA slowValveMultiplier must be in (0, 1]");
  }
 
  if (inputIocr.dataLength < static_cast<std::uint16_t>(inputSubmodule->inputLength) ||
      outputIocr.dataLength < static_cast<std::uint16_t>(outputSubmodule->outputLength))
  {
    throw std::invalid_argument("AUMA IOCR data length is smaller than the GSDML process data");
  }
 
  const auto hasInputObject = std::any_of(
      inputIocr.objects.begin(),
      inputIocr.objects.end(),
      [this, &inputSubmodule](const rt::IODataObject& object)
  {
    return object.slot == this->config.inputSlot && object.subslot == this->config.inputSubslot &&
           object.dataLength == inputSubmodule->inputLength &&
           object.offsetIOPS < this->inputIocr.dataLength;
  });
  const auto hasOutputObject = std::any_of(
      outputIocr.objects.begin(),
      outputIocr.objects.end(),
      [this, &outputSubmodule](const rt::IODataObject& object)
  {
    return object.slot == this->config.outputSlot && object.subslot == this->config.outputSubslot &&
           object.dataLength == outputSubmodule->outputLength;
  });
  if (!hasInputObject || !hasOutputObject)
  {
    throw std::invalid_argument("AUMA IOCRs do not contain the configured slot 1/1 and 2/1 objects");
  }
 
  inputProcessData.resize(static_cast<std::size_t>(inputSubmodule->inputLength), 0U);
  outputProcessData.resize(static_cast<std::size_t>(outputSubmodule->outputLength), 0U);
  BuildInputProcessData();
}
 
VirtualAumaValve::~VirtualAumaValve()
{
  Stop();
}
 
void VirtualAumaValve::Start(InMemoryEthernetBus& bus)
{
  if (running.exchange(true))
  {
    return;
  }
 
  try
  {
    {
      std::lock_guard<std::mutex> lock(stateMutex);
      controllerKnown = false;
      controllerMac = {};
      rxCycleCounter = 0U;
      inputFrameNumber = 0U;
      alarmSequence = 1U;
    }
    socket = bus.CreateSocket(deviceMac);
    socket->SetTimeout(std::chrono::milliseconds(1));
    worker = std::jthread([this]
    {
      Run();
    });
  }
  catch (...)
  {
    running = false;
    socket.reset();
    throw;
  }
}
 
void VirtualAumaValve::Stop()
{
  if (!running.exchange(false))
  {
    return;
  }
  if (socket != nullptr)
  {
    socket->SetTimeout(std::chrono::milliseconds(1));
  }
  if (worker.joinable())
  {
    worker.join();
  }
  socket.reset();
}
 
void VirtualAumaValve::SetScenario(const VirtualAumaScenario newScenario)
{
  VirtualAumaScenario oldScenario;
  {
    std::lock_guard<std::mutex> lock(stateMutex);
    oldScenario = scenario;
    scenario = newScenario;
    if (newScenario == VirtualAumaScenario::Fault || newScenario == VirtualAumaScenario::Jammed)
    {
      moving = false;
    }
    if (newScenario == VirtualAumaScenario::Normal &&
        (opening || closing) && position != targetPosition)
    {
      moving = true;
    }
  }
 
  if (newScenario != oldScenario && newScenario != VirtualAumaScenario::Normal)
  {
    EmitScenarioAlarms(newScenario);
  }
}
 
VirtualAumaScenario VirtualAumaValve::Scenario() const noexcept
{
  std::lock_guard<std::mutex> lock(stateMutex);
  return scenario;
}
 
std::uint16_t VirtualAumaValve::Position() const noexcept
{
  std::lock_guard<std::mutex> lock(stateMutex);
  return position;
}
 
std::uint16_t VirtualAumaValve::TargetPosition() const noexcept
{
  std::lock_guard<std::mutex> lock(stateMutex);
  return targetPosition;
}
 
bool VirtualAumaValve::FaultActive() const noexcept
{
  std::lock_guard<std::mutex> lock(stateMutex);
  return scenario == VirtualAumaScenario::Fault || scenario == VirtualAumaScenario::Jammed;
}
 
bool VirtualAumaValve::Moving() const noexcept
{
  std::lock_guard<std::mutex> lock(stateMutex);
  return moving;
}
 
const std::string& VirtualAumaValve::Name() const noexcept
{
  return name;
}
 
const MacAddress& VirtualAumaValve::DeviceMac() const noexcept
{
  return deviceMac;
}
 
std::uint16_t VirtualAumaValve::InputSlot() const noexcept
{
  return config.inputSlot;
}
 
std::uint16_t VirtualAumaValve::InputSubslot() const noexcept
{
  return config.inputSubslot;
}
 
std::uint16_t VirtualAumaValve::OutputSlot() const noexcept
{
  return config.outputSlot;
}
 
std::uint16_t VirtualAumaValve::OutputSubslot() const noexcept
{
  return config.outputSubslot;
}
 
const io::IoSignalCatalog& VirtualAumaValve::SignalCatalog() const noexcept
{
  return catalog;
}
 
void VirtualAumaValve::OnFrame(std::function<void(const Bytes&)> callback)
{
  std::lock_guard<std::mutex> lock(stateMutex);
  onFrame = std::move(callback);
}
 
void VirtualAumaValve::OnAlarm(std::function<void(const VirtualAumaAlarmEvent&)> callback)
{
  std::lock_guard<std::mutex> lock(stateMutex);
  onAlarm = std::move(callback);
}
 
Bytes VirtualAumaValve::InputProcessData() const
{
  std::lock_guard<std::mutex> lock(stateMutex);
  return inputProcessData;
}
 
Bytes VirtualAumaValve::OutputProcessData() const
{
  std::lock_guard<std::mutex> lock(stateMutex);
  return outputProcessData;
}
 
void VirtualAumaValve::Run()
{
  auto last = std::chrono::steady_clock::now();
  const auto cycle = std::chrono::microseconds(inputIocr.CycleTimeUs());
  auto nextInput = last;
 
  while (running)
  {
    if (socket != nullptr)
    {
      const Bytes frame = socket->Recv();
      if (!frame.empty())
      {
        ProcessOutputFrame(frame);
      }
    }
 
    const auto now = std::chrono::steady_clock::now();
    if (now >= nextInput)
    {
      const double elapsed = std::max(0.0, std::chrono::duration<double>(now - last).count());
      last = now;
      UpdateProcessModel(elapsed);
      SendInputFrame();
      nextInput += cycle;
      if (nextInput < now)
      {
        nextInput = now + cycle;
      }
    }
  }
}
 
void VirtualAumaValve::ProcessOutputFrame(const Bytes& frame)
{
  MacAddress destination{};
  MacAddress source{};
  if (!ReadMacs(frame, destination, source) || destination != deviceMac)
  {
    return;
  }
 
  const auto parsed = rt::ParseEthernetFrame(frame);
  if (!parsed.has_value() || parsed->frameId != outputIocr.frameId ||
      !parsed->IsValid() || parsed->transferStatus != 0U)
  {
    return;
  }
 
  Bytes processData;
  for (const auto& object : outputIocr.objects)
  {
    if (object.slot != config.outputSlot || object.subslot != config.outputSubslot ||
        object.dataLength == 0U)
    {
      continue;
    }
    const std::size_t offset = object.frameOffset;
    if (offset > parsed->payload.size() || object.dataLength > parsed->payload.size() - offset)
    {
      return;
    }
    processData.assign(parsed->payload.begin() + static_cast<std::ptrdiff_t>(offset),
                       parsed->payload.begin() +
                           static_cast<std::ptrdiff_t>(offset + object.dataLength));
    break;
  }
 
  if (processData.empty())
  {
    return;
  }
 
  {
    std::lock_guard<std::mutex> lock(stateMutex);
    if (controllerKnown && controllerMac != source)
    {
      return;
    }
    controllerMac = source;
    controllerKnown = true;
    outputProcessData = processData;
  }
 
  if ((parsed->dataStatus & rt::DATA_STATUS_PROVIDER_RUN) == 0U)
  {
    std::lock_guard<std::mutex> lock(stateMutex);
    opening = false;
    closing = false;
    moving = false;
    return;
  }
 
  DecodeCommands(processData);
}
 
void VirtualAumaValve::DecodeCommands(const Bytes& outputData)
{
  const bool open = ReadBitSignal(outputData, config.openCommand);
  const bool close = ReadBitSignal(outputData, config.closeCommand);
  const bool stop = ReadBitSignal(outputData, config.stopCommand);
 
  std::optional<std::uint16_t> setpoint;
  if (FindSignal(catalog, config.positionSetpoint, io::IoSignalDirection::Actuator) != nullptr)
  {
    const auto raw = ReadScalarSignal(outputData, config.positionSetpoint);
    // Treat a non-zero setpoint as an explicit absolute target. Zero remains
    // the neutral/default value so OPEN/CLOSE still mean end-stop travel.
    if (raw != 0U)
    {
      setpoint = static_cast<std::uint16_t>(std::min<std::uint64_t>(raw, kMaxPosition));
    }
  }
 
  double speed = 1.0;
  if (FindSignal(catalog, config.speedSetpoint, io::IoSignalDirection::Actuator) != nullptr)
  {
    const auto raw = ReadScalarSignal(outputData, config.speedSetpoint);
    if (raw != 0U)
    {
      speed = std::clamp(static_cast<double>(raw) / 100.0, 0.01, 1.0);
    }
  }
 
  std::lock_guard<std::mutex> lock(stateMutex);
  commandSpeed = speed;
  if (setpoint.has_value())
  {
    targetPosition = *setpoint;
  }
 
  if (stop || (open && close))
  {
    opening = false;
    closing = false;
    moving = false;
    return;
  }
 
  opening = open;
  closing = close;
  if (open && !setpoint.has_value())
  {
    targetPosition = kMaxPosition;
  }
  if (close && !setpoint.has_value())
  {
    targetPosition = 0U;
  }
  moving = (opening != closing) && scenario != VirtualAumaScenario::Fault &&
           scenario != VirtualAumaScenario::Jammed && position != targetPosition;
}
 
void VirtualAumaValve::UpdateProcessModel(const double elapsedSeconds)
{
  std::lock_guard<std::mutex> lock(stateMutex);
 
  if (scenario == VirtualAumaScenario::Jammed || scenario == VirtualAumaScenario::Fault || !moving)
  {
    moving = false;
    BuildInputProcessData();
    return;
  }
 
  const double multiplier = scenario == VirtualAumaScenario::SlowValve
                                ? config.slowValveMultiplier
                                : 1.0;
  const double delta = config.travelUnitsPerSecond * commandSpeed * multiplier * elapsedSeconds;
 
  if (opening)
  {
    const auto next = static_cast<std::uint16_t>(
        std::min<double>(kMaxPosition, static_cast<double>(position) + delta));
    position = next;
  }
  else if (closing)
  {
    const auto next = static_cast<std::uint16_t>(
        std::max<double>(0.0, static_cast<double>(position) - delta));
    position = next;
  }
 
  if (position == targetPosition || (!opening && !closing))
  {
    moving = false;
  }
  BuildInputProcessData();
}
 
void VirtualAumaValve::BuildInputProcessData()
{
  std::fill(inputProcessData.begin(), inputProcessData.end(), 0U);
 
  const bool fault = scenario == VirtualAumaScenario::Fault ||
                     scenario == VirtualAumaScenario::Jammed;
  const bool warning = scenario == VirtualAumaScenario::SlowValve;
 
  SetScalarSignal(inputProcessData, config.actualPosition, position);
  SetBitSignal(inputProcessData, config.faultSignal, fault);
  SetBitSignal(inputProcessData, config.warningSignal, warning);
  SetBitSignal(inputProcessData, "T_ID_OPERATIONSTATUS_0", opening);
  SetBitSignal(inputProcessData, "T_ID_OPERATIONSTATUS_1", closing);
  SetBitSignal(inputProcessData, "T_ID_OPERATIONSTATUS_2", moving);
  SetBitSignal(inputProcessData, "T_ID_OPERATIONSTATUS_3", position == 0U);
  SetBitSignal(inputProcessData, "T_ID_OPERATIONSTATUS_4", position == kMaxPosition);
  SetScalarSignal(inputProcessData, "T_ID_RPM",
                  static_cast<std::uint64_t>(moving
                                                 ? std::clamp(commandSpeed * 100.0, 1.0, 100.0)
                                                 : 0.0));
}
 
const io::IoSignal& VirtualAumaValve::RequireSignal(const std::string_view textId,
                                                    const io::IoSignalDirection direction) const
{
  const auto* signal = FindSignal(catalog, textId, direction);
  if (signal == nullptr)
  {
    throw std::invalid_argument("AUMA simulator cannot find signal '" + std::string(textId) + "'");
  }
  return *signal;
}
 
void VirtualAumaValve::SetBitSignal(Bytes& data,
                                    const std::string_view textId,
                                    const bool value) const
{
  const auto* signal = FindSignal(catalog, textId, io::IoSignalDirection::Sensor);
  if (signal == nullptr)
  {
    return;
  }
  ValidateRange(*signal, data.size());
  if (signal->bitSignal)
  {
    if (signal->bitOffset >= 8U)
    {
      throw std::out_of_range("AUMA bit signal has invalid bit offset: " + signal->textId);
    }
    const auto mask = static_cast<std::uint8_t>(1U << signal->bitOffset);
    if (value)
    {
      data[signal->byteOffset] |= mask;
    }
    else
    {
      data[signal->byteOffset] &= static_cast<std::uint8_t>(~mask);
    }
    return;
  }
  if (signal->byteLength != 1U)
  {
    throw std::invalid_argument("AUMA Boolean signal is wider than one byte: " + signal->textId);
  }
  data[signal->byteOffset] = value ? 1U : 0U;
}
 
void VirtualAumaValve::SetScalarSignal(Bytes& data,
                                       const std::string_view textId,
                                       const std::uint64_t value) const
{
  const auto* signal = FindSignal(catalog, textId, io::IoSignalDirection::Sensor);
  if (signal == nullptr)
  {
    return;
  }
  ValidateRange(*signal, data.size());
  if (signal->bitSignal || signal->byteLength == 0U || signal->byteLength > sizeof(std::uint64_t))
  {
    throw std::invalid_argument("Invalid AUMA scalar signal: " + signal->textId);
  }
 
  for (std::size_t index = 0; index < signal->byteLength; ++index)
  {
    const std::size_t shift = (signal->byteLength - 1U - index) * 8U;
    data[signal->byteOffset + index] =
        static_cast<std::uint8_t>((value >> shift) & 0xFFU);
  }
}
 
bool VirtualAumaValve::ReadBitSignal(const Bytes& data, const std::string_view textId) const
{
  const auto& signal = RequireSignal(textId, io::IoSignalDirection::Actuator);
  ValidateRange(signal, data.size());
  if (signal.bitSignal)
  {
    if (signal.bitOffset >= 8U)
    {
      throw std::out_of_range("AUMA bit signal has invalid bit offset: " + signal.textId);
    }
    return (data[signal.byteOffset] & static_cast<std::uint8_t>(1U << signal.bitOffset)) != 0U;
  }
  return data[signal.byteOffset] != 0U;
}
 
std::uint64_t VirtualAumaValve::ReadScalarSignal(const Bytes& data,
                                                 const std::string_view textId) const
{
  const auto& signal = RequireSignal(textId, io::IoSignalDirection::Actuator);
  ValidateRange(signal, data.size());
  if (signal.bitSignal)
  {
    return ReadBitSignal(data, textId) ? 1U : 0U;
  }
  if (signal.byteLength == 0U || signal.byteLength > sizeof(std::uint64_t))
  {
    throw std::invalid_argument("AUMA scalar is outside uint64_t range: " + signal.textId);
  }
 
  std::uint64_t value = 0;
  for (std::size_t index = 0; index < signal.byteLength; ++index)
  {
    value = (value << 8U) | data[signal.byteOffset + index];
  }
  return value;
}
 
void VirtualAumaValve::SendInputFrame()
{
  VirtualAumaScenario localScenario;
  MacAddress destination{};
  Bytes processData;
  {
    std::lock_guard<std::mutex> lock(stateMutex);
    localScenario = scenario;
    processData = inputProcessData;
    if (!controllerKnown)
    {
      return;
    }
    destination = controllerMac;
  }
 
  if (localScenario == VirtualAumaScenario::NoInput || socket == nullptr)
  {
    return;
  }
 
  Bytes payload(inputIocr.dataLength, 0U);
  bool mapped = false;
  for (const auto& object : inputIocr.objects)
  {
    if (object.slot != config.inputSlot || object.subslot != config.inputSubslot ||
        object.dataLength == 0U)
    {
      continue;
    }
    if (object.frameOffset > payload.size() ||
        object.dataLength > payload.size() - object.frameOffset ||
        object.dataLength > processData.size())
    {
      return;
    }
    std::copy(processData.begin(),
              processData.begin() + static_cast<std::ptrdiff_t>(object.dataLength),
              payload.begin() + object.frameOffset);
    if (object.offsetIOPS < payload.size())
    {
      payload[*object.offsetIOPS] =
          (localScenario == VirtualAumaScenario::BadIops ||
           localScenario == VirtualAumaScenario::Fault)
              ? rt::IOXS_BAD
              : rt::IOXS_GOOD;
    }
    mapped = true;
    break;
  }
  if (!mapped)
  {
    return;
  }
 
  const std::uint32_t step = static_cast<std::uint32_t>(inputIocr.sendClockFactor) *
                             inputIocr.reductionRatio;
  std::uint16_t cycleCounter = 0;
  VirtualAumaScenario counterScenario = VirtualAumaScenario::Normal;
  {
    std::lock_guard<std::mutex> lock(stateMutex);
    ++inputFrameNumber;
    counterScenario = scenario;
    if (counterScenario != VirtualAumaScenario::DuplicateInput)
    {
      rxCycleCounter = static_cast<std::uint16_t>((rxCycleCounter + step) & 0xFFFFU);
    }
    if (counterScenario == VirtualAumaScenario::OutOfOrderInput && inputFrameNumber % 4U == 0U)
    {
      rxCycleCounter = static_cast<std::uint16_t>((rxCycleCounter - (2U * step)) & 0xFFFFU);
    }
    cycleCounter = rxCycleCounter;
  }
 
  rt::RTFrame frame;
  frame.frameId = inputIocr.frameId;
  frame.cycleCounter = cycleCounter;
  frame.dataStatus = static_cast<std::uint8_t>(rt::DATA_STATUS_VALID |
                                               rt::DATA_STATUS_PROVIDER_RUN |
                                               rt::DATA_STATUS_STATION_OK |
                                               rt::DATA_STATUS_STATE);
  if (localScenario == VirtualAumaScenario::InvalidInput)
  {
    frame.dataStatus = static_cast<std::uint8_t>(frame.dataStatus &
                                                 ~rt::DATA_STATUS_VALID);
  }
  frame.transferStatus = 0U;
  frame.payload = std::move(payload);
 
  const Bytes ethernetFrame = rt::BuildEthernetFrame(destination, deviceMac, frame);
  socket->Send(ethernetFrame);
  NotifyFrame(ethernetFrame);
}
 
Bytes VirtualAumaValve::BuildRtaErrorFrame(const std::uint8_t errorCode1,
                                           const std::uint8_t errorCode2) const
{
  MacAddress destination{};
  std::uint16_t destinationReference = config.alarmDestinationReference;
  std::uint16_t sequence = 1;
  {
    std::lock_guard<std::mutex> lock(stateMutex);
    destination = controllerMac;
    sequence = alarmSequence;
  }
 
  if (!controllerKnown)
  {
    return {};
  }
 
  Bytes varPart;
  wire::PutU16(varPart, 0x0000U);
  varPart.push_back(errorCode1);
  varPart.push_back(errorCode2);
 
  Bytes rta;
  wire::PutU16(rta, destinationReference);
  wire::PutU16(rta, config.alarmSourceReference);
  rta.push_back(static_cast<std::uint8_t>((kRtaVersion << 4U) | kRtaErrorPduType));
  rta.push_back(kRtaAdditionalFlags);
  wire::PutU16(rta, sequence);
  wire::PutU16(rta, static_cast<std::uint16_t>(sequence - 1U));
  wire::PutU16(rta, static_cast<std::uint16_t>(varPart.size()));
  rta.insert(rta.end(), varPart.begin(), varPart.end());
 
  return BuildRtaEthernetFrame(destination, deviceMac, kAlarmFrameId, rta, true);
}
 
Bytes VirtualAumaValve::BuildAlarmNotificationBlock(const std::uint16_t alarmSpecifier) const
{
  Bytes body;
  wire::PutU16(body, 0x0001U);
  wire::PutU32(body, config.alarmApi);
  wire::PutU16(body, config.inputSlot);
  wire::PutU16(body, config.inputSubslot);
  wire::PutU32(body, config.alarmModuleIdent);
  wire::PutU32(body, config.alarmSubmoduleIdent);
  wire::PutU16(body, alarmSpecifier);
 
  // Add a standard channel-diagnosis item. This makes the generated alarm
  // useful for both AlarmNotification parsing and diagnosis handling tests.
  Bytes item;
  wire::PutU16(item, 0x8000U);
  wire::PutU16(item, 1U);
  wire::PutU16(item, 0x0800U);
  wire::PutU16(item, 9U);
 
  Bytes payload{0x01U, 0x00U};
  payload.insert(payload.end(), body.begin(), body.end());
  payload.insert(payload.end(), item.begin(), item.end());
 
  Bytes block;
  wire::PutU16(block, 0x0002U);
  wire::PutU16(block, static_cast<std::uint16_t>(payload.size()));
  block.insert(block.end(), payload.begin(), payload.end());
  return block;
}
 
void VirtualAumaValve::EmitScenarioAlarms(const VirtualAumaScenario localScenario)
{
  if (socket == nullptr)
  {
    return;
  }
 
  std::uint8_t errorCode2 = 0x81U;
  std::uint16_t alarmSpecifier = 0x0001U;
  switch (localScenario)
  {
    case VirtualAumaScenario::Fault:
      errorCode2 = 0x81U;
      alarmSpecifier = 0x0801U;
      break;
    case VirtualAumaScenario::BadIops:
      errorCode2 = 0x82U;
      alarmSpecifier = 0x0802U;
      break;
    case VirtualAumaScenario::NoInput:
      errorCode2 = 0x83U;
      alarmSpecifier = 0x0803U;
      break;
    case VirtualAumaScenario::SlowValve:
      errorCode2 = 0x84U;
      alarmSpecifier = 0x0804U;
      break;
    case VirtualAumaScenario::Jammed:
      errorCode2 = 0x85U;
      alarmSpecifier = 0x0805U;
      break;
    case VirtualAumaScenario::InvalidInput:
      errorCode2 = 0x86U;
      alarmSpecifier = 0x0806U;
      break;
    case VirtualAumaScenario::DuplicateInput:
      errorCode2 = 0x87U;
      alarmSpecifier = 0x0807U;
      break;
    case VirtualAumaScenario::OutOfOrderInput:
      errorCode2 = 0x88U;
      alarmSpecifier = 0x0808U;
      break;
    case VirtualAumaScenario::Normal:
      return;
  }
 
  VirtualAumaAlarmEvent event;
  event.scenario = localScenario;
  event.errorCode1 = 0xCFU;
  event.errorCode2 = errorCode2;
  event.alarmSpecifier = alarmSpecifier;
 
  if (config.emitRtaError)
  {
    event.rtaErrorFrame = BuildRtaErrorFrame(event.errorCode1, event.errorCode2);
    if (!event.rtaErrorFrame.empty())
    {
      socket->Send(event.rtaErrorFrame);
      NotifyFrame(event.rtaErrorFrame);
    }
  }
 
  if (config.emitAlarmNotification && controllerKnown)
  {
    MacAddress destination{};
    std::uint16_t sequence = 0;
    {
      std::lock_guard<std::mutex> lock(stateMutex);
      destination = controllerMac;
      sequence = alarmSequence;
      ++alarmSequence;
    }
 
    const Bytes block = BuildAlarmNotificationBlock(alarmSpecifier);
    Bytes rta;
    wire::PutU16(rta, config.alarmDestinationReference);
    wire::PutU16(rta, config.alarmSourceReference);
    rta.push_back(static_cast<std::uint8_t>((kRtaVersion << 4U) | kRtaDataPduType));
    rta.push_back(kRtaAdditionalFlags);
    wire::PutU16(rta, sequence);
    wire::PutU16(rta, static_cast<std::uint16_t>(sequence - 1U));
    wire::PutU16(rta, static_cast<std::uint16_t>(block.size()));
    rta.insert(rta.end(), block.begin(), block.end());
 
    event.alarmNotificationFrame =
        BuildRtaEthernetFrame(destination, deviceMac, kAlarmFrameId, rta, true);
    socket->Send(event.alarmNotificationFrame);
    NotifyFrame(event.alarmNotificationFrame);
  }
 
  NotifyAlarm(event);
}
 
void VirtualAumaValve::NotifyFrame(const Bytes& frame) const
{
  std::function<void(const Bytes&)> callback;
  {
    std::lock_guard<std::mutex> lock(stateMutex);
    callback = onFrame;
  }
  if (callback)
  {
    try
    {
      callback(frame);
    }
    catch (...)
    {
      // A simulator callback must never terminate the device worker thread.
    }
  }
}
 
void VirtualAumaValve::NotifyAlarm(const VirtualAumaAlarmEvent& event) const
{
  std::function<void(const VirtualAumaAlarmEvent&)> callback;
  {
    std::lock_guard<std::mutex> lock(stateMutex);
    callback = onAlarm;
  }
  if (callback)
  {
    try
    {
      callback(event);
    }
    catch (...)
    {
      // A simulator callback must never terminate the device worker thread.
    }
  }
}
 
} // namespace profinet::sim