test_virtual_phoenix_plcMore.cpp

Go to the documentation of this file.

 
 
#include <gtest/gtest.h>
 
#include <chrono>
#include <cmath>
#include <cstdint>
#include <limits>
#include <stdexcept>
#include <string>
#include <thread>
 
#include "profinet/sim/virtual_auma_valve.h"
#include "profinet/sim/virtual_phoenix_plc.h"
#include "virtual_sim_test_helpers.h"
 
namespace profinet::sim
{
 
namespace
{
 
using test::MakeAumaGsdml;
using test::MakePhoenixGsdml;
using test::MakeTestAumaIocrs;
using test::WaitUntil;
 
constexpr MacAddress TestControllerMac()
{
  return MacAddress{0x02, 0x00, 0x00, 0x10, 0x00, 0x01};
}
 
constexpr MacAddress TestValveMac()
{
  return MacAddress{0x02, 0x00, 0x00, 0x20, 0x00, 0x01};
}
 
} // namespace
 
TEST(VirtualPhoenixPlcTests, BuildsGsdmlDerivedProcessImage)
{
  const auto gsdml = MakePhoenixGsdml();
  VirtualPhoenixPlc plc("plc1", gsdml, TestControllerMac());
 
  ASSERT_FALSE(plc.SignalCatalog().Sensors().empty());
  ASSERT_FALSE(plc.SignalCatalog().Actuators().empty());
  EXPECT_TRUE(plc.GetLocalInputBytes("DI4").has_value());
  EXPECT_EQ(plc.ConnectionCount(), 0U);
}
 
TEST(VirtualPhoenixPlcTests, LocalInputBytesRoundTrip)
{
  const auto gsdml = MakePhoenixGsdml();
  VirtualPhoenixPlc plc("plc1", gsdml, TestControllerMac());
 
  const Bytes input{0x01U, 0x23U, 0x45U, 0x67U};
  plc.SetLocalInputBytes("DI4", input);
 
  ASSERT_TRUE(plc.GetLocalInputBytes("DI4").has_value());
  EXPECT_EQ(*plc.GetLocalInputBytes("DI4"), input);
}
 
TEST(VirtualPhoenixPlcTests, LocalTypedValuesRoundTrip)
{
  const auto gsdml = MakePhoenixGsdml();
  VirtualPhoenixPlc plc("plc1", gsdml, TestControllerMac());
 
  plc.SetLocalInputValue("TEMPERATURE", -123.0);
  plc.SetLocalInputValue("LEVEL", 12.5);
  plc.SetLocalOutputValue("DO4", 305419896.0);
  plc.SetLocalOutputValue("SETPOINT", 87.25);
 
  ASSERT_TRUE(plc.GetLocalInputValue("TEMPERATURE").has_value());
  ASSERT_TRUE(plc.GetLocalInputValue("LEVEL").has_value());
  ASSERT_TRUE(plc.GetLocalOutputValue("DO4").has_value());
  ASSERT_TRUE(plc.GetLocalOutputValue("SETPOINT").has_value());
 
  EXPECT_DOUBLE_EQ(*plc.GetLocalInputValue("TEMPERATURE"), -123.0);
  EXPECT_DOUBLE_EQ(*plc.GetLocalInputValue("LEVEL"), 12.5);
  EXPECT_DOUBLE_EQ(*plc.GetLocalOutputValue("DO4"), 305419896.0);
  EXPECT_DOUBLE_EQ(*plc.GetLocalOutputValue("SETPOINT"), 87.25);
}
 
TEST(VirtualPhoenixPlcTests, BitSignalsPreserveSiblingBits)
{
  const auto gsdml = MakePhoenixGsdml();
  VirtualPhoenixPlc plc("plc1", gsdml, TestControllerMac());
 
  plc.SetLocalOutputBytes("DO_STATUS_1", Bytes{0x00U});
  plc.SetLocalOutputValue("DO_STATUS_0", 1.0);
  plc.SetLocalOutputValue("DO_STATUS_3", 1.0);
 
  const auto bytes = plc.GetLocalOutputBytes("DO_STATUS_0");
  ASSERT_TRUE(bytes.has_value());
  ASSERT_EQ(bytes->size(), 1U);
  EXPECT_EQ((*bytes)[0], 0x09U);
 
  plc.SetLocalOutputValue("DO_STATUS_0", 0.0);
  const auto cleared = plc.GetLocalOutputBytes("DO_STATUS_3");
  ASSERT_TRUE(cleared.has_value());
  EXPECT_EQ((*cleared)[0], 0x08U);
}
 
TEST(VirtualPhoenixPlcTests, TypedValueValidationRejectsInvalidValues)
{
  const auto gsdml = MakePhoenixGsdml();
  VirtualPhoenixPlc plc("plc1", gsdml, TestControllerMac());
 
  EXPECT_THROW(plc.SetLocalInputValue("TEMPERATURE", 1.5), std::invalid_argument);
  EXPECT_THROW(plc.SetLocalInputValue("TEMPERATURE", -40000.0), std::out_of_range);
  EXPECT_THROW(plc.SetLocalInputValue("LEVEL", std::numeric_limits<double>::infinity()),
               std::invalid_argument);
  EXPECT_THROW(plc.SetLocalInputValue("RAW_STATUS", 1.0), std::invalid_argument);
  EXPECT_THROW(plc.SetLocalOutputValue("DO_STATUS_0", 2.0), std::invalid_argument);
}
 
TEST(VirtualPhoenixPlcTests, ConnectedControllerDrivesVirtualAuma)
{
  const auto auma = MakeAumaGsdml();
  const auto phoenix = MakePhoenixGsdml();
  auto iocrs = MakeTestAumaIocrs(auma);
 
  InMemoryEthernetBus bus;
  VirtualAumaValve valve("valve1", auma, TestValveMac(),
                         std::move(iocrs.input), std::move(iocrs.output));
  valve.Start(bus);
 
  VirtualPhoenixPlc plc("plc1", phoenix, TestControllerMac());
  auto valveIocrs = MakeTestAumaIocrs(auma);
  asio::io_context ioContext;
  profinet::AsioIoContextRunner ioContextRunner(ioContext);
 
  plc.Connect(ioContext,
              bus,
              valve,
              std::move(valveIocrs.input),
              std::move(valveIocrs.output));
 
  ASSERT_TRUE(WaitUntil([&plc]
  {
    return plc.ConnectionState("valve1").has_value() &&
           *plc.ConnectionState("valve1") == cyclic::CyclicState::Running;
  }));
 
  plc.SetOutput("valve1", "T_ID_CMD_0", 1.0);
 
  ASSERT_TRUE(WaitUntil([&valve]
  {
    return valve.Position() > 100U;
  }));
 
  const auto position = plc.ReadInput("valve1", "T_ID_ACTPOS_E2");
  ASSERT_TRUE(position.has_value());
  EXPECT_GT(*position, 0.0);
  EXPECT_EQ(plc.ConnectionCount(), 1U);
 
  plc.Stop();
  valve.Stop();
}
 
TEST(VirtualPhoenixPlcTests, BadIopsWithholdsInputData)
{
  const auto auma = MakeAumaGsdml();
  const auto phoenix = MakePhoenixGsdml();
  auto valveIocrs = MakeTestAumaIocrs(auma);
 
  InMemoryEthernetBus bus;
  VirtualAumaValve valve("valve1", auma, TestValveMac(),
                         std::move(valveIocrs.input), std::move(valveIocrs.output));
  valve.Start(bus);
 
  VirtualPhoenixPlc plc("plc1", phoenix, TestControllerMac());
  auto controllerIocrs = MakeTestAumaIocrs(auma);
  asio::io_context ioContext;
  profinet::AsioIoContextRunner ioContextRunner(ioContext);
 
  plc.Connect(ioContext, bus, valve,
              std::move(controllerIocrs.input),
              std::move(controllerIocrs.output));
 
  ASSERT_TRUE(WaitUntil([&plc]
  {
    const auto stats = plc.ConnectionStats("valve1");
    return stats.has_value() && stats->framesReceived >= 2U;
  }));
 
  valve.SetScenario(VirtualAumaScenario::BadIops);
  std::this_thread::sleep_for(std::chrono::milliseconds(50));
 
  EXPECT_FALSE(plc.ReadInput("valve1", "T_ID_ACTPOS_E2").has_value());
  const auto stats = plc.ConnectionStats("valve1");
  ASSERT_TRUE(stats.has_value());
  EXPECT_GT(stats->framesReceived, 0U);
 
  plc.Stop();
  valve.Stop();
}
 
TEST(VirtualPhoenixPlcTests, NoInputTriggersControllerWatchdog)
{
  const auto auma = MakeAumaGsdml();
  const auto phoenix = MakePhoenixGsdml();
  auto valveIocrs = MakeTestAumaIocrs(auma);
 
  InMemoryEthernetBus bus;
  VirtualAumaValve valve("valve1", auma, TestValveMac(),
                         std::move(valveIocrs.input), std::move(valveIocrs.output));
  valve.Start(bus);
 
  VirtualPhoenixPlc plc("plc1", phoenix, TestControllerMac());
  auto controllerIocrs = MakeTestAumaIocrs(auma);
  asio::io_context ioContext;
  profinet::AsioIoContextRunner ioContextRunner(ioContext);
 
  plc.Connect(ioContext, bus, valve,
              std::move(controllerIocrs.input),
              std::move(controllerIocrs.output),
              2);
 
  ASSERT_TRUE(WaitUntil([&plc]
  {
    const auto stats = plc.ConnectionStats("valve1");
    return stats.has_value() && stats->framesReceived >= 2U;
  }));
 
  valve.SetScenario(VirtualAumaScenario::NoInput);
 
  ASSERT_TRUE(WaitUntil([&plc]
  {
    const auto state = plc.ConnectionState("valve1");
    return state.has_value() && *state == cyclic::CyclicState::Fault;
  }, std::chrono::milliseconds(300)));
 
  const auto stats = plc.ConnectionStats("valve1");
  ASSERT_TRUE(stats.has_value());
  EXPECT_GT(stats->framesMissed, 0U);
 
  plc.Stop();
  valve.Stop();
}
 
TEST(VirtualPhoenixPlcTests, DisconnectAllowsReconnect)
{
  const auto auma = MakeAumaGsdml();
  const auto phoenix = MakePhoenixGsdml();
  auto valveIocrs = MakeTestAumaIocrs(auma);
 
  InMemoryEthernetBus bus;
 
  VirtualAumaValve valve("valve1", auma, TestValveMac(),
                         std::move(valveIocrs.input), std::move(valveIocrs.output));
  valve.Start(bus);
  VirtualPhoenixPlc plc("plc1", phoenix, TestControllerMac());
 
  auto first = MakeTestAumaIocrs(auma);
  asio::io_context ioContext;
  profinet::AsioIoContextRunner ioContextRunner(ioContext);
  plc.Connect(ioContext, bus, valve, std::move(first.input), std::move(first.output));
  ASSERT_EQ(plc.ConnectionCount(), 1U);
  ASSERT_TRUE(WaitUntil([&plc]
  {
    return plc.ConnectionState("valve1").has_value() &&
           *plc.ConnectionState("valve1") == cyclic::CyclicState::Running;
  }));
 
  plc.Disconnect("valve1");
  EXPECT_EQ(plc.ConnectionCount(), 0U);
 
  auto second = MakeTestAumaIocrs(auma);
 
  plc.Connect(ioContext, bus, valve, std::move(second.input), std::move(second.output));
  EXPECT_EQ(plc.ConnectionCount(), 1U);
 
  plc.Stop();
  valve.Stop();
}
 
TEST(VirtualPhoenixPlcTests, DuplicateConnectionIsRejected)
{
  const auto auma = MakeAumaGsdml();
  const auto phoenix = MakePhoenixGsdml();
  auto iocrs = MakeTestAumaIocrs(auma);
 
  InMemoryEthernetBus bus;
  VirtualAumaValve valve("valve1", auma, TestValveMac(),
                         std::move(iocrs.input), std::move(iocrs.output));
  valve.Start(bus);
  VirtualPhoenixPlc plc("plc1", phoenix, TestControllerMac());
 
  auto first = MakeTestAumaIocrs(auma);
  asio::io_context ioContext;
  profinet::AsioIoContextRunner ioContextRunner(ioContext);
 
  plc.Connect(ioContext, bus, valve, std::move(first.input), std::move(first.output));
  auto second = MakeTestAumaIocrs(auma);
 
  EXPECT_THROW(plc.Connect(ioContext, bus, valve, std::move(second.input), std::move(second.output)),
               std::invalid_argument);
  EXPECT_EQ(plc.ConnectionCount(), 1U);
 
  plc.Stop();
  valve.Stop();
}
 
} // namespace profinet::sim