alarms.cpp

Go to the documentation of this file.

 
 
#include "profinet/alarms.h"
 
#include <cstdio>
#include <map>
 
#include "profinet/wire.h"
 
namespace profinet
{
 
namespace
{
/*
const std::map<std::uint16_t, std::string>& UsiNames()
{
  static const std::map<std::uint16_t, std::string> table = {
      {USI_CHANNEL_DIAGNOSIS, "ChannelDiagnosis"},
      {USI_MULTIPLE_DIAGNOSIS, "MultipleDiagnosis"},
      {USI_EXT_CHANNEL_DIAGNOSIS, "ExtChannelDiagnosis"},
      {USI_QUALIFIED_CHANNEL_DIAGNOSIS, "QualifiedChannelDiagnosis"},
      {USI_MAINTENANCE, "MaintenanceItem"},
      {USI_UPLOAD, "UploadRecord"},
      {USI_IPARAMETER, "iParameterItem"},
      {USI_RS_ALARM_LOW, "RS_AlarmItem_Low"},
      {USI_RS_ALARM_HIGH, "RS_AlarmItem_High"},
      {USI_RS_ALARM_SUBMODULE, "RS_AlarmItem_Submodule"},
      {USI_PE_ALARM, "PE_AlarmItem"},
      {USI_PRAL_ALARM, "PRAL_AlarmItem"},
  };
  return table;
}
*/
/*
const std::map<std::uint16_t, std::string>& AlarmTypeNames()
{
  static const std::map<std::uint16_t, std::string> table = {
      {0x0001, "Diagnosis"},
      {0x0002, "Process"},
      {0x0003, "Pull"},
      {0x0004, "Plug"},
      {0x0005, "Status"},
      {0x0006, "Update"},
      {0x0007, "Redundancy"},
      {0x0008, "ControlledBySupervisor"},
      {0x0009, "Released"},
      {0x000A, "PlugWrongSubmodule"},
      {0x000B, "ReturnOfSubmodule"},
      {0x000C, "DiagnosisDisappears"},
      {0x000D, "MulticastMismatch"},
      {0x000E, "PortDataChange"},
      {0x000F, "SyncDataChanged"},
      {0x0010, "IsochronousModeProblem"},
      {0x0011, "NetworkComponentProblem"},
      {0x0012, "TimeDataChanged"},
      {0x0013, "DynamicFramePackingProblem"},
      {0x001E, "UploadAndRetrieval"},
      {0x001F, "PullModule"},
  };
  return table;
}
*/
} // namespace
 
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");
  }
 
  DiagnosisItem item;
  item.userStructureId = usi;
  item.channelNumber = static_cast<std::uint16_t>((data[offset] << OneOctetShift) | data[offset + 1]);
  item.channelProperties = static_cast<std::uint16_t>((data[offset + 2] << OneOctetShift) | data[offset + 3]);
  item.channelErrorType = static_cast<std::uint16_t>((data[offset + 4] << OneOctetShift) | data[offset + 5]);
  offset += 6;
 
  if (usi == Usi::ExtendedChannelDiagnosis || usi == Usi::QualifiedChannelDiagnosis)
  {
    if (data.size() < offset + 6)
    {
      throw std::invalid_argument("Truncated ExtChannelDiagnosis");
    }
    item.extChannelErrorType = static_cast<std::uint16_t>((data[offset] << OneOctetShift) | data[offset + 1]);
    item.extChannelAddValue = static_cast<std::uint32_t>(data[offset + 2]) << ThreeOctetsShift |
                              static_cast<std::uint32_t>(data[offset + 3]) << TwoOctetsShift |
                              static_cast<std::uint32_t>(data[offset + 4]) << OneOctetShift | data[offset + 5];
    offset += 6;
  }
 
  if (usi == Usi::QualifiedChannelDiagnosis)
  {
    if (data.size() < offset + 4)
    {
      throw std::invalid_argument("Truncated QualifiedChannelDiagnosis");
    }
    item.qualifiedChannelQualifier = static_cast<std::uint32_t>(data[offset]) << ThreeOctetsShift |
                                     static_cast<std::uint32_t>(data[offset + 1]) << TwoOctetsShift |
                                     static_cast<std::uint32_t>(data[offset + 2]) << OneOctetShift | data[offset + 3];
    offset += 4;
  }
 
  return {item, offset};
}
 
