diagnosis.cpp

Go to the documentation of this file.

 
 
#include "profinet/diagnosis.h"
 
#include <algorithm>
#include <cstdio>
#include <map>
 
#include "profinet/wire.h"
 
namespace profinet::diagnosis
{
 
// =============================================================================
// ChannelProperties
// =============================================================================
 
ChannelProperties ChannelProperties::FromUint16(std::uint16_t value)
{
  ChannelProperties p;
  p.raw = value;
 
  const auto ct = static_cast<std::uint8_t>(value & 0x03);
  p.channelTypeValue = ct <= 3 ? static_cast<ChannelType>(ct) : ChannelType::Reserved;
 
  const auto acc = static_cast<std::uint8_t>((value >> 2) & 0x07);
  p.accumulative = acc <= 2 ? static_cast<ChannelAccumulative>(acc) : ChannelAccumulative::No;
 
  static constexpr uint8_t maintenanceRequiredBitIdx = 5;
  p.maintenanceRequired = (((value >> maintenanceRequiredBitIdx) & 0x01) != 0);
 
  static constexpr uint8_t maintenanceDemandedBitIdx = 6;
  p.naintenanceDemanded = (((value >> maintenanceDemandedBitIdx) & 0x01) != 0);
  // bit 7 reserved
 
  const auto spec = static_cast<std::uint8_t>(ByteAt(value, 1U) & 0x07);
  p.specifier = spec <= 3 ? static_cast<ChannelSpecifier>(spec) : ChannelSpecifier::AllDisappears;
 
  const auto dir = static_cast<std::uint8_t>((value >> 11) & 0x03);
  p.direction = dir <= 3 ? static_cast<ChannelDirection>(dir) : ChannelDirection::Manufacturer;
 
  return p;
}
 
std::string ChannelProperties::ChannelTypeName() const
{
  switch (channelTypeValue)
  {
    case ChannelType::Reserved:
      return "Reserved";
    case ChannelType::Specific:
      return "Specific";
    case ChannelType::All:
      return "All";
    case ChannelType::Submodule:
      return "Submodule";
  }
  return "Unknown";
}
 
std::string ChannelProperties::SpecifierName() const
{
  switch (specifier)
  {
    case ChannelSpecifier::AllDisappears:
      return "All Disappears";
    case ChannelSpecifier::Appears:
      return "Appears";
    case ChannelSpecifier::Disappears:
      return "Disappears";
    case ChannelSpecifier::DisappearsOther:
      return "Disappears Other";
  }
  return "Unknown";
}
 
std::string ChannelProperties::DirectionName() const
{
  switch (direction)
  {
    case ChannelDirection::Manufacturer:
      return "Manufacturer";
    case ChannelDirection::Input:
      return "Input";
    case ChannelDirection::Output:
      return "Output";
    case ChannelDirection::Bidirectional:
      return "Bidirectional";
  }
  return "Unknown";
}
 
// =============================================================================
// Error type name tables
// =============================================================================
 
namespace
{
 
const std::map<std::uint16_t, std::string>& ChannelErrorTypes()
{
  // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays, modernize-avoid-c-arrays)
  static const std::map<std::uint16_t, std::string> table = {
      {0x0000, "Reserved"},
      {0x0001, "Short circuit"},
      {0x0002, "Undervoltage"},
      {0x0003, "Overvoltage"},
      {0x0004, "Overload"},
      {0x0005, "Overtemperature"},
      {0x0006, "Line break"},
      {0x0007, "Upper limit value exceeded"},
      {0x0008, "Lower limit value exceeded"},
      {0x0009, "Error"},
      {0x000A, "Simulation active"},
      {0x000F, "Parameter missing"},
      {0x0010, "Parameterization fault"},
      {0x0011, "Power supply fault"},
      {0x0012, "Fuse blown / open"},
      {0x0013, "Communication fault"},
      {0x0014, "Ground fault"},
      {0x0015, "Reference point lost"},
      {0x0016, "Process event lost"},
      {0x0017, "Threshold warning"},
      {0x0018, "Output disabled"},
      {0x0019, "Functional safety event"},
      {0x001A, "External fault"},
      {0x001B, "Sensor has incorrect configuration"},
      {0x001F, "Temporary fault"},
      {0x8000, "Data transmission impossible"},
      {0x8001, "Remote mismatch"},
      {0x8002, "Media redundancy mismatch"},
      {0x8003, "Sync mismatch"},
      {0x8004, "Isochronous mode mismatch"},
      {0x8005, "Multicast CR mismatch"},
      {0x8007, "Fiber optic mismatch"},
      {0x8008, "Network component function mismatch"},
      {0x8009, "Time mismatch"},
      {0x800A, "Dynamic frame packing function mismatch"},
      {0x800B, "Media redundancy with planned duplication mismatch"},
      {0x800C, "System redundancy mismatch"},
      {0x800D, "Multiple interface mismatch"},
      {0x9500, "IO-Link device event"},
      {0x9501, "IO-Link device event (MSB cleared)"},
      {0x9502, "IO-Link port event"},
  };
  return table;
}
 
// Ext error tables keyed by ChannelErrorType
const std::map<std::uint16_t, std::string>& ExtFor(std::uint16_t channelErrorType)
{
  static const std::map<std::uint16_t, std::string> general = {
      {0x0000, "Reserved"},
      {0x8000, "Accumulative info"},
  };
  static const std::map<std::uint16_t, std::map<std::uint16_t, std::string>> specific = {
      {0x8000, {{0x0000, "Reserved"}, {0x8000, "Link state mismatch - Loss of link"}, {0x8001, "MAUType mismatch"}, {0x8002, "Line delay mismatch"}}},
      {0x8001, {{0x0000, "Reserved"}, {0x8000, "Peer name of station mismatch"}, {0x8001, "Peer name of port mismatch"}, {0x8002, "Peer RT_CLASS_3 mismatch"}, {0x8003, "Peer MAUType mismatch"}, {0x8004, "Peer MRP domain mismatch"}, {0x8005, "No peer detected"}, {0x8006, "Peer line delay mismatch"}, {0x8007, "Peer PTCP mismatch"}, {0x8008, "Peer Preamble length mismatch"}, {0x8009, "Peer Fragmentation mismatch"}}},
      {0x8002, {{0x0000, "Reserved"}, {0x8000, "Manager role fail"}, {0x8001, "MRP-Loss of redundancy"}, {0x8003, "MRP ring open"}, {0x8004, "MRP multiple manager"}}},
      {0x8003, {{0x0000, "Reserved"}, {0x8000, "No sync message received"}, {0x8001, "Jitter out of boundary"}, {0x8002, "Sync message send failure"}, {0x8003, "PTCP timeout"}}},
      {0x8007, {{0x0000, "Reserved"}, {0x8000, "Power budget exceeded"}}},
      {0x8008, {{0x0000, "Reserved"}, {0x8000, "Frame dropped - no resource"}, {0x8001, "Frame dropped - wrong destination address"}, {0x8002, "Frame dropped - no gateway"}}},
      {0x8009, {{0x0000, "Reserved"}, {0x8000, "No master detected"}, {0x8001, "Drift exceeded"}, {0x8002, "Time sync failure"}}},
      {0x800B, {{0x0000, "Reserved"}, {0x8000, "MRPD loss of redundancy"}}},
  };
  auto it = specific.find(channelErrorType);
  if (it != specific.end())
  {
    return it->second;
  }
  return general;
}
 
// Known diagnosis block types (blocks.h's BLOCK_DIAGNOSIS_DATA is 0x0010)
bool IsDiagnosisBlockType(std::uint16_t t)
{
  return t == 0x0010 || t == 0x0011 || t == 0x8010 || t == 0x8011 || t == 0x8012;
}
 
} // namespace
 
std::string DecodeChannelErrorType(std::uint16_t errorType)
{
  auto it = ChannelErrorTypes().find(errorType);
  if (it != ChannelErrorTypes().end())
  {
    return it->second;
  }
  if (errorType >= 0x000B && errorType <= 0x000E)
  {
    return "Reserved (" + Hex4(errorType) + ")";
  }
  if (errorType >= 0x0020 && errorType <= 0x00FF)
  {
    return "Reserved (" + Hex4(errorType) + ")";
  }
  if (errorType >= 0x0100 && errorType <= 0x7FFF)
  {
    return "Manufacturer-specific (" + Hex4(errorType) + ")";
  }
  if (errorType >= 0x800E && errorType <= 0x8FFF)
  {
    return "Reserved (" + Hex4(errorType) + ")";
  }
  if (errorType >= 0x9000 && errorType <= 0x9FFF)
  {
    return "Profile-specific (" + Hex4(errorType) + ")";
  }
  if (errorType >= 0xA000)
  {
    return "Reserved (" + Hex4(errorType) + ")";
  }
  return "Unknown (" + Hex4(errorType) + ")";
}
 
std::string DecodeExtChannelErrorType(std::uint16_t channelErrorType, std::uint16_t extErrorType)
{
  const auto& lookup = ExtFor(channelErrorType);
  auto it = lookup.find(extErrorType);
  if (it != lookup.end())
  {
    return it->second;
  }
  if (extErrorType == 0x8000)
  {
    return "Accumulative info";
  }
  if (extErrorType >= 0x0001 && extErrorType <= 0x7FFF)
  {
    return "Manufacturer-specific (" + Hex4(extErrorType) + ")";
  }
  if (extErrorType >= 0x8001 && extErrorType <= 0x8FFF)
  {
    return "Reserved (" + Hex4(extErrorType) + ")";
  }
  if (extErrorType >= 0x9000 && extErrorType <= 0x9FFF)
  {
    return "Profile-specific (" + Hex4(extErrorType) + ")";
  }
  return "Unknown (" + Hex4(extErrorType) + ")";
}
 
// =============================================================================
// Parsing
// =============================================================================
 
DiagnosisData ParseDiagnosisBlock(const Bytes& data, std::uint32_t api, std::uint16_t slot, std::uint16_t subslot)
{
  DiagnosisData result;
  result.api = api;
  result.slot = slot;
  result.subslot = subslot;
  result.rawData = data;
 
  if (data.size() < (3 * sizeof(std::uint16_t))) // ChannelNumber(2) + ChannelProperties(2) + USI(2)
  {
    return result;
  }
 
  std::size_t offset = 0;
  wire::Reader r(data);
 
  // Skip block header if present
  if (data.size() >= 4)
  {
    const auto possibleType = r.U16();
    if (IsDiagnosisBlockType(possibleType))
    {
      offset = (3 * sizeof(std::uint16_t)); // ChannelNumber(2) + ChannelProperties(2) + USI(2)
    }
  }
 
  while (data.size() >= offset + (3 * sizeof(std::uint16_t))) // ChannelNumber(2) + ChannelProperties(2) + USI(2)
  {
    // Optionally consume API/Slot/Subslot location sub-header.
    // Heuristics by ralph / internet: if the next 8 bytes decode to a
    // plausible API (<0x10000) and slot (<0x8000), treat as location.
    if (data.size() >= offset + sizeof(std::uint32_t) + (2 * sizeof(std::uint16_t)))
    {
      wire::Reader locationReader(data);
      locationReader.SkipTo(offset);
 
      const auto maybeApi = locationReader.U32();
      const auto maybeSlot = locationReader.U16();
      const auto maybeSubslot = locationReader.U16();
 
      if (maybeApi < 0x10000 && maybeSlot < 0x8000)
      {
        api = maybeApi;
        slot = maybeSlot;
        subslot = maybeSubslot;
 
        offset = locationReader.Position();
        r.SkipTo(offset);
 
        if (data.size() < offset + (3 * sizeof(std::uint16_t))) // ChannelNumber(2) + ChannelProperties(2) + USI(2)
        {
          break;
        }
      }
      else
      {
        // The heuristic did not match. Keep the reader at the current
        // diagnosis entry rather than consuming the candidate bytes.
        r.SkipTo(offset);
      }
    }
    else
    {
      r.SkipTo(offset);
    }
    // ChannelNumber(2) + ChannelProperties(2) + USI(2)
    const auto channelNum = r.U16();
    offset += sizeof(std::uint16_t);
 
    const auto chPropsRaw = r.U16();
    offset += sizeof(std::uint16_t);
 
    const auto usi = static_cast<Usi>(r.U16());
    offset += sizeof(std::uint16_t);
 
    const ChannelProperties chProps = ChannelProperties::FromUint16(chPropsRaw);
 
    AnyChannelDiagnosis entry;
    entry.usi = usi;
    entry.base.api = api;
    entry.base.slot = slot;
    entry.base.subslot = subslot;
    entry.base.channelNumber = channelNum;
    entry.base.properties = chProps;
 
    if (usi == Usi::ChannelDiagnosis)
    {
      // ChannelDiagnosis: ChannelErrorType(2)
      if (offset + 2 > data.size())
      {
        break;
      }
      const auto errorType = r.U16();
      offset += sizeof(std::uint16_t);
 
      entry.base.errorType = errorType;
      entry.base.errorTypeName = DecodeChannelErrorType(errorType);
    }
    else if (usi == Usi::ExtendedChannelDiagnosis)
    {
      // ExtChannelDiagnosis: error_type(2) + ext_error_type(2) + ext_add_value(4)
      if (offset + (2 * sizeof(std::uint16_t)) + sizeof(std::uint32_t) > data.size())
      {
        break;
      }
      const auto errorType = r.U16();
      offset += sizeof(std::uint16_t);
 
      const auto extType = r.U16();
      offset += sizeof(std::uint16_t);
 
      const std::uint32_t extAdd = r.U32();
      offset += sizeof(std::uint32_t);
 
      entry.base.errorType = errorType;
      entry.base.errorTypeName = DecodeChannelErrorType(errorType);
      ExtChannelDiagnosis ext;
      static_cast<ChannelDiagnosis&>(ext) = entry.base;
      ext.extErrorType = extType;
      ext.extErrorTypeName = DecodeExtChannelErrorType(errorType, extType);
      ext.extAddValue = extAdd;
      entry.ext = ext;
    }
    else if (usi == Usi::QualifiedChannelDiagnosis)
    {
      // QualifiedChannelDiagnosis: same as Ext + qualifier(4)
      if (offset + (2 * sizeof(std::uint16_t)) + (2 * sizeof(std::uint32_t)) > data.size())
      {
        break;
      }
      const auto errorType = r.U16();
      offset += sizeof(std::uint16_t);
 
      const auto extType = r.U16();
      offset += sizeof(std::uint16_t);
 
      const std::uint32_t extAdd = r.U32();
      offset += sizeof(std::uint32_t);
 
      const std::uint32_t qualifier = r.U32();
      offset += sizeof(std::uint32_t);
 
      entry.base.errorType = errorType;
      entry.base.errorTypeName = DecodeChannelErrorType(errorType);
      QualifiedChannelDiagnosis qual;
      static_cast<ChannelDiagnosis&>(qual) = entry.base;
      qual.extErrorType = extType;
      qual.extErrorTypeName = DecodeExtChannelErrorType(errorType, extType);
      qual.extAddValue = extAdd;
      qual.qualifier = qualifier;
      entry.qualified = qual;
      entry.ext = qual; // also populate ext for convenience
    }
    else
    {
      // Unknown USI — treat as ChannelDiagnosis with minimal data
      if (offset + 2 > data.size())
      {
        break;
      }
      const auto errorType = r.U16();
      offset += sizeof(std::uint16_t);
      entry.base.errorType = errorType;
      entry.base.errorTypeName = DecodeChannelErrorType(errorType);
    }
 
    result.entries.push_back(entry);
  }
 
  return result;
}
 
DiagnosisData ParseDiagnosisSimple(const Bytes& data, std::uint32_t api, std::uint16_t slot,
                                   std::uint16_t subslot)
{
  DiagnosisData result;
  result.api = api;
  result.slot = slot;
  result.subslot = subslot;
  result.rawData = data;
 
  // Skip the 6-byte block header unconditionally
  if (data.size() < blockHeaderLength)
  {
    return result;
  }
  std::size_t offset = blockHeaderLength;
  wire::Reader r(data);
  r.SkipTo(offset);
 
  while (data.size() >= offset + (3 * sizeof(std::uint16_t)))
  {
    const auto channelNum = r.U16();
    offset += sizeof(std::uint16_t);
 
    const auto chPropsRaw = r.U16();
    offset += sizeof(std::uint16_t);
 
    const auto errorType = r.U16();
    offset += sizeof(std::uint16_t);
 
    // Stop on zero-filled sentinel entry
    if (channelNum == 0 && chPropsRaw == 0 && errorType == 0)
    {
      break;
    }
 
    AnyChannelDiagnosis entry;
    entry.usi = Usi::NoIdentifier;
    entry.base.api = api;
    entry.base.slot = slot;
    entry.base.subslot = subslot;
    entry.base.channelNumber = channelNum;
    entry.base.properties = ChannelProperties::FromUint16(chPropsRaw);
    entry.base.errorType = errorType;
    entry.base.errorTypeName = DecodeChannelErrorType(errorType);
    result.entries.push_back(entry);
  }
 
  return result;
}
 
} // namespace profinet::diagnosis