exceptions.h

Go to the documentation of this file.

 
#pragma once
 
#include <cstdint>
#include <span>
#include <stdexcept>
#include <string>
 
namespace profinet
{
 
enum class ErrorDecode : std::uint8_t
{
  PnioCm = 0x40,
 
  PnioRw = 0x80,
 
  Pnio = 0x81
};
 
std::string GetErrorDecodeName(ErrorDecode errorDecodeName);
 
enum class PnioRwErrorCode1 : std::uint8_t
{
  InvalidIndex = 0xB0,
 
  WriteLength = 0xB1,
 
  Resource = 0xB2,
 
  Access = 0xB3,
 
  Application = 0xB4
};
 
std::string GetPnioRwErrorCode1Name(PnioRwErrorCode1 errorCodeRw1);
 
enum class PnioCmErrorCode1 : std::uint8_t
{
  Ar = 0x01,
 
  Iocr = 0x02,
 
  AlarmCr = 0x03,
 
  ExpectedSubmodule = 0x04,
 
  ModuleDiff = 0x05,
 
  ArRpc = 0x06,
 
  IrInfo = 0x07,
 
  SrInfo = 0x08,
 
  ArFsu = 0x09,
 
  IodControlRequest = 0x10,
 
  IodControlResponse = 0x11,
 
  ArResponse = 0x81,
 
  IocrResponse = 0x82,
 
  AlarmCrResponse = 0x83,
 
  ModuleDiffResponse = 0x84,
 
  ArServerResponse = 0x85,
 
  PrmServer = 0x3D,
 
  CmCtl = 0x3E,
 
  CmDev = 0x3F,
 
  CmRpc = 0x40,
 
  FaultyRecord = 0xFD,
 
  FaultyAr = 0xFE,
 
  FaultyBlock = 0xFF
};
 
std::string GetPnioCmErrorCode1Name(PnioCmErrorCode1 errorCodeCm1);
 
enum class PnioRwInvalidIndexErrorCode2 : std::uint8_t
{
  IndexNotSupported = 0x00,
 
  IndexNotWritten = 0x05
};
 
std::string GetPnioRwErrorMessage(PnioRwInvalidIndexErrorCode2 errorCode2);
 
enum class PnioRwWriteLengthErrorCode2 : std::uint8_t
{
  WriteLengthError = 0x00,
 
  DataTooShort = 0x01,
 
  DataTooLong = 0x02,
 
  WriteProtected = 0x03
};
 
std::string GetPnioRwErrorMessage(PnioRwWriteLengthErrorCode2 errorCode2);
 
enum class PnioRwResourceErrorCode2 : std::uint8_t
{
  ResourceNotAvailable = 0x00,
 
  InvalidSlot = 0x07,
 
  InvalidSubslot = 0x08,
 
  ModuleHasNoData = 0x09
};
 
std::string GetPnioRwErrorMessage(PnioRwResourceErrorCode2 errorCode2);
 
enum class PnioRwAccessErrorCode2 : std::uint8_t
{
  InvalidArea = 0x00,
 
  AccessDenied = 0x03,
 
  InvalidRange = 0x04,
 
  InvalidState = 0x05,
 
  LocalControl = 0x06
};
 
std::string GetPnioRwErrorMessage(PnioRwAccessErrorCode2 errorCode2);
 
enum class PnioRwApplicationErrorCode2 : std::uint8_t
{
  ReadError = 0x00,
 
  WriteError = 0x01,
 
  ModuleFailure = 0x02,
 
  ResourceBusy = 0x04,
 
  VersionConflict = 0x05,
 
  InvalidApi = 0x06,
 
  BackupNotAllowed = 0x07,
 
  AlarmPending = 0x08
};
 
std::string GetPnioRwErrorMessage(PnioRwApplicationErrorCode2 errorCode2);
 
enum class PnioCmArErrorCode2 : std::uint8_t
{
  InvalidArType = 0x00,
 
  ArAlreadyActive = 0x01,
 
  NoArResources = 0x02,
 
  NoProviderResources = 0x03,
 
  NoConsumerResources = 0x04,
 
  NoAlarmResources = 0x05,
 
  NoMemory = 0x06,
 
  InvalidSessionKey = 0x07,
 
  ArUuidConflict = 0x08
};
 
std::string GetPnioCmErrorMessage(PnioCmArErrorCode2 errorCode2);
 
enum class PnioCmIocrErrorCode2 : std::uint8_t
{
  InvalidIocrType = 0x00,
 
  NoIocrResources = 0x01,
 
  InvalidFrameId = 0x02,
 
  InvalidRtClass = 0x03,
 
  InvalidIoDataLength = 0x04,
 
  CycleTimeConflict = 0x05,
 
  WatchdogConfigurationError = 0x06
};
 
std::string GetPnioCmErrorMessage(PnioCmIocrErrorCode2 errorCode2);
 
enum class PnioCmAlarmCrErrorCode2 : std::uint8_t
{
  InvalidAlarmCrType = 0x00,
 
  NoAlarmCrResources = 0x01
};
 
std::string GetPnioCmErrorMessage(PnioCmAlarmCrErrorCode2 errorCode2);
 
enum class PnioCmExpectedSubmoduleErrorCode2 : std::uint8_t
{
  InvalidSlot = 0x00,
 
  InvalidSubslot = 0x01,
 
  WrongModuleIdentNumber = 0x02,
 
