diagnosis.h

Go to the documentation of this file.

 
//
// Note: diagnosis.py's USI/alarm-type enums and alarms.h's USI_*
// constants name the same values. Both coexist without conflict; the
// canonical single-source-of-truth for future new code is
// indices.h/indices.cpp, which was ported after both.
#pragma once
 
#include <cstdint>
#include <optional>
#include <string>
#include <vector>
 
#include "profinet/protocol.h"
 
namespace profinet::diagnosis
{
 
// =============================================================================
// ChannelProperties bit-field constants
// =============================================================================
 
enum class ChannelType : std::uint8_t
{
  Reserved = 0,
  Specific = 1,
  All = 2,
  Submodule = 3,
};
 
enum class ChannelAccumulative : std::uint8_t
{
  No = 0,
  MainFault = 1,
  AdditionalFault = 2,
};
 
enum class ChannelSpecifier : std::uint8_t
{
  AllDisappears = 0,
  Appears = 1,
  Disappears = 2,
  DisappearsOther = 3,
};
 
enum class ChannelDirection : std::uint8_t
{
  Manufacturer = 0,
  Input = 1,
  Output = 2,
  Bidirectional = 3,
};
 
struct ChannelProperties
{
  std::uint16_t raw = 0;
 
  ChannelType channelTypeValue = ChannelType::Reserved;
 
  ChannelAccumulative accumulative = ChannelAccumulative::No;
 
  bool maintenanceRequired = false;
 
  bool naintenanceDemanded = false;
 
  ChannelSpecifier specifier = ChannelSpecifier::AllDisappears;
 
  ChannelDirection direction = ChannelDirection::Manufacturer;
 
  static ChannelProperties FromUint16(std::uint16_t value);
 
  [[nodiscard]] std::string ChannelTypeName() const;
 
  [[nodiscard]] std::string SpecifierName() const;
 
  [[nodiscard]] std::string DirectionName() const;
 
  bool operator==(const ChannelProperties&) const = default;
};
 
// =============================================================================
// Error type decoding
// =============================================================================
 
std::string DecodeChannelErrorType(std::uint16_t errorType);
 
std::string DecodeExtChannelErrorType(std::uint16_t channelErrorType, std::uint16_t extErrorType);
 
// =============================================================================
// Data Classes
// =============================================================================
 
struct ChannelDiagnosis
{
  std::uint32_t api = 0;
 
  std::uint16_t slot = 0;
 
  std::uint16_t subslot = 0;
 
  std::uint16_t channelNumber = 0;
 
  ChannelProperties properties;
 
  std::uint16_t errorType = 0;
 
  std::string errorTypeName;
 
  [[nodiscard]] bool IsSubmoduleLevel() const
  {
    return channelNumber == static_cast<std::uint16_t>(Usi::Bit15OfChannelNumber);
  }
  bool operator==(const ChannelDiagnosis&) const = default;
};
 
struct ExtChannelDiagnosis : ChannelDiagnosis
{
  std::uint16_t extErrorType = 0;
 
  std::string extErrorTypeName;
 
  std::uint32_t extAddValue = 0;
};
 
struct QualifiedChannelDiagnosis : ExtChannelDiagnosis
{
  std::uint32_t qualifier = 0;
};
 
struct AnyChannelDiagnosis
{
  std::uint16_t usi = 0;
 
  ChannelDiagnosis base;
 
  std::optional<ExtChannelDiagnosis> ext;
 
  std::optional<QualifiedChannelDiagnosis> qualified;
 
  [[nodiscard]] bool IsChannelDiagnosis() const
  {
    return usi == static_cast<std::uint16_t>(Usi::Bit15OfChannelNumber) || usi == 0;
  }
 
  [[nodiscard]] bool IsExtChannelDiagnosis() const
  {
    return usi == static_cast<std::uint16_t>(Usi::Bit15AndExternalChannelDiagnosisOfChannelNumber);
  }
 
  [[nodiscard]] bool IsQualifiedChannelDiagnosis() const
  {
    return usi == static_cast<std::uint16_t>(Usi::Bit15AndQualifiedChannelDiagnosisOfChannelNumber);
  }
  bool operator==(const AnyChannelDiagnosis&) const = default;
};
 
struct DiagnosisData
{
  std::uint32_t api = 0;
 
  std::uint16_t slot = 0;
 
  std::uint16_t subslot = 0;
 
  std::vector<AnyChannelDiagnosis> entries;
 
  Bytes rawData;
 
  [[nodiscard]] bool HasErrors() const
  {
    return !entries.empty();
  }
 
  [[nodiscard]] bool HasMaintenanceRequired() const
  {
    for (const auto& e : entries)
    {
      if (e.base.properties.maintenanceRequired)
      {
        return true;
      }
    }
    return false;
  }
 
  [[nodiscard]] bool HasMaintenanceDemanded() const
  {
    for (const auto& e : entries)
    {
      if (e.base.properties.naintenanceDemanded)
      {
        return true;
      }
    }
    return false;
  }
 
  [[nodiscard]] std::vector<const AnyChannelDiagnosis*> GetByChannel(std::uint16_t channel) const
  {
    std::vector<const AnyChannelDiagnosis*> result;
    for (const auto& e : entries)
    {
      if (e.base.channelNumber == channel)
      {
        result.push_back(&e);
      }
    }
    return result;
  }
  bool operator==(const DiagnosisData&) const = default;
};
 
// =============================================================================
// Parsing Functions
// =============================================================================
 
DiagnosisData ParseDiagnosisBlock(const Bytes& data, std::uint32_t api = 0, std::uint16_t slot = 0,
                                  std::uint16_t subslot = 0);
 
DiagnosisData ParseDiagnosisSimple(const Bytes& data, std::uint32_t api = 0, std::uint16_t slot = 0,
                                   std::uint16_t subslot = 0);
 
} // namespace profinet::diagnosis