std::pair<MaintenanceItem, std::size_t> ParseMaintenanceItem(const Bytes& data, std::size_t offset)
{
  if (data.size() < offset + 12)
  {
    throw std::invalid_argument("Truncated MaintenanceItem");
  }
  const PNBlockHeader hdr = PNBlockHeader::Parse(Bytes(data.begin() + offset, data.begin() + offset + 6));
  offset += 6 + 2; // + 2-byte padding
 
  const std::uint32_t status = static_cast<std::uint32_t>(data[offset]) << ThreeOctetsShift |
                               static_cast<std::uint32_t>(data[offset + 1]) << TwoOctetsShift |
                               static_cast<std::uint32_t>(data[offset + 2]) << OneOctetShift | data[offset + 3];
  offset += 4;
 
  MaintenanceItem item;
  item.userStructureId = Usi::Maintenance;
  item.blockType = hdr.blockType;
  item.blockLength = hdr.blockLength;
  item.blockVersion = static_cast<std::uint16_t>((hdr.blockVersionHigh << OneOctetShift) | hdr.blockVersionLow);
  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 + 16)
  {
    throw std::invalid_argument("Truncated UploadRetrievalItem");
  }
  const PNBlockHeader hdr = PNBlockHeader::Parse(Bytes(data.begin() + offset, data.begin() + offset + 6));
  offset += 6 + 2; // + 2-byte padding
 
  const std::uint32_t index = static_cast<std::uint32_t>(data[offset]) << ThreeOctetsShift |
                              static_cast<std::uint32_t>(data[offset + 1]) << TwoOctetsShift |
                              static_cast<std::uint32_t>(data[offset + 2]) << OneOctetShift | data[offset + 3];
  offset += 4;
  const std::uint32_t length = static_cast<std::uint32_t>(data[offset]) << ThreeOctetsShift |
                               static_cast<std::uint32_t>(data[offset + 1]) << TwoOctetsShift |
                               static_cast<std::uint32_t>(data[offset + 2]) << OneOctetShift | data[offset + 3];
  offset += 4;
 
  UploadRetrievalItem item;
  item.userStructureId = usi;
  item.blockType = hdr.blockType;
  item.blockLength = hdr.blockLength;
  item.blockVersion = static_cast<std::uint16_t>((hdr.blockVersionHigh << OneOctetShift) | hdr.blockVersionLow);
  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 + 7)
  {
    throw std::invalid_argument("Truncated PE_AlarmItem");
  }
  const PNBlockHeader hdr = PNBlockHeader::Parse(Bytes(data.begin() + offset, data.begin() + offset + 6));
  offset += 6;
  const std::uint8_t mode = data[offset];
  offset += 1;
 
  PEAlarmItem item;
  item.userStructureId = Usi::PeAlarm;
  item.blockType = hdr.blockType;
  item.blockLength = hdr.blockLength;
  item.blockVersion = static_cast<std::uint16_t>((hdr.blockVersionHigh << OneOctetShift) | hdr.blockVersionLow);
  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 + 2)
  {
    throw std::invalid_argument("Truncated RS_AlarmItem");
  }
  const auto info = static_cast<std::uint16_t>((data[offset] << OneOctetShift) | data[offset + 1]);
  offset += 2;
 
  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 + 8)
  {
    throw std::invalid_argument("Truncated PRAL_AlarmItem");
  }
  const auto channelNum = static_cast<std::uint16_t>((data[offset] << OneOctetShift) | data[offset + 1]);
  const auto channelProps = static_cast<std::uint16_t>((data[offset + 2] << OneOctetShift) | data[offset + 3]);
  const auto reason = static_cast<std::uint16_t>((data[offset + 4] << OneOctetShift) | data[offset + 5]);
  const auto extReason = static_cast<std::uint16_t>((data[offset + 6] << OneOctetShift) | data[offset + 7]);
  offset += 8;
 
  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 + 2)
  {
    throw std::invalid_argument("Insufficient data for USI");
  }
 
  const auto usi = static_cast<Usi>((data[offset] << OneOctetShift) | data[offset + 1]);
  offset += 2;
 
  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). Upstream alarms.py checks for 28
  // and then advances its read offset by 22 after this body, but 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, itself
  // verified against the real profinet-py module's fmt_size).
 
  // 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() + 6));
  offset += 6;
 
  wire::Reader r(data.data() + offset, data.size() - offset);
  const auto alarmType = static_cast<AlarmType>(r.U16());
  const std::uint32_t api = r.U32();
  const std::uint16_t slotNumber = r.U16();
  const std::uint16_t subslotNumber = r.U16();
  const std::uint32_t moduleIdent = r.U32();
  const std::uint32_t submoduleIdent = r.U32();
  const std::uint16_t alarmSpecifier = r.U16();
  offset += 20;
 
  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 & 0x07FF;
  notification.channelDiagnosis = (alarmSpecifier & 0x0800) != 0;
  notification.manufacturerSpecific = (alarmSpecifier & 0x1000) != 0;
  notification.submoduleDiagnosisState = (alarmSpecifier & 0x2000) != 0;
  notification.arDiagnosisState = (alarmSpecifier & 0x8000) != 0; // dit zou ook 0x8000 (bit 15) 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;
}
 
} // namespace profinet