alarms.cpp

Go to the documentation of this file.

 
 
#include "profinet/alarms.h"
 
#include <cstdio>
 
#include "profinet/wire.h"
 
namespace profinet
{
 
Usi UsiOf(const AlarmItemVariant& item)
{
  return std::visit([](const auto& i)
  { return i.userStructureId; }, item);
}
 
std::string UsiNameOf(const AlarmItemVariant& item)
{
  return std::visit([](const auto& i)
  { return i.UsiName(); }, item);
}
 
namespace
{
 
std::pair<DiagnosisItem, std::size_t> ParseDiagnosisItem(const Bytes& data, std::size_t offset, Usi usi)
{
  if (data.size() < offset + 6)
  {
    throw std::invalid_argument("Truncated DiagnosisItem");
  }
  wire::Reader r(data);
  r.SkipTo(offset);
 
  DiagnosisItem item;
  item.userStructureId = usi;
  item.channelNumber = r.U16();
  offset += sizeof(std::uint16_t);
  item.channelProperties = r.U16();
  offset += sizeof(std::uint16_t);
  item.channelErrorType = r.U16();
  offset += sizeof(std::uint16_t);
 
  if (usi == Usi::ExtendedChannelDiagnosis || usi == Usi::QualifiedChannelDiagnosis)
  {
    if (data.size() < offset + sizeof(std::uint16_t) + sizeof(std::uint32_t))
    {
      throw std::invalid_argument("Truncated ExtChannelDiagnosis");
    }
    item.extChannelErrorType = r.U16();
    offset += sizeof(std::uint16_t);
    item.extChannelAddValue = r.U32();
    offset += sizeof(std::uint32_t);
  }
 
  if (usi == Usi::QualifiedChannelDiagnosis)
  {
    if (data.size() < offset + sizeof(std::uint32_t))
    {
      throw std::invalid_argument("Truncated QualifiedChannelDiagnosis");
    }
    item.qualifiedChannelQualifier = r.U32();
    offset += sizeof(std::uint32_t);
  }
 
  return {item, offset};
}
 
std::pair<MaintenanceItem, std::size_t> ParseMaintenanceItem(const Bytes& data, std::size_t offset)
{
  if (data.size() < offset + blockHeaderLength + (2 * sizeof(std::uint8_t)) + sizeof(std::uint32_t))
  {
    throw std::invalid_argument("Truncated MaintenanceItem");
  }
  const PNBlockHeader hdr = PNBlockHeader::Parse(Bytes(data.begin() + offset, data.begin() + offset + blockHeaderLength));
 
  offset += blockHeaderLength + (2 * sizeof(std::uint8_t)); // + 2-byte padding
  wire::Reader r(data);
  r.SkipTo(offset);
  const std::uint32_t status = r.U32();
  offset += sizeof(std::uint32_t);
 
  MaintenanceItem item;
  item.userStructureId = Usi::Maintenance;
  item.blockType = hdr.blockType;
  item.blockLength = hdr.blockLength;
  item.blockVersion = hdr.blockVersion;
  item.maintenanceStatus = status;
  return {item, offset};
}
 
std::pair<UploadRetrievalItem, std::size_t> ParseUploadRetrievalItem(const Bytes& data, std::size_t offset, Usi usi)
{
  if (data.size() < offset + blockHeaderLength + sizeof(std::uint16_t) + (2 * sizeof(std::uint32_t)))
  {
    throw std::invalid_argument("Truncated UploadRetrievalItem");
  }
  const PNBlockHeader hdr = PNBlockHeader::Parse(Bytes(data.begin() + offset, data.begin() + offset + 6));
  offset += blockHeaderLength + (2 * sizeof(std::uint8_t)); // + 2-byte padding
  wire::Reader r(data);
  r.SkipTo(offset);
 
  const std::uint32_t index = r.U32();
  offset += sizeof(std::uint32_t);
  const std::uint32_t length = r.U32();
  offset += sizeof(std::uint32_t);
 
  UploadRetrievalItem item;
  item.userStructureId = usi;
  item.blockType = hdr.blockType;
  item.blockLength = hdr.blockLength;
  item.blockVersion = hdr.blockVersion;
  item.urRecordIndex = index;
  item.urRecordLength = length;
  return {item, offset};
}
 
std::pair<PEAlarmItem, std::size_t> ParsePeAlarmItem(const Bytes& data, std::size_t offset)
{
  if (data.size() < offset + blockHeaderLength + sizeof(std::uint8_t))
  {
    throw std::invalid_argument("Truncated PE_AlarmItem");
  }
  const PNBlockHeader hdr = PNBlockHeader::Parse(Bytes(data.begin() + offset, data.begin() + offset + blockHeaderLength));
  offset += blockHeaderLength;
  const std::uint8_t mode = data[offset];
  offset += sizeof(std::uint8_t);
 
  PEAlarmItem item;
  item.userStructureId = Usi::PeAlarm;
  item.blockType = hdr.blockType;
  item.blockLength = hdr.blockLength;
  item.blockVersion = hdr.blockVersion;
  item.peOperationalMode = mode;
  return {item, offset};
}
 
std::pair<RSAlarmItem, std::size_t> ParseRsAlarmItem(const Bytes& data, std::size_t offset, Usi usi)
{
  if (data.size() < offset + sizeof(std::uint16_t))
  {
    throw std::invalid_argument("Truncated RS_AlarmItem");
  }
  wire::Reader r(data);
  r.SkipTo(offset);
 
  const auto info = r.U16();
  offset += sizeof(std::uint32_t);
 
  RSAlarmItem item;
  item.userStructureId = usi;
  item.rsAlarmInfo = info;
  return {item, offset};
}
 
std::pair<PRALAlarmItem, std::size_t> ParsePralAlarmItem(const Bytes& data, std::size_t offset)
{
  if (data.size() < offset + (4 * sizeof(std::uint16_t)))
  {
    throw std::invalid_argument("Truncated PRAL_AlarmItem");
  }
  wire::Reader r(data);
  r.SkipTo(offset);
 
  const auto channelNum = r.U16();
  offset += sizeof(std::uint16_t);
 
  const auto channelProps = r.U16();
  offset += sizeof(std::uint16_t);
 
  const auto reason = r.U16();
  offset += sizeof(std::uint16_t);
 
  const auto extReason = r.U16();
  offset += sizeof(std::uint16_t);
 
  PRALAlarmItem item;
  item.userStructureId = Usi::PralAlarm;
  item.channelNumber = channelNum;
  item.propAlChannelProperties = channelProps;
  item.prAlReason = reason;
  item.prAlExtReason = extReason;
  item.prAlReasonAddValue = Bytes(data.begin() + offset, data.end());
  return {item, data.size()};
}
 
} // namespace
 
std::pair<AlarmItemVariant, std::size_t> ParseAlarmItem(const Bytes& data, std::size_t offset)
{
  if (data.size() < offset + sizeof(std::uint16_t))
  {
    throw std::invalid_argument("Insufficient data for USI");
  }
  wire::Reader r(data);
  r.SkipTo(offset);
 
  const auto usi = static_cast<Usi>(r.U16());
  offset += sizeof(std::uint16_t);
 
  if (usi == Usi::ChannelDiagnosis || usi == Usi::ExtendedChannelDiagnosis || usi == Usi::QualifiedChannelDiagnosis)
  {
    auto [item, new_offset] = ParseDiagnosisItem(data, offset, usi);
    return {item, new_offset};
  }
  if (usi == Usi::Maintenance)
  {
    auto [item, new_offset] = ParseMaintenanceItem(data, offset);
    return {item, new_offset};
  }
  if (usi == Usi::Upload || usi == Usi::IParameter)
  {
    auto [item, new_offset] = ParseUploadRetrievalItem(data, offset, usi);
    return {item, new_offset};
  }
  if (usi == Usi::RsAlarmLow || usi == Usi::RsAlarmHigh || usi == Usi::RsAlarmSubmodule)
  {
    auto [item, new_offset] = ParseRsAlarmItem(data, offset, usi);
    return {item, new_offset};
  }
  if (usi == Usi::PeAlarm)
  {
    auto [item, new_offset] = ParsePeAlarmItem(data, offset);
    return {item, new_offset};
  }
  if (usi == Usi::PralAlarm)
  {
    auto [item, new_offset] = ParsePralAlarmItem(data, offset);
    return {item, new_offset};
  }
 
  AlarmItem generic;
  generic.userStructureId = usi;
  generic.rawData = Bytes(data.begin() + offset, data.end());
  return {generic, data.size()};
}
 
std::string AlarmNotification::Location() const
{
  return std::format("{}:{}:0x{:04X}", api, slotNumber, subslotNumber);
}
 
AlarmNotification ParseAlarmNotification(const Bytes& data)
{
  // Minimum: BlockHeader(6) + Body(20). The body struct it actually parses
  // (alarm_type+api+slot+subslot+module_ident+submodule_ident+alarm_specifier = 2+4+2+2+4+4+2)
  // is only 20 bytes — a real off-by-2 bug that misaligns every item after the
  // first. Fixed here to the structurally correct 26 total / 20 body, per
  // IEC 61158-6-10's AlarmNotification-PDU layout (also confirmed against
  // protocol.h's PNAlarmNotificationPDU::kFixedSize == 26).
 
  // ralph update:
  // AlarmNotification body size in bytes (IEC 61158-6-10): AlarmType(2) + API(4) +
  // SlotNumber(2) + SubslotNumber(2) + ModuleIdent(4) + SubmoduleIdent(4) +
  // AlarmSpecifier(2). The block header (6) precedes it, so the item-less PDU is
  // 26 bytes and BlockLength reads 22(bytes following the BlockLength field).
  if (data.size() < 26)
  {
    throw std::invalid_argument("AlarmNotification too short");
  }
 
  std::size_t offset = 0;
  const PNBlockHeader hdr = PNBlockHeader::Parse(Bytes(data.begin(), data.begin() + blockHeaderLength));
  offset += blockHeaderLength;
 
  wire::Reader r(data.data() + offset, data.size() - offset);
 
  const auto alarmType = static_cast<AlarmType>(r.U16());
  offset += sizeof(std::uint16_t);
 
  const std::uint32_t api = r.U32();
  offset += sizeof(std::uint32_t);
 
  const std::uint16_t slotNumber = r.U16();
  offset += sizeof(std::uint16_t);
 
  const std::uint16_t subslotNumber = r.U16();
  offset += sizeof(std::uint16_t);
 
  const std::uint32_t moduleIdent = r.U32();
  offset += sizeof(std::uint32_t);
 
  const std::uint32_t submoduleIdent = r.U32();
  offset += sizeof(std::uint32_t);
 
  const std::uint16_t alarmSpecifier = r.U16();
  offset += sizeof(std::uint16_t);
 
  AlarmNotification notification;
  notification.blockType = hdr.blockType;
  notification.blockVersion = {hdr.blockVersionHigh, hdr.blockVersionLow};
  notification.alarmType = alarmType;
  notification.api = api;
  notification.slotNumber = slotNumber;
  notification.subslotNumber = subslotNumber;
  notification.moduleIdentNumber = moduleIdent;
  notification.submoduleIdentNumber = submoduleIdent;
  notification.alarmSequenceNumber = alarmSpecifier & AlarmNotificationBitmask::AlarmSequenceNumber;
  notification.channelDiagnosis = (alarmSpecifier & AlarmNotificationBitmask::ChannelDiagnosis) != 0;
  notification.manufacturerSpecific = (alarmSpecifier & AlarmNotificationBitmask::ManufacturerSpecific) != 0;
  notification.submoduleDiagnosisState = (alarmSpecifier & AlarmNotificationBitmask::SubmoduleDiagnosisState) != 0;
  notification.arDiagnosisState = (alarmSpecifier & AlarmNotificationBitmask::ArDiagnosisState) != 0; // dit zou ook 0x8000
                                                                                                      // (bit 15, maar die lijkt ook voor Channel diagnosis te zijn)
                                                                                                      // kunnen zijn, bit 14 is gereserveerd.
 
  const std::size_t blockBodyLength = hdr.blockLength;
  constexpr std::size_t blockVersionSize = 2;
  constexpr std::size_t alarmBodySize = 20;
 
  if (blockBodyLength < blockVersionSize + alarmBodySize)
  {
    throw std::invalid_argument("Invalid AlarmNotification BlockLength");
  }
 
  const std::size_t blockEnd = 4U + blockBodyLength;
 
  if (data.size() < blockEnd)
  {
    throw std::invalid_argument("Truncated AlarmNotification block");
  }
 
  notification.rawPayload = Bytes(data.begin() + offset, data.begin() + blockEnd);
 
  //  notification.rawPayload = Bytes(data.begin() + offset, data.end());
 
  std::size_t itemOffset = 0;
  const Bytes& payload = notification.rawPayload;
  while (itemOffset < payload.size())
  {
    try
    {
      auto [item, new_offset] = ParseAlarmItem(payload, itemOffset);
      notification.items.push_back(std::move(item));
      itemOffset = new_offset;
    }
    catch (const std::invalid_argument&)
    {
      break;
    }
  }
 
  return notification;
}
 
RtaErrorReason RtaError::ClassifyRtaErrorReason(std::uint8_t errorCode2)
{
  switch (errorCode2)
  {
    case 0x00:
      return RtaErrorReason::Reserved;
 
    case 0x01:
      return RtaErrorReason::SequenceNumber;
 
    case 0x02:
      return RtaErrorReason::InstanceClosed;
 
    case 0x03:
      return RtaErrorReason::ArOutOfMemory;
 
    case 0x04:
      return RtaErrorReason::ArAddProviderConsumerFailed;
 
    case 0x05:
      return RtaErrorReason::ArConsumerDhtWdtExpired;
 
    case 0x06:
      return RtaErrorReason::ArCmiTimeout;
 
    case 0x07:
      return RtaErrorReason::ArAlarmOpenFailed;
 
    case 0x08:
      return RtaErrorReason::ArAlarmSendConfirmationNegative;
 
    case 0x09:
      return RtaErrorReason::ArAlarmAckSendConfirmationNegative;
 
    case 0x0A:
      return RtaErrorReason::ArAlarmDataTooLong;
 
    case 0x0B:
      return RtaErrorReason::ArAlarmIndError;
 
    case 0x0C:
      return RtaErrorReason::ArRpcClientCallConfirmationNegative;
 
    case 0x0D:
      return RtaErrorReason::ArAbortRequest;
 
    case 0x0E:
      return RtaErrorReason::ArRerunAbortsExisting;
 
    case 0x0F:
      return RtaErrorReason::ArReleaseIndReceived;
 
    case 0x10:
      return RtaErrorReason::ArDeviceDeactivated;
 
    case 0x11:
      return RtaErrorReason::ArRemoved;
 
    case 0x12:
      return RtaErrorReason::ArProtocolViolation;
 
    case 0x13:
      return RtaErrorReason::ArNameResolutionError;
 
    case 0x14:
      return RtaErrorReason::ArRpcBindError;
 
    case 0x15:
      return RtaErrorReason::ArRpcConnectError;
 
    case 0x16:
      return RtaErrorReason::ArRpcReadError;
 
    case 0x17:
      return RtaErrorReason::ArRpcWriteError;
 
    case 0x18:
      return RtaErrorReason::ArRpcControlError;
 
    case 0x19:
      return RtaErrorReason::ArForbiddenPullPlug;
 
    case 0x1A:
      return RtaErrorReason::ArApRemoved;
 
    case 0x1B:
      return RtaErrorReason::ArLinkDown;
 
    case 0x1C:
      return RtaErrorReason::ArMulticastMacRegistrationFailed;
 
    case 0x1D:
      return RtaErrorReason::NotSynchronized;
 
    case 0x1E:
      return RtaErrorReason::WrongTopology;
 
    case 0x1F:
      return RtaErrorReason::DcpStationNameChanged;
 
    case 0x20:
      return RtaErrorReason::DcpResetToFactorySettings;
 
    case 0x21:
      return RtaErrorReason::CompanionAr8ippSubmodule;
 
    case 0x22:
      return RtaErrorReason::NoIrdataRecordYet;
 
    case 0x23:
      return RtaErrorReason::Pdev;
 
    case 0x24:
      return RtaErrorReason::PdevNoRequiredSpeedDuplexity;
 
    case 0x25:
      return RtaErrorReason::IpSuiteChanged;
 
    case 0x26:
      return RtaErrorReason::IocarSrRdhtExpired;
 
    case 0x27:
      return RtaErrorReason::IocarSrPdevParameterizationImpossible;
 
    case 0x28:
      return RtaErrorReason::RemoteApplicationReadyTimeout;
 
    case 0x29:
      return RtaErrorReason::IocarSrRedundantInterfaceLost;
 
    case 0x2A:
      return RtaErrorReason::IocarSrMtotExpired;
 
    case 0x2B:
      return RtaErrorReason::IocarSrArProtocolViolation;
 
    case 0x2C:
      return RtaErrorReason::PdevPlugPortWithoutCombinedObjectContainer;
 
    case 0x2D:
      return RtaErrorReason::ObsoletedNmeNoConfiguration;
 
    case 0xFF:
      return RtaErrorReason::UserAbort;
 
    default:
      return RtaErrorReason::Reserved;
  }
}
RtaErrorClass RtaError::ClassifyRtaError(std::uint8_t errorCode2)
{
  switch (errorCode2)
  {
    case 0x00:
      return RtaErrorClass::Reserved;
 
    case 0x01:
      return RtaErrorClass::SequenceNumber;
 
    case 0x02:
    case 0x03:
    case 0x04:
    case 0x05:
    case 0x06:
    case 0x07:
    case 0x08:
    case 0x09:
    case 0x0A:
    case 0x0B:
    case 0x0C:
    case 0x0D:
    case 0x0E:
    case 0x0F:
    case 0x10:
    case 0x11:
    case 0x12:
    case 0x13:
    case 0x14:
    case 0x15:
    case 0x16:
    case 0x17:
    case 0x18:
    case 0x19:
    case 0x1A:
    case 0x1B:
    case 0x1C:
    case 0x1D:
    case 0x1E:
    case 0x1F:
    case 0x20:
    case 0x21:
    case 0x22:
    case 0x23:
    case 0x24:
    case 0x25:
      return RtaErrorClass::Abort;
 
    case 0x26:
    case 0x27:
    case 0x28:
    case 0x29:
    case 0x2A:
    case 0x2B:
    case 0x2C:
      return RtaErrorClass::Extended;
 
    case 0x2D:
      return RtaErrorClass::Obsoleted;
 
    case 0xFF:
      return RtaErrorClass::Abort;
 
    default:
      return RtaErrorClass::Reserved;
  }
}
std::string RtaError::ReasonName() const
{
  switch (reason)
  {
    case RtaErrorReason::Reserved:
      return "Reserved";
 
    case RtaErrorReason::SequenceNumber:
      return "Error within the coordination of sequence numbers";
 
    case RtaErrorReason::InstanceClosed:
      return "Instance closed";
 
    case RtaErrorReason::ArOutOfMemory:
      return "AR out of memory";
 
    case RtaErrorReason::ArAddProviderConsumerFailed:
      return "AR add provider or consumer failed";
 
    case RtaErrorReason::ArConsumerDhtWdtExpired:
      return "AR consumer DHT/WDT expired";
 
    case RtaErrorReason::ArCmiTimeout:
      return "AR CMI timeout";
 
    case RtaErrorReason::ArAlarmOpenFailed:
      return "AR alarm-open failed";
 
    case RtaErrorReason::ArAlarmSendConfirmationNegative:
      return "AR alarm-send.cnf(-)";
 
    case RtaErrorReason::ArAlarmAckSendConfirmationNegative:
      return "AR alarm-ack-send.cnf(-)";
 
    case RtaErrorReason::ArAlarmDataTooLong:
      return "AR alarm data too long";
 
    case RtaErrorReason::ArAlarmIndError:
      return "AR alarm.ind(err)";
 
    case RtaErrorReason::ArRpcClientCallConfirmationNegative:
      return "AR RPC-client call.cnf(-)";
 
    case RtaErrorReason::ArAbortRequest:
      return "AR abort.req";
 
    case RtaErrorReason::ArRerunAbortsExisting:
      return "AR re-run aborts existing";
 
    case RtaErrorReason::ArReleaseIndReceived:
      return "AR release.ind received";
 
    case RtaErrorReason::ArDeviceDeactivated:
      return "AR device deactivated";
 
    case RtaErrorReason::ArRemoved:
      return "AR removed";
 
    case RtaErrorReason::ArProtocolViolation:
      return "AR protocol violation";
 
    case RtaErrorReason::ArNameResolutionError:
      return "AR name resolution error";
 
    case RtaErrorReason::ArRpcBindError:
      return "AR RPC-Bind error";
 
    case RtaErrorReason::ArRpcConnectError:
      return "AR RPC-Connect error";
 
    case RtaErrorReason::ArRpcReadError:
      return "AR RPC-Read error";
 
    case RtaErrorReason::ArRpcWriteError:
      return "AR RPC-Write error";
 
    case RtaErrorReason::ArRpcControlError:
      return "AR RPC-Control error";
 
    case RtaErrorReason::ArForbiddenPullPlug:
      return "AR forbidden pull or plug after check.rsp and before in-data.ind";
 
    case RtaErrorReason::ArApRemoved:
      return "AR AP removed";
 
    case RtaErrorReason::ArLinkDown:
      return "AR link down";
 
    case RtaErrorReason::ArMulticastMacRegistrationFailed:
      return "AR could not register multicast-mac address";
 
    case RtaErrorReason::NotSynchronized:
      return "Not synchronized (cannot start companion-AR)";
 
    case RtaErrorReason::WrongTopology:
      return "Wrong topology (cannot start companion-AR)";
 
    case RtaErrorReason::DcpStationNameChanged:
      return "DCP station-name changed";
 
    case RtaErrorReason::DcpResetToFactorySettings:
      return "DCP reset to factory-settings";
 
    case RtaErrorReason::CompanionAr8ippSubmodule:
      return "Cannot start companion-AR because of 0x8ipp submodule in first AR";
 
    case RtaErrorReason::NoIrdataRecordYet:
      return "No irdata record yet";
 
    case RtaErrorReason::Pdev:
      return "PDEV";
 
    case RtaErrorReason::PdevNoRequiredSpeedDuplexity:
      return "PDEV: no port offers required speed/duplexity";
 
    case RtaErrorReason::IpSuiteChanged:
      return "IP-Suite changed by DCP_Set(IPParameter) or local engineering";
 
    case RtaErrorReason::IocarSrRdhtExpired:
      return "IOCARSR: RDHT expired";
 
    case RtaErrorReason::IocarSrPdevParameterizationImpossible:
      return "IOCARSR: PDEV parameterization impossible";
 
    case RtaErrorReason::RemoteApplicationReadyTimeout:
      return "Remote application ready timeout expired";
 
    case RtaErrorReason::IocarSrRedundantInterfaceLost:
      return "IOCARSR: redundant interface lost or peripheral access impossible";
 
    case RtaErrorReason::IocarSrMtotExpired:
      return "IOCARSR: MTOT expired";
 
    case RtaErrorReason::IocarSrArProtocolViolation:
      return "IOCARSR: AR protocol violation";
 
    case RtaErrorReason::PdevPlugPortWithoutCombinedObjectContainer:
      return "PDEV: plug port without CombinedObjectContainer";
 
    case RtaErrorReason::ObsoletedNmeNoConfiguration:
      return "(Obsoleted) NME: no or wrong configuration";
 
    case RtaErrorReason::UserAbort:
      return "User abort";
  }
 
  return "Unknown RTA error";
}
RtaErrorClass ClassifyRtaError(RtaErrorReason reason)
{
  const auto value = static_cast<std::uint8_t>(reason);
 
  if (value == 0x00U)
  {
    return RtaErrorClass::Reserved;
  }
 
  if (value == 0x01U)
  {
    return RtaErrorClass::SequenceNumber;
  }
 
  if (value >= 0x02U && value <= 0x25U)
  {
    return RtaErrorClass::Abort;
  }
 
  if (value >= 0x26U && value <= 0x2CU)
  {
    return RtaErrorClass::Extended;
  }
 
  if (value == 0x2DU)
  {
    return RtaErrorClass::Obsoleted;
  }
 
  return RtaErrorClass::UserSpecific;
}
} // namespace profinet