IOSignal.cpp

Go to the documentation of this file.

 
 
#include "profinet/IOSignal.h"
 
#include <algorithm>
#include <cctype>
#include <stdexcept>
#include <utility>
 
namespace profinet::io
{
 
namespace
{
 
[[nodiscard]] bool EqualInsensitive(const char lhs, const char rhs) noexcept
{
  const auto left = static_cast<unsigned char>(lhs);
  const auto right = static_cast<unsigned char>(rhs);
  return std::tolower(left) == std::tolower(right);
}
 
[[nodiscard]] bool IsAsciiAlpha(const char value) noexcept
{
  const auto character = static_cast<unsigned char>(value);
  return std::isalpha(character) != 0;
}
 
[[nodiscard]] bool ContainsReservedMarker(const std::string_view value) noexcept
{
  constexpr std::string_view kReserve = "RESERVE";
  constexpr std::string_view kReserved = "RESERVED";
  constexpr std::string_view kNotAvailable = "-";
 
  for (std::size_t offset = 0; offset < value.size(); ++offset)
  {
    const auto matchesAt = [&](const std::string_view marker)
    {
      if (offset + marker.size() > value.size())
      {
        return false;
      }
 
      for (std::size_t index = 0; index < marker.size(); ++index)
      {
        if (!EqualInsensitive(value[offset + index], marker[index]))
        {
          return false;
        }
      }
 
      if (offset > 0 && IsAsciiAlpha(value[offset - 1]))
      {
        return false;
      }
 
      const std::size_t end = offset + marker.size();
      if (end == value.size())
      {
        return true;
      }
 
      const char next = value[end];
      return !IsAsciiAlpha(next) ||
             (std::isupper(static_cast<unsigned char>(next)) != 0);
    };
 
    if (matchesAt(kReserved) || matchesAt(kReserve) || matchesAt(kNotAvailable))
    {
      return true;
    }
  }
 
  return false;
}
 
void AddUnique(std::vector<int>& values, const std::vector<int>& candidates)
{
  for (const int candidate : candidates)
  {
    if (std::ranges::find(values, candidate) == values.end())
    {
      values.push_back(candidate);
    }
  }
}
 
void NormalizeLocations(std::vector<int>& values)
{
  std::ranges::sort(values);
  values.erase(std::ranges::unique(values).begin(), values.end());
}
 
[[nodiscard]] std::string MakeSignalName(const gsdml::GSDMLDataItem& item)
{
  if (!item.name.empty())
  {
    return item.name;
  }
 
  if (!item.textId.empty())
  {
    return item.textId;
  }
 
  return "<unnamed>";
}
 
[[nodiscard]] IoSignal MakeSignal(const gsdml::GSDMLDataItem& item,
                                  const IoSignalDirection direction,
                                  const gsdml::GSDMLModule& module,
                                  const gsdml::GSDMLSubmodule& submodule,
                                  const std::size_t byteOffset,
                                  const std::vector<int>& possibleSlots,
                                  const std::vector<int>& possibleSubslots,
                                  const gsdml::GSDMLBitDataItem* bit = nullptr)
{
  if (item.length < 0)
  {
    throw std::invalid_argument("GSDML DataItem has a negative length");
  }
 
  IoSignal signal;
  signal.direction = direction;
  signal.name = bit != nullptr ? !bit->name.empty() ? bit->name : !bit->textId.empty() ? bit->textId
                                                                                       : "<unnamed>"
                               : MakeSignalName(item);
  signal.textId = bit != nullptr ? bit->textId : item.textId;
  signal.parentDataItemTextId = bit != nullptr ? item.textId : "";
  signal.bitSignal = bit != nullptr;
  signal.parentDataItemByteOffset = byteOffset;
  if (bit != nullptr)
  {
    signal.byteOffset = byteOffset + (bit->bitOffset / 8U);
 
    signal.bitOffset = bit->bitOffset % 8U;
  }
  else
  {
    signal.byteOffset = byteOffset;
    signal.bitOffset = 0U;
  }
  signal.gsdmlDataType = item.dataType;
  signal.valueType = bit != nullptr ? IoSignalValueType::Boolean : ClassifyDataType(item.dataType);
  signal.doubleCompatible = signal.valueType != IoSignalValueType::Unsupported;
  signal.moduleId = module.id;
  signal.moduleName = module.name;
  signal.submoduleId = submodule.id;
  signal.submoduleName = submodule.name;
  signal.moduleIdentNumber = module.moduleIdentNumber;
  signal.submoduleIdentNumber = submodule.submoduleIdentNumber;
 
  signal.byteLength = bit != nullptr ? 1U : static_cast<std::size_t>(item.length);
  signal.possibleSlots = possibleSlots;
  signal.possibleSubslots = possibleSubslots;
 
  return signal;
}
 
[[nodiscard]] std::vector<int> ResolveModuleSlots(const gsdml::GSDMLDevice& device,
                                                  const std::string& moduleId)
{
  std::vector<int> result;
 
  for (const auto& reference : device.moduleReferences)
  {
    if (reference.moduleId != moduleId)
    {
      continue;
    }
 
    AddUnique(result, reference.allowedSlots);
    AddUnique(result, reference.fixedSlots);
    AddUnique(result, reference.usedSlots);
  }
 
  NormalizeLocations(result);
  return result;
}
 
[[nodiscard]] std::vector<int> ResolveSubmoduleSlots(const gsdml::GSDMLSubmodule& submodule)
{
  std::vector<int> result;
  AddUnique(result, submodule.allowedSubslots);
  AddUnique(result, submodule.fixedSubslots);
  AddUnique(result, submodule.usedSubslots);
  NormalizeLocations(result);
  return result;
}
 
[[nodiscard]] std::vector<int> ResolveSubmoduleSlots(const gsdml::GSDMLModule& module,
                                                     const std::string& submoduleId)
{
  std::vector<int> result;
 
  for (const auto& reference : module.submoduleReferences)
  {
    if (reference.submoduleId != submoduleId)
    {
      continue;
    }
 
    AddUnique(result, reference.allowedSubslots);
    AddUnique(result, reference.fixedSubslots);
    AddUnique(result, reference.usedSubslots);
  }
 
  NormalizeLocations(result);
  return result;
}
 
void AddSubmoduleItems(const gsdml::GSDMLModule& module,
                       const gsdml::GSDMLSubmodule& submodule,
                       const std::vector<int>& possibleSlots,
                       const std::vector<int>& possibleSubslots,
                       std::vector<IoSignal>& sensors,
                       std::vector<IoSignal>& actuators)
{
  std::size_t inputOffset = 0;
  for (const auto& item : submodule.inputItems)
  {
    if (item.length < 0)
    {
      throw std::invalid_argument("GSDML DataItem has a negative length");
    }
    if (item.useAsBits && !item.bitDataItems.empty())
    {
      for (const auto& bit : item.bitDataItems)
      {
        if (!IsReservedSignal(item.textId, bit.textId, bit.name))
        {
          sensors.push_back(MakeSignal(item,
                                       IoSignalDirection::Sensor,
                                       module,
                                       submodule,
                                       inputOffset,
                                       possibleSlots,
                                       possibleSubslots,
                                       &bit));
        }
      }
    }
    else
    {
      const std::string name = MakeSignalName(item);
      if (!IsReservedSignal(item.textId, name))
      {
        sensors.push_back(MakeSignal(item,
                                     IoSignalDirection::Sensor,
                                     module,
                                     submodule,
                                     inputOffset,
                                     possibleSlots,
                                     possibleSubslots));
      }
    }
    inputOffset += static_cast<std::size_t>(item.length);
  }
 
  std::size_t outputOffset = 0;
  for (const auto& item : submodule.outputItems)
  {
    if (item.length < 0)
    {
      throw std::invalid_argument("GSDML DataItem has a negative length");
    }
    if (item.useAsBits && !item.bitDataItems.empty())
    {
      for (const auto& bit : item.bitDataItems)
      {
        if (!IsReservedSignal(item.textId, bit.textId, bit.name))
        {
          actuators.push_back(
              MakeSignal(item,
                         IoSignalDirection::Actuator,
                         module,
                         submodule,
                         outputOffset,
                         possibleSlots,
                         possibleSubslots,
                         &bit));
        }
      }
    }
    else
    {
      const std::string name = MakeSignalName(item);
      if (!IsReservedSignal(item.textId, name))
      {
        actuators.push_back(MakeSignal(item,
                                       IoSignalDirection::Actuator,
                                       module,
                                       submodule,
                                       outputOffset,
                                       possibleSlots,
                                       possibleSubslots));
      }
 
      outputOffset += static_cast<std::size_t>(item.length);
    }
  }
}
 
void AddModule(const gsdml::GSDMLDevice& device,
               const gsdml::GSDMLModule& module,
               const std::vector<int>& possibleSlots,
               std::vector<IoSignal>& sensors,
               std::vector<IoSignal>& actuators)
{
  for (const auto& [submoduleId, submodule] : module.submodules)
  {
    auto possibleSubslots = ResolveSubmoduleSlots(submodule);
    const auto referenceSubslots = ResolveSubmoduleSlots(module, submoduleId);
    AddUnique(possibleSubslots, referenceSubslots);
    NormalizeLocations(possibleSubslots);
 
    AddSubmoduleItems(module,
                      submodule,
                      possibleSlots,
                      possibleSubslots,
                      sensors,
                      actuators);
  }
 
  std::vector<std::string> processedSubmoduleIds;
 
  for (const auto& reference : module.submoduleReferences)
  {
    const auto inlineIt = module.submodules.find(reference.submoduleId);
    if (inlineIt != module.submodules.end())
    {
      continue;
    }
 
    if (std::ranges::find(processedSubmoduleIds, reference.submoduleId) !=
        processedSubmoduleIds.end())
    {
      continue;
    }
    processedSubmoduleIds.push_back(reference.submoduleId);
 
    const auto* submodule = device.FindSubmodule(reference.submoduleId);
    if (submodule == nullptr)
    {
      throw std::invalid_argument(
          "Module '" + module.id + "' references unknown submodule '" +
          reference.submoduleId + "'");
    }
 
    auto possibleSubslots = ResolveSubmoduleSlots(*submodule);
    const auto referenceSubslots = ResolveSubmoduleSlots(module, reference.submoduleId);
    AddUnique(possibleSubslots, referenceSubslots);
    NormalizeLocations(possibleSubslots);
 
    AddSubmoduleItems(module,
                      *submodule,
                      possibleSlots,
                      possibleSubslots,
                      sensors,
                      actuators);
  }
}
 
void AddDapSignals(const gsdml::GSDMLDevice& device,
                   std::vector<IoSignal>& sensors,
                   std::vector<IoSignal>& actuators)
{
  gsdml::GSDMLModule dapModule;
  dapModule.id = device.dapModuleId;
  dapModule.name = device.dapModuleName.empty() ? device.deviceName : device.dapModuleName;
  dapModule.moduleIdentNumber = device.dapModuleIdentNumber;
 
  for (std::size_t index = 0; index < device.dapSubmodules.size(); ++index)
  {
    const auto& submodule = device.dapSubmodules[index];
    std::vector<int> possibleSlots{0};
    std::vector<int> possibleSubslots{static_cast<int>(index + 1U)};
 
    AddSubmoduleItems(dapModule,
                      submodule,
                      possibleSlots,
                      possibleSubslots,
                      sensors,
                      actuators);
  }
}
 
} // namespace
 
bool IoSignal::IsBitSignal() const noexcept
{
  return bitSignal;
}
 
bool IoSignal::IsSensor() const noexcept
{
  return direction == IoSignalDirection::Sensor;
}
 
bool IoSignal::IsActuator() const noexcept
{
  return direction == IoSignalDirection::Actuator;
}
 
bool IoSignal::IsDoubleCompatible() const noexcept
{
  return doubleCompatible;
}
 
IoSignalValueType ClassifyDataType(const std::string_view dataType) noexcept
{
  if ((dataType == "Boolean") || (dataType == "Bit"))
  {
    return IoSignalValueType::Boolean;
  }
 
  if ((dataType == "Integer8") || (dataType == "Integer16") ||
      (dataType == "Integer32") || (dataType == "Integer64"))
  {
    return IoSignalValueType::SignedInteger;
  }
 
  if ((dataType == "Unsigned8") || (dataType == "Unsigned16") ||
      (dataType == "Unsigned32") || (dataType == "Unsigned64"))
  {
    return IoSignalValueType::UnsignedInteger;
  }
 
  if ((dataType == "Float32") || (dataType == "Float64"))
  {
    return IoSignalValueType::FloatingPoint;
  }
 
  return IoSignalValueType::Unsupported;
}
 
bool IsReservedSignal(const std::string_view textId, const std::string_view bitId, const std::string_view name) noexcept
{
  return ContainsReservedMarker(textId) || ContainsReservedMarker(bitId) || ContainsReservedMarker(name);
}
 
bool IsReservedSignal(const std::string_view textId, const std::string_view name) noexcept
{
  return ContainsReservedMarker(textId) || ContainsReservedMarker(name);
}
 
IoSignalCatalog IoSignalCatalog::FromGsdml(const gsdml::GSDMLDevice& device)
{
  IoSignalCatalog catalog;
 
  AddDapSignals(device, catalog.sensors, catalog.actuators);
 
  if (device.moduleReferences.empty())
  {
    for (const auto& [moduleId, module] : device.modules)
    {
      (void)moduleId;
      AddModule(device,
                module,
                ResolveModuleSlots(device, module.id),
                catalog.sensors,
                catalog.actuators);
    }
  }
  else
  {
    std::vector<std::string> processedModuleIds;
 
    for (const auto& reference : device.moduleReferences)
    {
      const auto* module = device.FindModule(reference.moduleId);
      if (module == nullptr)
      {
        throw std::invalid_argument(
            "GSDML references unknown module '" + reference.moduleId + "'");
      }
 
      const auto existing = std::ranges::find(processedModuleIds, reference.moduleId);
      if (existing != processedModuleIds.end())
      {
        continue;
      }
 
      processedModuleIds.push_back(reference.moduleId);
 
      std::vector<int> possibleSlots;
      for (const auto& candidate : device.moduleReferences)
      {
        if (candidate.moduleId != reference.moduleId)
        {
          continue;
        }
 
        AddUnique(possibleSlots, candidate.allowedSlots);
        AddUnique(possibleSlots, candidate.fixedSlots);
        AddUnique(possibleSlots, candidate.usedSlots);
      }
      NormalizeLocations(possibleSlots);
 
      AddModule(device,
                *module,
                possibleSlots,
                catalog.sensors,
                catalog.actuators);
    }
  }
 
  return catalog;
}
 
const std::vector<IoSignal>& IoSignalCatalog::Sensors() const noexcept
{
  return sensors;
}
 
const std::vector<IoSignal>& IoSignalCatalog::Actuators() const noexcept
{
  return actuators;
}
 
std::size_t IoSignalCatalog::Size() const noexcept
{
  return sensors.size() + actuators.size();
}
 
} // namespace profinet::io