virtual_auma_config.cpp

Go to the documentation of this file.

 
 
#include "profinet/sim/virtual_auma_config.h"
 
#include <algorithm>
#include <stdexcept>
#include <string>
 
namespace profinet::sim
{
 
namespace
{
 
const gsdml::GSDMLSubmodule& RequireAumaSubmodule(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 simulator 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 simulator GSDML is missing submodule: " + submoduleId);
  }
  return *submodule;
}
 
std::uint16_t ResolveFixedSlot(const gsdml::GSDMLDevice& device,
                               const std::string& moduleId,
                               const std::uint16_t fallback)
{
  for (const auto& reference : device.moduleReferences)
  {
    if (reference.moduleId == moduleId && !reference.fixedSlots.empty())
    {
      return static_cast<std::uint16_t>(reference.fixedSlots.front());
    }
  }
  return fallback;
}
 
std::uint16_t ResolveFixedSubslot(const gsdml::GSDMLSubmodule& submodule,
                                  const std::uint16_t fallback)
{
  if (!submodule.fixedSubslots.empty())
  {
    return static_cast<std::uint16_t>(submodule.fixedSubslots.front());
  }
  return fallback;
}
 
std::uint16_t ResolveModuleReferenceSubslot(const gsdml::GSDMLModule& module,
                                            const std::string& submoduleId,
                                            const std::uint16_t fallback)
{
  for (const auto& reference : module.submoduleReferences)
  {
    if (reference.submoduleId == submoduleId && !reference.fixedSubslots.empty())
    {
      return static_cast<std::uint16_t>(reference.fixedSubslots.front());
    }
  }
  return fallback;
}
 
}  // namespace
 
VirtualAumaIocrConfiguration MakeVirtualAumaIocrConfiguration(
    const gsdml::GSDMLDevice& device,
    const std::uint16_t inputFrameId,
    const std::uint16_t outputFrameId,
    const std::uint16_t sendClockFactor,
    const std::uint16_t reductionRatio,
    const std::uint16_t watchdogFactor,
    const std::uint16_t dataHoldFactor)
{
  const auto* inputModule = device.FindModule("ID_MODULE_ADI_IN_0");
  const auto* outputModule = device.FindModule("ID_MODULE_ADI_OUT_0");
  if (inputModule == nullptr || outputModule == nullptr)
  {
    throw std::invalid_argument("AUMA GSDML does not contain the expected ADI modules");
  }
 
  const auto* input = &RequireAumaSubmodule(device, inputModule->id, "ID_SUBMOD_ADI_IN_0");
  const auto* output = &RequireAumaSubmodule(device, outputModule->id, "ID_SUBMOD_ADI_OUT_0");
 
  if (input->inputLength <= 0 || output->outputLength <= 0)
  {
    throw std::invalid_argument("AUMA simulator GSDML contains empty process-data modules");
  }
 
  const auto inputSlot = ResolveFixedSlot(device, inputModule->id, 1U);
  const auto outputSlot = ResolveFixedSlot(device, outputModule->id, 2U);
  const auto inputSubslot = ResolveModuleReferenceSubslot(
      *inputModule, input->id, ResolveFixedSubslot(*input, 1U));
  const auto outputSubslot = ResolveModuleReferenceSubslot(
      *outputModule, output->id, ResolveFixedSubslot(*output, 1U));
 
  // The real AUMA SGx GSDML uses 43-byte input and 25-byte output C_SDU limits.
  // The parser currently exposes the module process-data lengths but not the
  // DAP IOConfigData MaxInputLength/MaxOutputLength attributes, so these defaults
  // remain explicit and can be overridden by changing the IOCRs supplied to the
  // simulator constructor.
  constexpr std::uint16_t kAumaInputCsduLength = 43U;
  constexpr std::uint16_t kAumaOutputCsduLength = 25U;
 
  VirtualAumaIocrConfiguration result;
 
  result.input.typeIOCR = rt::IOCR_TYPE_INPUT;
  result.input.referenceIOCR = 1U;
  result.input.frameId = inputFrameId;
  result.input.sendClockFactor = sendClockFactor;
  result.input.reductionRatio = reductionRatio;
  result.input.watchdogFactor = watchdogFactor;
  result.input.dataLength =
      std::max<std::uint16_t>(kAumaInputCsduLength,
                              static_cast<std::uint16_t>(input->inputLength + 1));
  result.input.objects = {
      {
          inputSlot,
          inputSubslot,
          0U,
          static_cast<std::uint16_t>(input->inputLength),
          static_cast<std::uint16_t>(input->inputLength),
          {},
      },
  };
 
  result.output.typeIOCR = rt::IOCR_TYPE_OUTPUT;
  result.output.referenceIOCR = 2U;
  result.output.frameId = outputFrameId;
  result.output.sendClockFactor = sendClockFactor;
  result.output.reductionRatio = reductionRatio;
  result.output.watchdogFactor = watchdogFactor;
  result.output.dataLength =
      std::max<std::uint16_t>(kAumaOutputCsduLength,
                              static_cast<std::uint16_t>(output->outputLength + 9));
  result.output.objects = {
      {
          outputSlot,
          outputSubslot,
          8U,
          static_cast<std::uint16_t>(output->outputLength),
          static_cast<std::uint16_t>(output->outputLength + 8),
          {},
      },
  };
 
  // dataHoldFactor is serialized by rpc::RPCCon::BuildIocrBlock through the
  // higher-level rpc::IOCRSetup. rt::IOCRConfig models the cyclic data layout only.
  (void)dataHoldFactor;
 
  return result;
}
 
}  // namespace profinet::sim