test_virtual_gsdmlIntegrationMore.cpp

Go to the documentation of this file.

 
 
#include <gtest/gtest.h>
 
#include <algorithm>
#include <chrono>
#include <cstdlib>
#include <functional>
#include <stdexcept>
#include <string>
#include <thread>
#include <vector>
 
#include "profinet/alarms.h"
#include "profinet/gsdml.h"
#include "profinet/sim/virtual_auma_config.h"
#include "profinet/sim/virtual_auma_valve.h"
#include "profinet/sim/virtual_phoenix_plc.h"
#include "virtual_sim_test_helpers.h"
 
namespace profinet::sim
{
 
namespace
{
constexpr char kAumaGsdml[] = "GSDML-V2.42-AUMA-SGX-20220920.xml";
constexpr char kPhoenixGsdml[] = "GSDML-V2.45-Phoenix Contact-AXC F 1252-20250813.xml";
 
std::string GetGsdmlLocation(const std::string& fileName)
{
  const std::array<std::filesystem::path, 4> candidates{
      GetExecutableDirectory() / "gsdml" / fileName,
      GetExecutableDirectory() / "tests" / "gsdml" / fileName,
      std::filesystem::current_path() / "tests" / "gsdml" / fileName,
      std::filesystem::current_path() / "gsdml" / fileName};
 
  for (const auto& candidate : candidates)
  {
    if (std::filesystem::exists(candidate))
    {
      return candidate.string();
    }
  }
 
  ADD_FAILURE() << "GSDML fixture not found: " << fileName;
  return {};
}
std::string AumaGsdmlPath()
{
  return GetGsdmlLocation(kAumaGsdml);
}
 
std::string PhoenixGsdmlPath()
{
  return GetGsdmlLocation(kPhoenixGsdml);
}
 
bool WaitUntil(const std::function<bool()>& predicate,
               const std::chrono::milliseconds timeout = std::chrono::milliseconds(1000))
{
  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(5));
  }
  return predicate();
}
 
} // namespace
 
TEST(VirtualRealGsdmlIntegrationTests, ParsesRealAumaGsdmlAndBuildsSignalCatalog)
{
  const std::string path = AumaGsdmlPath();
  if (path.empty())
  {
    GTEST_SKIP() << "Set PROFINET_AUMA_GSDML to run the real AUMA integration test";
  }
 
  const auto device = gsdml::ParseGsdml(path);
  EXPECT_EQ(device.vendorId, 0x013FU);
  EXPECT_EQ(device.deviceId, 0x0002U);
 
  const auto catalog = io::IoSignalCatalog::FromGsdml(device);
  EXPECT_NE(std::find_if(catalog.Sensors().begin(), catalog.Sensors().end(),
                         [](const auto& signal)
  { return signal.textId == "T_ID_ACTPOS_E2"; }),
            catalog.Sensors().end());
  EXPECT_NE(std::find_if(catalog.Actuators().begin(), catalog.Actuators().end(),
                         [](const auto& signal)
  { return signal.textId == "T_ID_CMD_0"; }),
            catalog.Actuators().end());
}
 
TEST(VirtualRealGsdmlIntegrationTests, ParsesRealPhoenixGsdmlAndBuildsSignalCatalog)
{
  const std::string path = PhoenixGsdmlPath();
  if (path.empty())
  {
    GTEST_SKIP() << "Set PROFINET_PHOENIX_GSDML to run the real Phoenix integration test";
  }
 
  const auto device = gsdml::ParseGsdml(path);
  EXPECT_EQ(device.vendorId, 0x00B0U);
  EXPECT_EQ(device.deviceId, 0x0193U);
 
  const auto catalog = io::IoSignalCatalog::FromGsdml(device);
  EXPECT_FALSE(catalog.Sensors().empty());
  EXPECT_FALSE(catalog.Actuators().empty());
}
 
TEST(VirtualRealGsdmlIntegrationTests, RunsRealAumaAndPhoenixThroughCyclicController)
{
  const std::string aumaPath = AumaGsdmlPath();
  const std::string phoenixPath = PhoenixGsdmlPath();
  if (aumaPath.empty() || phoenixPath.empty())
  {
    GTEST_SKIP() << "Set both PROFINET_AUMA_GSDML and PROFINET_PHOENIX_GSDML";
  }
 
  const auto auma = gsdml::ParseGsdml(aumaPath);
  const auto phoenix = gsdml::ParseGsdml(phoenixPath);
  auto iocrs = MakeVirtualAumaIocrConfiguration(auma, 0x9000U, 0x8001U, 32U, 8U, 3U, 3U);
 
  InMemoryEthernetBus bus;
  VirtualAumaValve valve("auma-real", auma, test::kValveMac,
                         iocrs.input, iocrs.output);
  VirtualPhoenixPlc plc("phoenix-real", phoenix, test::kControllerMac);
  valve.Start(bus);
 
  auto controllerIocrs = iocrs;
  asio::io_context ioContext;
  profinet::AsioIoContextRunner ioContextRunner(ioContext);
 
  plc.Connect(ioContext,
              bus,
              valve,
              controllerIocrs.input,
              controllerIocrs.output,
              3);
 
  ASSERT_TRUE(WaitUntil([&plc]
  {
    const auto stats = plc.ConnectionStats("auma-real");
    return stats.has_value() && stats->framesReceived >= 3U;
  }));
 
  plc.SetOutput("auma-real", "T_ID_CMD_0", 1.0);
 
  ASSERT_TRUE(WaitUntil([&valve]
  {
    return valve.Position() > 0U;
  }));
 
  const auto actualPosition = plc.ReadInput("auma-real", "T_ID_ACTPOS_E2");
  ASSERT_TRUE(actualPosition.has_value());
  EXPECT_GT(*actualPosition, 0.0);
 
  plc.Stop();
  valve.Stop();
}
 
} // namespace profinet::sim