virtual_sim_test_helpers.h

Go to the documentation of this file.

 
#pragma once
 
#include <chrono>
#include <cstddef>
#include <cstdint>
#include <functional>
#include <string>
#include <thread>
 
#include "profinet/gsdml.h"
#include "profinet/sim/virtual_auma_config.h"
#include "profinet/util.h"
 
namespace profinet::sim::test
{
 
inline constexpr MacAddress kControllerMac{0x02, 0x00, 0x00, 0x10, 0x00, 0x01};
inline constexpr MacAddress kValveMac{0x02, 0x00, 0x00, 0x20, 0x00, 0x01};
 
inline gsdml::GSDMLDataItem MakeScalarItem(const std::string& dataType,
                                           const int length,
                                           const std::string& textId)
{
  gsdml::GSDMLDataItem item;
  item.dataType = dataType;
  item.length = length;
  item.textId = textId;
  return item;
}
 
inline gsdml::GSDMLDataItem MakeBitByte(const std::string& parentTextId,
                                        const std::string& bitPrefix)
{
  auto item = MakeScalarItem("Unsigned8", 1, parentTextId);
  item.useAsBits = true;
  for (std::uint8_t bit = 0; bit < 8U; ++bit)
  {
    item.bitDataItems.push_back({bit, bitPrefix + std::to_string(bit)});
  }
  return item;
}
 
inline gsdml::GSDMLDevice MakeAumaGsdml()
{
  gsdml::GSDMLDevice device;
  device.vendorId = 0x013FU;
  device.deviceId = 0x0002U;
  device.deviceName = "Auma-SGx-Test";
  device.dapModuleId = "DAP";
 
  gsdml::GSDMLModule inputModule;
  inputModule.id = "ID_MODULE_ADI_IN_0";
  inputModule.moduleIdentNumber = 0x00008000U;
 
  gsdml::GSDMLSubmodule inputSubmodule;
  inputSubmodule.id = "ID_SUBMOD_ADI_IN_0";
  inputSubmodule.submoduleIdentNumber = 0x00002200U;
  inputSubmodule.fixedSubslots = {1};
  inputSubmodule.inputItems = {
      MakeBitByte("T_ID_LOG", "T_ID_LOG_"),
      MakeBitByte("T_ID_DRV", "T_ID_DRV_"),
      MakeScalarItem("Unsigned16", 2, "T_ID_ACTPOS_E2"),
      MakeBitByte("T_ID_DEVICESTATUS", "T_ID_DEVICESTATUS_"),
      MakeBitByte("T_ID_OPERATIONSTATUS", "T_ID_OPERATIONSTATUS_"),
      MakeBitByte("T_ID_WARNING1", "T_ID_WARNING1_"),
      MakeBitByte("T_ID_FAULT1", "T_ID_FAULT1_"),
      MakeScalarItem("Unsigned8", 1, "T_ID_RPM"),
      MakeScalarItem("Unsigned8", 1, "T_ID_RESERVE_INPUT"),
  };
  inputSubmodule.inputLength = 9;
  inputModule.submodules.emplace(inputSubmodule.id, inputSubmodule);
  device.modules.emplace(inputModule.id, inputModule);
 
  gsdml::GSDMLModule outputModule;
  outputModule.id = "ID_MODULE_ADI_OUT_0";
  outputModule.moduleIdentNumber = 0x00008100U;
 
  gsdml::GSDMLSubmodule outputSubmodule;
  outputSubmodule.id = "ID_SUBMOD_ADI_OUT_0";
  outputSubmodule.submoduleIdentNumber = 0x10001000U;
  outputSubmodule.fixedSubslots = {1};
  outputSubmodule.outputItems = {
      MakeBitByte("T_ID_CMD", "T_ID_CMD_"),
      MakeScalarItem("Unsigned8", 1, "T_ID_SPEEDSETPOINT"),
      MakeScalarItem("Unsigned16", 2, "T_ID_POSITIONSETPOINT"),
      MakeBitByte("T_ID_ADDCMD", "T_ID_ADDCMD_"),
      MakeBitByte("T_ID_DIRPOS", "T_ID_DIRPOS_"),
      MakeScalarItem("Unsigned8", 1, "T_ID_RESERVE_OUTPUT"),
  };
  outputSubmodule.outputLength = 7;
  outputModule.submodules.emplace(outputSubmodule.id, outputSubmodule);
  device.modules.emplace(outputModule.id, outputModule);
 
  gsdml::GSDMLModuleReference inputReference;
  inputReference.moduleId = inputModule.id;
  inputReference.fixedSlots = {1};
  device.moduleReferences.push_back(inputReference);
 
  gsdml::GSDMLModuleReference outputReference;
  outputReference.moduleId = outputModule.id;
  outputReference.fixedSlots = {2};
  device.moduleReferences.push_back(outputReference);
 
  return device;
}
 
inline gsdml::GSDMLDevice MakePhoenixGsdml()
{
  gsdml::GSDMLDevice device;
  device.vendorId = 0x00B0U;
  device.deviceId = 0x0193U;
  device.deviceName = "AXC-F-1252-Test";
  device.dapModuleId = "DIM 1";
 
  gsdml::GSDMLModule module;
  module.id = "PNSlot1";
  module.moduleIdentNumber = 0x00000001U;
 
  gsdml::GSDMLSubmodule submodule;
  submodule.id = "PNIO0202";
  submodule.submoduleIdentNumber = 0x00000009U;
  submodule.fixedSubslots = {1};
  submodule.inputItems = {
      MakeScalarItem("Unsigned32", 4, "DI4"),
      MakeScalarItem("Integer16", 2, "TEMPERATURE"),
      MakeScalarItem("Float32", 4, "LEVEL"),
      MakeBitByte("DI_STATUS", "DI_STATUS_"),
      MakeScalarItem("VisibleString", 2, "RAW_STATUS"),
  };
  submodule.outputItems = {
      MakeScalarItem("Unsigned32", 4, "DO4"),
      MakeScalarItem("Float32", 4, "SETPOINT"),
      MakeBitByte("DO_STATUS", "DO_STATUS_"),
  };
  submodule.inputLength = 13;
  submodule.outputLength = 9;
  module.submodules.emplace(submodule.id, submodule);
  device.modules.emplace(module.id, module);
 
  gsdml::GSDMLModuleReference reference;
  reference.moduleId = module.id;
  reference.fixedSlots = {1};
  device.moduleReferences.push_back(reference);
 
  return device;
}
 
inline VirtualAumaIocrConfiguration MakeTestAumaIocrs(const gsdml::GSDMLDevice& device)
{
  auto result = MakeVirtualAumaIocrConfiguration(device, 0x9000U, 0x8001U, 32U, 8U, 3U, 3U);
  result.input.dataLength = 16U;
  result.output.dataLength = 16U;
  result.input.objects[0].frameOffset = 0U;
  result.input.objects[0].offsetIOPS = 9U;
  result.output.objects[0].frameOffset = 0U;
  result.output.objects[0].offsetIOPS = 7U;
  return result;
}
 
inline bool WaitUntil(const std::function<bool()>& predicate,
                      std::chrono::milliseconds timeout = std::chrono::milliseconds(500))
{
  const auto deadline = std::chrono::steady_clock::now() + timeout;
  while (std::chrono::steady_clock::now() < deadline)
  {
    if (predicate())
    {
      return true;
    }
    std::this_thread::sleep_for(std::chrono::milliseconds(2));
  }
  return predicate();
}
 
inline MacAddress MakeIndexedMac(const std::uint8_t prefix, const std::size_t index)
{
  return MacAddress{0x02, 0x00, 0x00, prefix,
                    static_cast<std::uint8_t>((index >> 8U) & 0xFFU),
                    static_cast<std::uint8_t>(index & 0xFFU)};
}
 
} // namespace profinet::sim::test