alarms.h

Go to the documentation of this file.

 
 
#pragma once
 
#include <cstdint>
#include <stdexcept>
#include <string>
#include <utility>
#include <variant>
#include <vector>
 
#include "profinet/indices.h"
#include "profinet/protocol.h"
 
namespace profinet
{
struct AlarmItem
{
  Usi userStructureId = Usi::NoIdentifier;
 
  Bytes rawData;
 
  [[nodiscard]] std::string UsiName() const
  {
    return GetUsiName(userStructureId);
  }
};
 
struct DiagnosisItem
{
  Usi userStructureId;
 
  std::uint16_t channelNumber = 0;
 
  std::uint16_t channelProperties = 0;
 
  std::uint16_t channelErrorType = 0;
 
  std::uint16_t extChannelErrorType = 0;
 
  std::uint32_t extChannelAddValue = 0;
 
  std::uint32_t qualifiedChannelQualifier = 0;
 
  [[nodiscard]] std::string UsiName() const
  {
    return GetUsiName(userStructureId);
  }
 
  [[nodiscard]] std::uint16_t ChannelNumberValue() const
  {
    return channelNumber & static_cast<uint16_t>(Usi::Bit0till14OfChannelNumber);
  }
 
  [[nodiscard]] bool IsAccumulative() const
  {
    return (channelNumber & static_cast<uint16_t>(Usi::Bit15OfChannelNumber)) != 0;
  }
 
  [[nodiscard]] std::uint8_t ChannelTypeValue() const
  {
    return static_cast<std::uint8_t>(channelProperties);
  }
 
  [[nodiscard]] bool IsExtended() const
  {
    return userStructureId == Usi::ExtendedChannelDiagnosis || userStructureId == Usi::QualifiedChannelDiagnosis;
  }
 
  [[nodiscard]] bool IsQualified() const
  {
    return userStructureId == Usi::QualifiedChannelDiagnosis;
  }
};
 
struct MaintenanceItem
{
  Usi userStructureId = Usi::Maintenance;
 
  BlockType blockType;
 
  std::uint16_t blockLength = 0;
 
  std::uint16_t blockVersion = 0;
 
  std::uint32_t maintenanceStatus = 0;
 
  [[nodiscard]] std::string UsiName() const
  {
    return GetUsiName(userStructureId);
  }
 
  [[nodiscard]] bool MaintenanceRequired() const
  {
    return (maintenanceStatus & 0x01) != 0;
  }
 
  [[nodiscard]] bool MaintenanceDemanded() const
  {
    return (maintenanceStatus & 0x02) != 0;
  }
};
 
struct UploadRetrievalItem
{
  Usi userStructureId = Usi::Upload;
 
  BlockType blockType;
 
  std::uint16_t blockLength = 0;
 
  std::uint16_t blockVersion = 0;
 
  std::uint32_t urRecordIndex = 0;
 
  std::uint32_t urRecordLength = 0;
 
  [[nodiscard]] std::string UsiName() const
  {
    return GetUsiName(userStructureId);
  }
 
  [[nodiscard]] bool IsUpload() const
  {
    return userStructureId == Usi::Upload;
  }
 
  [[nodiscard]] bool IsRetrieval() const
  {
    return userStructureId == Usi::IParameter;
  }
};
 
struct IParameterItem
{
  Usi userStructureId = Usi::IParameter;
 
  std::uint16_t blockType = 0;
 
  std::uint16_t blockLength = 0;
 
  std::uint16_t blockVersion = 0;
 
  std::uint32_t iParReqHeader = 0;
 
  std::uint32_t maxSegmentSize = 0;
 
  std::uint32_t transferIndex = 0;
 
  std::uint32_t totalIparSize = 0;
 
  [[nodiscard]] std::string UsiName() const
  {
    return GetUsiName(userStructureId);
  }
};
 
struct PEAlarmItem
{
  Usi userStructureId = Usi::PeAlarm;
 
  BlockType blockType;
 
  std::uint16_t blockLength = 0;
 
  std::uint16_t blockVersion = 0;
 
  std::uint8_t peOperationalMode = 0;
 
  [[nodiscard]] std::string UsiName() const
  {
    return GetUsiName(userStructureId);
  }
 
  [[nodiscard]] std::string ModeName() const
  {
    return GetPeModeName(peOperationalMode);
  }
};
 
struct RSAlarmItem
{
  Usi userStructureId;
 
  std::uint16_t rsAlarmInfo = 0;
 
  [[nodiscard]] std::string UsiName() const
  {
    return GetUsiName(userStructureId);
  }
 
