virtual_pn_lab.cpp

Go to the documentation of this file.

 
 
#include "profinet/sim/virtual_pn_lab.h"
 
#include <algorithm>
#include <sstream>
#include <stdexcept>
 
namespace profinet::sim
{
 
VirtualProfinetLab::~VirtualProfinetLab()
{
  Stop();
}
 
VirtualAumaValve& VirtualProfinetLab::AddAumaValve(std::string name,
                                                   const gsdml::GSDMLDevice& gsdml,
                                                   MacAddress deviceMac,
                                                   rt::IOCRConfig inputIocr,
                                                   rt::IOCRConfig outputIocr,
                                                   VirtualAumaValveConfiguration config)
{
  if (IsMacInUse(deviceMac))
  {
    throw std::invalid_argument("AUMA simulator MAC address is already in use: " +
                                Mac2String(deviceMac));
  }
  if (std::any_of(valves.begin(), valves.end(), [&name](const AumaEntry& entry)
  { return entry.name == name; }))
  {
    throw std::invalid_argument("AUMA simulator name already exists: " + name);
  }
  auto valve = std::make_unique<VirtualAumaValve>(
      name,
      gsdml,
      deviceMac,
      std::move(inputIocr),
      std::move(outputIocr),
      std::move(config));
  valve->Start(bus);
  valves.push_back({std::move(name), std::move(valve)});
  return *valves.back().valve;
}
 
VirtualPhoenixPlc& VirtualProfinetLab::AddPhoenixPlc(std::string name,
                                                     const gsdml::GSDMLDevice& gsdml,
                                                     MacAddress controllerMac)
{
  if (IsMacInUse(controllerMac))
  {
    throw std::invalid_argument("Phoenix simulator MAC address is already in use: " +
                                Mac2String(controllerMac));
  }
  if (std::any_of(plcs.begin(), plcs.end(), [&name](const PlcEntry& entry)
  { return entry.name == name; }))
  {
    throw std::invalid_argument("Phoenix simulator name already exists: " + name);
  }
  auto plc = std::make_unique<VirtualPhoenixPlc>(name, gsdml, controllerMac);
  plcs.push_back({std::move(name), std::move(plc)});
  return *plcs.back().plc;
}
 
void VirtualProfinetLab::Connect(asio::io_context& ioContext,
                                 const std::string& plcName,
                                 const std::string& valveName,
                                 rt::IOCRConfig inputIocr,
                                 rt::IOCRConfig outputIocr,
                                 const int maxConsecutiveTimeouts)
{
  Plc(plcName).Connect(ioContext,
                       bus,
                       Valve(valveName),
                       std::move(inputIocr),
                       std::move(outputIocr),
                       maxConsecutiveTimeouts);
}
 
void VirtualProfinetLab::SetAumaScenario(const std::string& valveName,
                                         const VirtualAumaScenario scenario)
{
  Valve(valveName).SetScenario(scenario);
}
 
InMemoryEthernetBus& VirtualProfinetLab::Bus() noexcept
{
  return bus;
}
 
VirtualAumaValve& VirtualProfinetLab::Valve(const std::string& name)
{
  const auto it = std::find_if(valves.begin(), valves.end(), [&name](const AumaEntry& entry)
  { return entry.name == name; });
  if (it == valves.end())
  {
    throw std::invalid_argument("Unknown AUMA simulator: " + name);
  }
  return *it->valve;
}
 
VirtualPhoenixPlc& VirtualProfinetLab::Plc(const std::string& name)
{
  const auto it = std::find_if(plcs.begin(), plcs.end(), [&name](const PlcEntry& entry)
  { return entry.name == name; });
  if (it == plcs.end())
  {
    throw std::invalid_argument("Unknown Phoenix simulator: " + name);
  }
  return *it->plc;
}
 
const VirtualAumaValve& VirtualProfinetLab::Valve(const std::string& name) const
{
  const auto it = std::find_if(valves.begin(), valves.end(), [&name](const AumaEntry& entry)
  { return entry.name == name; });
  if (it == valves.end())
  {
    throw std::invalid_argument("Unknown AUMA simulator: " + name);
  }
  return *it->valve;
}
 
const VirtualPhoenixPlc& VirtualProfinetLab::Plc(const std::string& name) const
{
  const auto it = std::find_if(plcs.begin(), plcs.end(), [&name](const PlcEntry& entry)
  { return entry.name == name; });
  if (it == plcs.end())
  {
    throw std::invalid_argument("Unknown Phoenix simulator: " + name);
  }
  return *it->plc;
}
 
std::vector<std::string> VirtualProfinetLab::ValveNames() const
{
  std::vector<std::string> result;
  result.reserve(valves.size());
  for (const auto& valve : valves)
  {
    result.push_back(valve.name);
  }
  return result;
}
 
std::vector<std::string> VirtualProfinetLab::PlcNames() const
{
  std::vector<std::string> result;
  result.reserve(plcs.size());
  for (const auto& plc : plcs)
  {
    result.push_back(plc.name);
  }
  return result;
}
 
std::string VirtualProfinetLab::StatusReport() const
{
  std::ostringstream out;
  out << "============================================================\n";
  out << "                 VIRTUAL PROFINET LAB\n";
  out << "============================================================\n";
  out << "Ethernet endpoints: " << bus.EndpointCount() << '\n';
  out << "Virtual AUMA valves: " << valves.size() << '\n';
  for (const auto& valve : valves)
  {
    out << "  AUMA " << valve.name
        << "  MAC=" << Mac2String(valve.valve->DeviceMac())
        << "  scenario=" << ToString(valve.valve->Scenario())
        << "  pos=" << valve.valve->Position()
        << "  target=" << valve.valve->TargetPosition()
        << "  moving=" << (valve.valve->Moving() ? "yes" : "no")
        << '\n';
  }
  out << "Virtual Phoenix PLCs: " << plcs.size() << '\n';
  for (const auto& plc : plcs)
  {
    out << plc.plc->StatusReport();
  }
  out << "============================================================\n";
  return out.str();
}
 
bool VirtualProfinetLab::IsMacInUse(const MacAddress& mac) const noexcept
{
  for (const auto& entry : valves)
  {
    if (entry.valve != nullptr && entry.valve->DeviceMac() == mac)
    {
      return true;
    }
  }
  for (const auto& entry : plcs)
  {
    if (entry.plc != nullptr && entry.plc->ControllerMac() == mac)
    {
      return true;
    }
  }
  return false;
}
 
void VirtualProfinetLab::Stop()
{
  for (auto& plc : plcs)
  {
    if (plc.plc != nullptr)
    {
      plc.plc->Stop();
    }
  }
  for (auto& valve : valves)
  {
    if (valve.valve != nullptr)
    {
      valve.valve->Stop();
    }
  }
}
 
} // namespace profinet::sim