  WrongSubmoduleIdentNumber = 0x03,
 
  IoDataLengthMismatch = 0x04
};
 
std::string GetPnioCmErrorMessage(PnioCmExpectedSubmoduleErrorCode2 errorCode2);
 
enum class PnioCmDeviceErrorCode2 : std::uint8_t
{
  DeviceStateConflict = 0x00,
 
  ConnectionResourceUnavailable = 0x01,
 
  AlreadyOwned = 0x02,
 
  ArSetAborted = 0x03
};
 
std::string GetPnioCmErrorMessage(PnioCmDeviceErrorCode2 errorCode2);
 
enum class PnioCmFaultyBlockErrorCode2 : std::uint8_t
{
  FaultyBlockStructure = 0x00
};
 
std::string GetPnioCmErrorMessage(PnioCmFaultyBlockErrorCode2 errorCode2);
 
enum class PnioErrorCode1 : std::uint8_t
{
  Rmpm = 0x40,
 
  PrmServer = 0x3D
};
 
std::string GetPnioErrorCode1Name(PnioErrorCode1 errorCode1);
 
enum class PnioRmpmErrorCode2 : std::uint8_t
{
  InvalidArgumentsLength = 0x00,
 
  UnknownBlocksInRequest = 0x01,
 
  RequiredIocrBlockMissing = 0x02,
 
  WrongAlarmCrBlockCount = 0x03,
 
  OutOfArResources = 0x04
};
 
std::string GetPnioErrorMessage(PnioRmpmErrorCode2 errorCode2);
 
enum class PnioPrmServerErrorCode2 : std::uint8_t
{
  StateConflict = 0x00
};
 
std::string GetPnioErrorMessage(PnioPrmServerErrorCode2 errorCode2);
 
std::string GetPnioRwErrorMessage(PnioRwErrorCode1 errorCode1, std::uint8_t errorCode2);
 
class ProfinetError : public std::runtime_error
{
 public:
  explicit ProfinetError(const std::string& message)
      : std::runtime_error(message)
  {
  }
};
 
class DCPError : public ProfinetError
{
 public:
  explicit DCPError(const std::string& message)
      : ProfinetError(message)
  {
  }
};
 
class DCPTimeoutError : public DCPError
{
 public:
  explicit DCPTimeoutError(const std::string& message)
      : DCPError(message)
  {
  }
};
 
class DCPDeviceNotFoundError : public DCPError
{
 public:
  explicit DCPDeviceNotFoundError(const std::string& message)
      : DCPError(message)
  {
  }
};
 
class RPCError : public ProfinetError
{
 public:
  explicit RPCError(const std::string& message)
      : ProfinetError(message)
  {
  }
};
 
class RPCTimeoutError : public RPCError
{
 public:
  explicit RPCTimeoutError(const std::string& message)
      : RPCError(message)
  {
  }
};
 
class RPCFaultError : public RPCError
{
 public:
  explicit RPCFaultError(const std::string& message, std::uint32_t faultCode = 0)
      : RPCError(message), faultCode(faultCode)
  {
  }
 
  std::uint32_t faultCode;
};
 
class RPCConnectionError : public RPCError
{
 public:
  explicit RPCConnectionError(const std::string& message)
      : RPCError(message)
  {
  }
};
 
class ValidationError : public ProfinetError
{
 public:
  explicit ValidationError(const std::string& message)
      : ProfinetError(message)
  {
  }
};
 
class InvalidMACError : public ValidationError
{
 public:
  explicit InvalidMACError(const std::string& message)
      : ValidationError(message)
  {
  }
};
 
class InvalidIPError : public ValidationError
{
 public:
  explicit InvalidIPError(const std::string& message)
      : ValidationError(message)
  {
  }
};
 
class SocketError : public ProfinetError
{
 public:
  explicit SocketError(const std::string& message)
      : ProfinetError(message)
  {
  }
};
 
class PermissionDeniedError : public SocketError
{
 public:
  explicit PermissionDeniedError(const std::string& message)
      : SocketError(message)
  {
  }
};
 
class PNIOError : public RPCError
{
 public:
  std::uint8_t errorCode = 0;
 
  std::uint8_t errorDecode = 0;
 
  std::uint8_t errorCode1 = 0;
 
  std::uint8_t errorCode2 = 0;
 
  PNIOError(const std::string& message,
            std::uint8_t errorCode,
            std::uint8_t errorDecode,
            std::uint8_t errorCode1,
            std::uint8_t errorCode2)
      : RPCError(message),
        errorCode(errorCode),
        errorDecode(errorDecode),
        errorCode1(errorCode1),
        errorCode2(errorCode2)
  {
  }
 
  static PNIOError FromBytes(std::span<const std::uint8_t, 4> data);
 
  static PNIOError FromArgsStatus(std::uint32_t argsStatus);
 
  [[nodiscard]] bool IsCmError() const
  {
    return static_cast<ErrorDecode>(errorDecode) == ErrorDecode::PnioCm;
  }
 
  [[nodiscard]] std::string BlockName() const;
 
 private:
  static void extracted(const std::uint8_t& errorCode1, const std::uint8_t& errorCode2, std::string& message);
  static PNIOError CreateFromCodes(std::uint8_t errorCode, std::uint8_t errorDecode,
                                   std::uint8_t errorCode1, std::uint8_t errorCode2);
};
 
} // namespace profinet