exceptions.cpp

Go to the documentation of this file.

 
 
// Ported from profinet-py's profinet/exceptions.py
#include "profinet/exceptions.h"
 
#include <cstdio>
#include <map>
 
#include "profinet/util.h"
 
namespace profinet
{
 
std::string GetErrorDecodeName(const ErrorDecode errorDecodeName)
{
  switch (errorDecodeName)
  {
    case ErrorDecode::PnioCm:
      return "PNIO Connection Management";
 
    case ErrorDecode::PnioRw:
      return "PNIO Read/Write";
 
    case ErrorDecode::Pnio:
      return "PNIO";
 
    default:
      return "Unknown (" +
             Hex2(static_cast<std::uint8_t>(errorDecodeName)) +
             ")";
  }
}
 
std::string GetPnioRwErrorCode1Name(const PnioRwErrorCode1 errorCodeRw1)
{
  switch (errorCodeRw1)
  {
    case PnioRwErrorCode1::InvalidIndex:
      return "Invalid Index";
 
    case PnioRwErrorCode1::WriteLength:
      return "Write Length Error";
 
    case PnioRwErrorCode1::Resource:
      return "Resource Error";
 
    case PnioRwErrorCode1::Access:
      return "Access Error";
 
    case PnioRwErrorCode1::Application:
      return "Application Error";
 
    default:
      return "Unknown (" +
             Hex2(static_cast<std::uint8_t>(errorCodeRw1)) +
             ")";
  }
}
 
std::string GetPnioCmErrorCode1Name(const PnioCmErrorCode1 errorCodeCm1)
{
  switch (errorCodeCm1)
  {
    case PnioCmErrorCode1::Ar:
      return "AR Block";
 
    case PnioCmErrorCode1::Iocr:
      return "IOCR Block";
 
    case PnioCmErrorCode1::AlarmCr:
      return "Alarm CR Block";
 
    case PnioCmErrorCode1::ExpectedSubmodule:
      return "Expected Submodule Block";
 
    case PnioCmErrorCode1::ModuleDiff:
      return "Module Difference Block";
 
    case PnioCmErrorCode1::ArRpc:
      return "AR RPC Block";
 
    case PnioCmErrorCode1::IrInfo:
      return "IR Info Block";
 
    case PnioCmErrorCode1::SrInfo:
      return "SR Info Block";
 
    case PnioCmErrorCode1::ArFsu:
      return "ARFSU Block";
 
    case PnioCmErrorCode1::IodControlRequest:
      return "IOD Control Request";
 
    case PnioCmErrorCode1::IodControlResponse:
      return "IOD Control Response";
 
    case PnioCmErrorCode1::ArResponse:
      return "AR Block Response";
 
    case PnioCmErrorCode1::IocrResponse:
      return "IOCR Block Response";
 
    case PnioCmErrorCode1::AlarmCrResponse:
      return "Alarm CR Block Response";
 
    case PnioCmErrorCode1::ModuleDiffResponse:
      return "Module Difference Block Response";
 
    case PnioCmErrorCode1::ArServerResponse:
      return "AR Server Block Response";
 
    case PnioCmErrorCode1::PrmServer:
      return "Parameter Server";
 
    case PnioCmErrorCode1::CmCtl:
      return "Connection Management Control";
 
    case PnioCmErrorCode1::CmDev:
      return "Connection Management Device";
 
    case PnioCmErrorCode1::CmRpc:
      return "Connection Management RPC";
 
    case PnioCmErrorCode1::FaultyRecord:
      return "Faulty Record Data";
 
    case PnioCmErrorCode1::FaultyAr:
      return "Faulty Application Relation";
 
    case PnioCmErrorCode1::FaultyBlock:
      return "Faulty Block Structure";
 
    default:
      return "Unknown (" +
             Hex2(static_cast<std::uint8_t>(errorCodeCm1)) +
             ")";
  }
}
 
std::string GetPnioRwErrorMessage(const PnioRwInvalidIndexErrorCode2 errorCode2)
{
  switch (errorCode2)
  {
    case PnioRwInvalidIndexErrorCode2::IndexNotSupported:
      return "Index not supported";
 
    case PnioRwInvalidIndexErrorCode2::IndexNotWritten:
      return "Index exists but has not been written";
 
    default:
      return "Unknown Error (" +
             Hex2(static_cast<std::uint8_t>(errorCode2)) +
             ")";
  }
}
 
std::string GetPnioRwErrorMessage(const PnioRwWriteLengthErrorCode2 errorCode2)
{
  switch (errorCode2)
  {
    case PnioRwWriteLengthErrorCode2::WriteLengthError:
      return "Write length error";
 
    case PnioRwWriteLengthErrorCode2::DataTooShort:
      return "Write data is too short";
 
    case PnioRwWriteLengthErrorCode2::DataTooLong:
      return "Write data is too long";
 
    case PnioRwWriteLengthErrorCode2::WriteProtected:
      return "Write access denied (write protected)";
 
    default:
      return "Unknown Error (" +
             Hex2(static_cast<std::uint8_t>(errorCode2)) +
             ")";
  }
}
 
std::string GetPnioRwErrorMessage(const PnioRwResourceErrorCode2 errorCode2)
{
  switch (errorCode2)
  {
    case PnioRwResourceErrorCode2::ResourceNotAvailable:
      return "Resource not available";
 
    case PnioRwResourceErrorCode2::InvalidSlot:
      return "Invalid slot number";
 
    case PnioRwResourceErrorCode2::InvalidSubslot:
      return "Invalid subslot number";
 
    case PnioRwResourceErrorCode2::ModuleHasNoData:
      return "Module has no data";
 
    default:
      return "Unknown Error (" +
             Hex2(static_cast<std::uint8_t>(errorCode2)) +
             ")";
  }
}
 
std::string GetPnioRwErrorMessage(const PnioRwAccessErrorCode2 errorCode2)
{
  switch (errorCode2)
  {
    case PnioRwAccessErrorCode2::InvalidArea:
      return "Access denied (invalid area)";
 
    case PnioRwAccessErrorCode2::AccessDenied:
      return "Access denied";
 
    case PnioRwAccessErrorCode2::InvalidRange:
      return "Access denied (invalid range)";
 
    case PnioRwAccessErrorCode2::InvalidState:
      return "Access denied (invalid state for access)";
 
    case PnioRwAccessErrorCode2::LocalControl:
      return "Access denied (local control)";
 
    default:
      return "Unknown Error (" +
             Hex2(static_cast<std::uint8_t>(errorCode2)) +
             ")";
  }
}
 
std::string GetPnioRwErrorMessage(const PnioRwApplicationErrorCode2 errorCode2)
{
  switch (errorCode2)
  {
    case PnioRwApplicationErrorCode2::ReadError:
      return "Read error";
 
    case PnioRwApplicationErrorCode2::WriteError:
      return "Write error";
 
    case PnioRwApplicationErrorCode2::ModuleFailure:
      return "Module failure";
 
    case PnioRwApplicationErrorCode2::ResourceBusy:
      return "Resource busy";
 
    case PnioRwApplicationErrorCode2::VersionConflict:
      return "Version conflict";
 
    case PnioRwApplicationErrorCode2::InvalidApi:
      return "Invalid API number";
 
    case PnioRwApplicationErrorCode2::BackupNotAllowed:
      return "Backup not allowed";
 
    case PnioRwApplicationErrorCode2::AlarmPending:
      return "Alarm pending";
 
    default:
      return "Unknown Error (" +
             Hex2(static_cast<std::uint8_t>(errorCode2)) +
             ")";
  }
}
 
std::string GetPnioErrorCode1Name(const PnioErrorCode1 errorCode1)
{
  switch (errorCode1)
  {
    case PnioErrorCode1::Rmpm:
      return "RMPM";
 
    case PnioErrorCode1::PrmServer:
      return "PrmServer";
 
    default:
      return "Unknown(" +
             Hex2(static_cast<std::uint8_t>(errorCode1)) +
             ")";
  }
}
 
std::string GetPnioErrorMessage(const PnioRmpmErrorCode2 errorCode2)
{
  switch (errorCode2)
  {
    case PnioRmpmErrorCode2::InvalidArgumentsLength:
      return "Invalid arguments length";
 
    case PnioRmpmErrorCode2::UnknownBlocksInRequest:
      return "Unknown blocks in request";
 
    case PnioRmpmErrorCode2::RequiredIocrBlockMissing:
      return "Required IOCR block missing";
 
    case PnioRmpmErrorCode2::WrongAlarmCrBlockCount:
      return "Wrong AlarmCR block count";
 
    case PnioRmpmErrorCode2::OutOfArResources:
      return "Out of AR resources";
 
    default:
      return "Unknown Error (" +
             Hex2(static_cast<std::uint8_t>(errorCode2)) +
             ")";
  }
}
 
std::string GetPnioErrorMessage(const PnioPrmServerErrorCode2 errorCode2)
{
  switch (errorCode2)
  {
    case PnioPrmServerErrorCode2::StateConflict:
      return "Parameter server state conflict";
 
    default:
      return "Unknown Error (" +
             Hex2(static_cast<std::uint8_t>(errorCode2)) +
             ")";
  }
}
 
std::string GetPnioRwErrorMessage(const PnioRwErrorCode1 errorCode1, const std::uint8_t errorCode2)
{
  switch (errorCode1)
  {
    case PnioRwErrorCode1::InvalidIndex:
    {
      const auto errCode2 = static_cast<PnioRwInvalidIndexErrorCode2>(errorCode2);
      return GetPnioRwErrorMessage(errCode2);
    }
    case PnioRwErrorCode1::WriteLength:
    {
      const auto errCode2 = static_cast<PnioRwWriteLengthErrorCode2>(errorCode2);
      return GetPnioRwErrorMessage(errCode2);
    }
    case PnioRwErrorCode1::Resource:
    {
      const auto errCode2 = static_cast<PnioRwResourceErrorCode2>(errorCode2);
      return GetPnioRwErrorMessage(errCode2);
    }
    case PnioRwErrorCode1::Access:
    {
      const auto errCode2 = static_cast<PnioRwAccessErrorCode2>(errorCode2);
      return GetPnioRwErrorMessage(errCode2);
    }
    case PnioRwErrorCode1::Application:
    {
      const auto errCode2 = static_cast<PnioRwApplicationErrorCode2>(errorCode2);
      return GetPnioRwErrorMessage(errCode2);
    }
  }
 
  return "Unknown Error (" + Hex2(errorCode2) + ")";
}
 
std::string GetPnioCmErrorMessage(const PnioCmArErrorCode2 errorCode2)
{
  switch (errorCode2)
  {
    case PnioCmArErrorCode2::InvalidArType:
      return "Invalid AR type";
 
    case PnioCmArErrorCode2::ArAlreadyActive:
      return "AR already active";
 
    case PnioCmArErrorCode2::NoArResources:
      return "Out of AR resources";
 
    case PnioCmArErrorCode2::NoProviderResources:
      return "Out of provider resources";
 
    case PnioCmArErrorCode2::NoConsumerResources:
      return "Out of consumer resources";
 
    case PnioCmArErrorCode2::NoAlarmResources:
      return "Out of alarm resources";
 
    case PnioCmArErrorCode2::NoMemory:
      return "Out of memory";
 
    case PnioCmArErrorCode2::InvalidSessionKey:
      return "Invalid session key";
 
    case PnioCmArErrorCode2::ArUuidConflict:
      return "AR UUID conflict";
 
    default:
      return "Unknown Error (" +
             Hex2(static_cast<std::uint8_t>(errorCode2)) +
             ")";
  }
}
 
std::string GetPnioCmErrorMessage(const PnioCmIocrErrorCode2 errorCode2)
{
  switch (errorCode2)
  {
    case PnioCmIocrErrorCode2::InvalidIocrType:
      return "Invalid IOCR type";
 
    case PnioCmIocrErrorCode2::NoIocrResources:
      return "Out of IOCR resources";
 
    case PnioCmIocrErrorCode2::InvalidFrameId:
      return "Invalid frame ID";
 
    case PnioCmIocrErrorCode2::InvalidRtClass:
      return "Invalid RT class";
 
    case PnioCmIocrErrorCode2::InvalidIoDataLength:
      return "Invalid IO data length";
 
    case PnioCmIocrErrorCode2::CycleTimeConflict:
      return "Cycle time conflict";
 
    case PnioCmIocrErrorCode2::WatchdogConfigurationError:
      return "Watchdog configuration error";
 
    default:
      return "Unknown Error (" +
             Hex2(static_cast<std::uint8_t>(errorCode2)) +
             ")";
  }
}
 
std::string GetPnioCmErrorMessage(const PnioCmAlarmCrErrorCode2 errorCode2)
{
  switch (errorCode2)
  {
    case PnioCmAlarmCrErrorCode2::InvalidAlarmCrType:
      return "Invalid AlarmCR type";
 
    case PnioCmAlarmCrErrorCode2::NoAlarmCrResources:
      return "Out of AlarmCR resources";
 
    default:
      return "Unknown Error (" +
             Hex2(static_cast<std::uint8_t>(errorCode2)) +
             ")";
  }
}
 
std::string GetPnioCmErrorMessage(const PnioCmExpectedSubmoduleErrorCode2 errorCode2)
{
  switch (errorCode2)
  {
    case PnioCmExpectedSubmoduleErrorCode2::InvalidSlot:
      return "Invalid slot number";
 
    case PnioCmExpectedSubmoduleErrorCode2::InvalidSubslot:
      return "Invalid subslot number";
 
    case PnioCmExpectedSubmoduleErrorCode2::WrongModuleIdentNumber:
      return "Wrong module identification number";
 
    case PnioCmExpectedSubmoduleErrorCode2::WrongSubmoduleIdentNumber:
      return "Wrong submodule identification number";
 
    case PnioCmExpectedSubmoduleErrorCode2::IoDataLengthMismatch:
      return "IO data length mismatch";
 
    default:
      return "Unknown Error (" +
             Hex2(static_cast<std::uint8_t>(errorCode2)) +
             ")";
  }
}
 
std::string GetPnioCmErrorMessage(const PnioCmDeviceErrorCode2 errorCode2)
{
  switch (errorCode2)
  {
    case PnioCmDeviceErrorCode2::DeviceStateConflict:
      return "Device state conflict";
 
    case PnioCmDeviceErrorCode2::ConnectionResourceUnavailable:
      return "Connection resource unavailable";
 
    case PnioCmDeviceErrorCode2::AlreadyOwned:
      return "Device already owned";
 
    case PnioCmDeviceErrorCode2::ArSetAborted:
      return "AR set aborted";
 
    default:
      return "Unknown Error (" +
             Hex2(static_cast<std::uint8_t>(errorCode2)) +
             ")";
  }
}
 
std::string GetPnioCmErrorMessage(const PnioCmFaultyBlockErrorCode2 errorCode2)
{
  switch (errorCode2)
  {
    case PnioCmFaultyBlockErrorCode2::FaultyBlockStructure:
      return "Faulty block structure";
 
    default:
      return "Unknown Error (" +
             Hex2(static_cast<std::uint8_t>(errorCode2)) +
             ")";
  }
}
 
PNIOError PNIOError::FromBytes(std::span<const std::uint8_t, 4> data)
{
  // Expliciet benoemde indices in lowerCamelCase om te voldoen aan je stijlrichtlijn
  static constexpr std::size_t idxErrorCode = 0;
  static constexpr std::size_t idxErrorDecode = 1;
  static constexpr std::size_t idxErrorCode1 = 2;
  static constexpr std::size_t idxErrorCode2 = 3;
 
  // We gebruiken .at() of directe span-indexering; Clang-Tidy staat dit toe
  // omdat de grootte (4) compile-time gegarandeerd is via de span-template.
  return CreateFromCodes(data[idxErrorCode],
                         data[idxErrorDecode],
                         data[idxErrorCode1],
                         data[idxErrorCode2]);
}
 
PNIOError PNIOError::FromArgsStatus(std::uint32_t argsStatus)
{
  // args_status was parsed as big-endian from little-endian wire bytes by
  // the caller, so byte-swap it back to Hilscher-style ordering, exactly
  // as the Python implementation does.
  const std::uint32_t swapped = ((argsStatus & LowByteMask) << ThreeOctetsShift) | (((argsStatus >> OneOctetShift) & LowByteMask) << TwoOctetsShift) |
                                (((argsStatus >> TwoOctetsShift) & LowByteMask) << OneOctetShift) | ((argsStatus >> ThreeOctetsShift) & LowByteMask);
 
  const std::uint8_t errorCode = (swapped >> ThreeOctetsShift) & LowByteMask;
  const std::uint8_t errorDecode = (swapped >> TwoOctetsShift) & LowByteMask;
  const std::uint8_t errorCode1 = (swapped >> OneOctetShift) & LowByteMask;
  const std::uint8_t errorCode2 = swapped & LowByteMask;
 
  return CreateFromCodes(errorCode, errorDecode, errorCode1, errorCode2);
}
 
std::string DecodePnioCmError(const std::uint8_t& errorCode1, const std::uint8_t& errorCode2)
{
  const auto code1 = static_cast<PnioCmErrorCode1>(errorCode1);
 
  switch (code1)
  {
    case PnioCmErrorCode1::Ar:
      return GetPnioCmErrorMessage(PnioCmArErrorCode2{static_cast<std::uint8_t>(errorCode2)});
 
    case PnioCmErrorCode1::ArResponse:
      return GetPnioCmErrorMessage(PnioCmArErrorCode2{static_cast<std::uint8_t>(errorCode2)}) + " (in response)";
 
    case PnioCmErrorCode1::Iocr:
      return GetPnioCmErrorMessage(PnioCmIocrErrorCode2{static_cast<std::uint8_t>(errorCode2)});
 
    case PnioCmErrorCode1::IocrResponse:
      return GetPnioCmErrorMessage(PnioCmIocrErrorCode2{static_cast<std::uint8_t>(errorCode2)}) + " (in response)";
 
    case PnioCmErrorCode1::AlarmCr:
      return GetPnioCmErrorMessage(PnioCmAlarmCrErrorCode2{static_cast<std::uint8_t>(errorCode2)});
 
    case PnioCmErrorCode1::AlarmCrResponse:
      return GetPnioCmErrorMessage(PnioCmAlarmCrErrorCode2{static_cast<std::uint8_t>(errorCode2)}) + " (in response)";
 
    case PnioCmErrorCode1::ExpectedSubmodule:
      return GetPnioCmErrorMessage(PnioCmExpectedSubmoduleErrorCode2{static_cast<std::uint8_t>(errorCode2)});
 
    case PnioCmErrorCode1::CmDev:
      return GetPnioCmErrorMessage(PnioCmDeviceErrorCode2{static_cast<std::uint8_t>(errorCode2)});
 
    case PnioCmErrorCode1::FaultyBlock:
      return GetPnioCmErrorMessage(PnioCmFaultyBlockErrorCode2{static_cast<std::uint8_t>(errorCode2)});
 
    default:
      return "Unknown CM error in " + GetPnioCmErrorCode1Name(code1);
  }
}
std::string DecodePnioError(const std::uint8_t& errorCode1, const std::uint8_t& errorCode2)
{
  const auto code1 = static_cast<PnioErrorCode1>(errorCode1);
 
  switch (code1)
  {
    case PnioErrorCode1::Rmpm:
      return GetPnioErrorMessage(PnioRmpmErrorCode2{static_cast<std::uint8_t>(errorCode2)});
 
    case PnioErrorCode1::PrmServer:
      return GetPnioErrorMessage(PnioPrmServerErrorCode2{static_cast<std::uint8_t>(errorCode2)});
 
    default:
      return "Unknown PNIO error";
  }
}
std::string DecodePnioRWError(const std::uint8_t& errorCode1, const std::uint8_t& errorCode2)
{
  const auto code1 = static_cast<PnioRwErrorCode1>(errorCode1);
 
  switch (code1)
  {
    case PnioRwErrorCode1::InvalidIndex:
      return GetPnioRwErrorMessage(PnioRwInvalidIndexErrorCode2{static_cast<std::uint8_t>(errorCode2)});
 
    case PnioRwErrorCode1::WriteLength:
      return GetPnioRwErrorMessage(PnioRwWriteLengthErrorCode2{static_cast<std::uint8_t>(errorCode2)});
 
    case PnioRwErrorCode1::Resource:
      return GetPnioRwErrorMessage(PnioRwResourceErrorCode2{static_cast<std::uint8_t>(errorCode2)});
 
    case PnioRwErrorCode1::Access:
      return GetPnioRwErrorMessage(PnioRwAccessErrorCode2{static_cast<std::uint8_t>(errorCode2)});
 
    case PnioRwErrorCode1::Application:
      return GetPnioRwErrorMessage(PnioRwApplicationErrorCode2{static_cast<std::uint8_t>(errorCode2)});
 
    default:
      return "Unknown PNIORW error";
  }
}
 
PNIOError PNIOError::CreateFromCodes(
    const std::uint8_t errorCode,
    const std::uint8_t errorDecode,
    const std::uint8_t errorCode1,
    const std::uint8_t errorCode2)
{
  std::string message;
 
  const auto decode = static_cast<ErrorDecode>(errorDecode);
 
  switch (decode)
  {
    case ErrorDecode::PnioCm:
      message = DecodePnioCmError(errorCode1, errorCode2);
      break;
    case ErrorDecode::Pnio:
      message = DecodePnioError(errorCode1, errorCode2);
      break;
    case ErrorDecode::PnioRw:
      message = DecodePnioRWError(errorCode1, errorCode2);
      break;
    default:
      message = "Unknown error (Decode=" +
                Hex2(errorDecode) +
                ")";
      break;
  }
 
  return {message, errorCode, errorDecode, errorCode1, errorCode2};
}
std::string PNIOError::BlockName() const
{
  if (!IsCmError())
  {
    return "";
  }
 
  return GetPnioCmErrorCode1Name(
      static_cast<PnioCmErrorCode1>(errorCode1));
}
} // namespace profinet