test_virtual_pn_labMore.cpp

Go to the documentation of this file.

 
 
#include <gtest/gtest.h>
 
#include <chrono>
#include <cstddef>
#include <stdexcept>
#include <string>
#include <vector>
 
#include "profinet/sim/virtual_pn_lab.h"
#include "virtual_sim_test_helpers.h"
 
namespace profinet::sim
{
 
namespace
{
 
using test::MakeAumaGsdml;
using test::MakeIndexedMac;
using test::MakePhoenixGsdml;
using test::MakeTestAumaIocrs;
using test::WaitUntil;
 
void PopulateLab(VirtualProfinetLab& lab,
                 const std::size_t count,
                 const gsdml::GSDMLDevice& auma,
                 const gsdml::GSDMLDevice& phoenix)
{
  for (std::size_t index = 0; index < count; ++index)
  {
    const std::string valveName = "valve" + std::to_string(index + 1U);
    const std::string plcName = "plc" + std::to_string(index + 1U);
    auto iocrs = MakeTestAumaIocrs(auma);
    lab.AddAumaValve(valveName,
                     auma,
                     MakeIndexedMac(0x20U, index + 1U),
                     std::move(iocrs.input),
                     std::move(iocrs.output));
    lab.AddPhoenixPlc(plcName, phoenix, MakeIndexedMac(0x10U, index + 1U));
    auto controllerIocrs = MakeTestAumaIocrs(auma);
    asio::io_context ioContext;
    profinet::AsioIoContextRunner ioContextRunner(ioContext);
 
    lab.Connect(ioContext,
                plcName,
                valveName,
                std::move(controllerIocrs.input),
                std::move(controllerIocrs.output));
  }
}
 
} // namespace
 
TEST(VirtualProfinetLabTests, RunsMultipleIndependentValvePlcPairs)
{
  constexpr std::size_t kInstanceCount = 4;
  const auto auma = MakeAumaGsdml();
  const auto phoenix = MakePhoenixGsdml();
  VirtualProfinetLab lab;
  PopulateLab(lab, kInstanceCount, auma, phoenix);
 
  EXPECT_EQ(lab.ValveNames().size(), kInstanceCount);
  EXPECT_EQ(lab.PlcNames().size(), kInstanceCount);
  EXPECT_EQ(lab.Bus().EndpointCount(), kInstanceCount + (2U * kInstanceCount));
 
  for (std::size_t index = 0; index < kInstanceCount; ++index)
  {
    const std::string plc = "plc" + std::to_string(index + 1U);
    const std::string valve = "valve" + std::to_string(index + 1U);
    lab.Plc(plc).SetOutput(valve, "T_ID_CMD_0", 1.0);
  }
 
  ASSERT_TRUE(WaitUntil([&lab]
  {
    for (std::size_t index = 0; index < kInstanceCount; ++index)
    {
      if (lab.Valve("valve" + std::to_string(index + 1U)).Position() == 0U)
      {
        return false;
      }
    }
    return true;
  }, std::chrono::milliseconds(500)));
 
  for (std::size_t index = 0; index < kInstanceCount; ++index)
  {
    const std::string plc = "plc" + std::to_string(index + 1U);
    const std::string valve = "valve" + std::to_string(index + 1U);
    const auto value = lab.Plc(plc).ReadInput(valve, "T_ID_ACTPOS_E2");
    ASSERT_TRUE(value.has_value());
    EXPECT_GT(*value, 0.0);
  }
 
  lab.Stop();
  EXPECT_EQ(lab.Bus().EndpointCount(), 0U);
}
 
TEST(VirtualProfinetLabTests, DuplicateNamesAreRejected)
{
  const auto auma = MakeAumaGsdml();
  const auto phoenix = MakePhoenixGsdml();
  VirtualProfinetLab lab;
  auto first = MakeTestAumaIocrs(auma);
  lab.AddAumaValve("valve", auma, MakeIndexedMac(0x20U, 1U),
                   std::move(first.input), std::move(first.output));
 
  auto second = MakeTestAumaIocrs(auma);
  EXPECT_THROW(lab.AddAumaValve("valve", auma, MakeIndexedMac(0x20U, 2U),
                                std::move(second.input), std::move(second.output)),
               std::invalid_argument);
 
  lab.AddPhoenixPlc("plc", phoenix, MakeIndexedMac(0x10U, 1U));
  EXPECT_THROW(lab.AddPhoenixPlc("plc", phoenix, MakeIndexedMac(0x10U, 2U)),
               std::invalid_argument);
}
 
TEST(VirtualProfinetLabTests, DuplicateMacAddressesAreRejectedAcrossNodeTypes)
{
  const auto auma = MakeAumaGsdml();
  const auto phoenix = MakePhoenixGsdml();
  VirtualProfinetLab lab;
  auto iocrs = MakeTestAumaIocrs(auma);
  const MacAddress mac = MakeIndexedMac(0x20U, 1U);
  lab.AddAumaValve("valve1", auma, mac,
                   std::move(iocrs.input), std::move(iocrs.output));
 
  EXPECT_THROW(lab.AddPhoenixPlc("plc1", phoenix, mac), std::invalid_argument);
  EXPECT_EQ(lab.ValveNames().size(), 1U);
  EXPECT_TRUE(lab.PlcNames().empty());
}
 
TEST(VirtualProfinetLabTests, ScenarioChangeUpdatesDashboard)
{
  const auto auma = MakeAumaGsdml();
  const auto phoenix = MakePhoenixGsdml();
  VirtualProfinetLab lab;
  auto iocrs = MakeTestAumaIocrs(auma);
  lab.AddAumaValve("valve", auma, MakeIndexedMac(0x20U, 1U),
                   std::move(iocrs.input), std::move(iocrs.output));
  lab.AddPhoenixPlc("plc", phoenix, MakeIndexedMac(0x10U, 1U));
  auto controllerIocrs = MakeTestAumaIocrs(auma);
  asio::io_context ioContext;
  profinet::AsioIoContextRunner ioContextRunner(ioContext);
 
  lab.Connect(ioContext, "plc", "valve",
              std::move(controllerIocrs.input),
              std::move(controllerIocrs.output));
 
  lab.SetAumaScenario("valve", VirtualAumaScenario::Jammed);
 
  EXPECT_EQ(lab.Valve("valve").Scenario(), VirtualAumaScenario::Jammed);
  const std::string report = lab.StatusReport();
  EXPECT_NE(report.find("VIRTUAL PROFINET LAB"), std::string::npos);
  EXPECT_NE(report.find("scenario=jammed"), std::string::npos);
 
  lab.Stop();
}
 
} // namespace profinet::sim