  [[nodiscard]] std::uint16_t RsSpecifier() const
  {
    return rsAlarmInfo & static_cast<std::uint16_t>(Usi::Low11BitsOfRsAlarmInfo);
  }
 
  [[nodiscard]] std::uint16_t RsSequenceNumber() const
  {
    return RsSpecifier();
  }
};
 
struct PRALAlarmItem
{
  Usi userStructureId = Usi::PralAlarm;
 
  std::uint16_t channelNumber = 0;
 
  std::uint16_t propAlChannelProperties = 0;
 
  std::uint16_t prAlReason = 0;
 
  std::uint16_t prAlExtReason = 0;
 
  Bytes prAlReasonAddValue;
 
  [[nodiscard]] std::string UsiName() const
  {
    return GetUsiName(userStructureId);
  }
};
 
using AlarmItemVariant = std::variant<AlarmItem, DiagnosisItem, MaintenanceItem, UploadRetrievalItem, PEAlarmItem,
                                      RSAlarmItem, PRALAlarmItem>;
 
Usi UsiOf(const AlarmItemVariant& item);
 
std::string UsiNameOf(const AlarmItemVariant& item);
 
std::pair<AlarmItemVariant, std::size_t> ParseAlarmItem(const Bytes& data, std::size_t offset = 0);
 
struct AlarmNotification
{
  BlockType blockType;
 
  std::pair<std::uint8_t, std::uint8_t> blockVersion{1, 0};
 
  AlarmType alarmType;
 
  std::uint32_t api = 0;
 
  std::uint16_t slotNumber = 0;
 
  std::uint16_t subslotNumber = 0;
 
  std::uint32_t moduleIdentNumber = 0;
 
  std::uint32_t submoduleIdentNumber = 0;
 
  std::uint16_t alarmSequenceNumber = 0;
 
  bool channelDiagnosis = false;
 
  bool manufacturerSpecific = false;
 
  bool submoduleDiagnosisState = false;
 
  bool arDiagnosisState = false;
 
  std::vector<AlarmItemVariant> items;
 
  Bytes rawPayload;
 
  [[nodiscard]] bool IsHighPriority() const
  {
    return blockType == BlockType::AlarmNotificationHigh;
  }
 
  [[nodiscard]] bool IsLowPriority() const
  {
    return blockType == BlockType::AlarmNotificationLow;
  }
 
  [[nodiscard]] std::string AlarmTypeName() const
  {
    return GetAlarmTypeName(alarmType);
  }
 
  [[nodiscard]] std::string Location() const;
};
 
AlarmNotification ParseAlarmNotification(const Bytes& data);
 
enum class AlarmNotificationBitmask : std::uint16_t
{
  None = 0x0000,
 
  AlarmSequenceNumber = 0x07FF,
 
  ManufacturerSpecific = 0x1000,
 
  SubmoduleDiagnosisState = 0x2000,
 
  ArDiagnosisState = 0x4000, // kan misschien ook 0x8000 zijn
 
  ChannelDiagnosis = 0x0800
};
 
// ============================================================================
// Enum <-> Enum Bitwise Operators
// ============================================================================
 
constexpr AlarmNotificationBitmask operator|(AlarmNotificationBitmask lhs, AlarmNotificationBitmask rhs) noexcept
{
  return static_cast<AlarmNotificationBitmask>(static_cast<std::uint16_t>(lhs) | static_cast<std::uint16_t>(rhs));
}
 
constexpr AlarmNotificationBitmask operator&(AlarmNotificationBitmask lhs, AlarmNotificationBitmask rhs) noexcept
{
  return static_cast<AlarmNotificationBitmask>(static_cast<std::uint16_t>(lhs) & static_cast<std::uint16_t>(rhs));
}
 
constexpr std::uint16_t operator&(std::uint16_t lhs, AlarmNotificationBitmask rhs) noexcept
{
  return lhs & static_cast<std::uint16_t>(rhs);
}
 
constexpr std::uint16_t operator&(AlarmNotificationBitmask lhs, std::uint16_t rhs) noexcept
{
  return static_cast<std::uint16_t>(lhs) & rhs;
}
 
constexpr std::uint16_t operator|(std::uint16_t lhs, AlarmNotificationBitmask rhs) noexcept
{
  return lhs | static_cast<std::uint16_t>(rhs);
}
 
constexpr std::uint16_t operator|(AlarmNotificationBitmask lhs, std::uint16_t rhs) noexcept
{
  return static_cast<std::uint16_t>(lhs) | rhs;
}
} // namespace profinet