motion_master_error.h

Go to the documentation of this file.

#pragma once
 
#include <map>
#include <stdexcept>
 
class MotionMasterError : public std::runtime_error {
 public:
  enum class Error : unsigned int {
    kNone = 0,
    kInvalidRequest,
    kSmCannotGetState,
    kSmCannotGetOpMode,
    kSmCannotSetState,
    kSmCannotSetOpMode,
    kSmCannotSetStateOpMode,
    kSmCannotSetStateStoSbc,
    kSmFaultState,
    kSmAborted,
    kOffsetDetectionInitFailed,  // 10
    kOffsetDetectionNoCommutationEncoder,
    kOffsetDetectionTimeout,
    kOffsetDetectionFailed,
    kOffsetDetectionAborted,
    kSystemIdentificationFailed,
    kSystemIdentificationAborted,
    kSystemIdentificationZeroTorqueAmplitude,
    kSystemIdentificationZeroVelocityAmplitude,
    kSystemIdentificationWrongEncoderPolarity,
    kSystemIdentificationWrongPositionVelocityPolarity,  // 20
    kSystemIdentificationSmallMotionAmplitude,
    kSystemIdentificationInsufficientVelocityResolution,
    kSystemIdentificationBadDataQuality,
    kAutoTuningPositionFailed,
    kAutoTuningPositionAborted,
    kAutoTuningNoPositionControlEncoder,
    kAutoTuningCannotAchieveSettlingTime,
    kAutoTuningVelocityFailed,
    kAutoTuningVelocityAborted,
    kAutoTuningPlantModelInvalid,  // 30
    kAutoTuningPlantModelNotFound,
    kFullAutoTuningForbidden,
    kCoggingFailedHallEncoder,
    kCoggingFailedInvalidResolution,
    kCoggingFailedInvalidEncoderConfigurationWithGearboxV4,
    kCoggingFailedInvalidEncoderConfigurationWithGearboxV5,
    kCoggingFailedInvalidEncoderConfigurationNoGearbox,
    kCoggingFailedPositionControllerNotTuned,
    kCoggingFailedSmmConfigured,
    kCoggingInitFailed,  // 40
    kCoggingCannotReadData,
    kCoggingDataCorrupted,
    kCoggingRecordingFailed,
    kCoggingRecordingAborted,
    kCoggingRecordingTimeout,
    kCoggingSavingFailed,
    kCoggingSavingAborted,
    kCoggingSavingTimeout,
    kCoggingNotEnoughMovementSpace,
    kNarrowAngleCalibrationFailed,  // 50
    kNarrowAngleCalibrationInternalError,
    kNarrowAngleCalibrationAborted,
    kNarrowAngleCalibrationTimedOut,
    kNarrowAngleCalibrationMotorNotMoving,
    kNarrowAngleCalibrationTimeoutMotorTooSlow,
    kNarrowAngleCalibrationMotorTooSlow,
    kNarrowAngleCalibrationMotorSemiRotation,
    kNarrowAngleCalibrationMaxMotorSpeedTooLow,
    kNarrowAngleCalibrationDataOutOfRange,
    kNarrowAngleCalibrationBadData,  // 60
    kNarrowAngleCalibrationNoniusPhaseErrorTooHigh,
    kNarrowAngleCalibrationAbsResetFailed,
    kNarrowAngleCalibrationUnsafeAutoPositionAdjustment,
    kNarrowAngleCalibrationAutoPositionAdjustmentFailed,
    kNarrowAngleCalibrationInternalLimitReached,
    kNarrowAngleCalibrationNotEnoughMovementSpace,
    kNarrowAngleCalibrationInsufficientVelocityResolution,
    kNarrowAngleCalibrationEncoderDataRecordingFailed,
    kNarrowAngleCalibrationSmmConfigured,
    kNarrowAngleCalibrationFault,  // 70
    kNarrowAngleCalibrationNotSupported,
    kBrakeGetStatusFailed,
    kBrakeSetStatusFailed,
    kBrakeSetTimeout,
    kBrakeNotConfigured,
    kConfigurationSaveFailed,
    kCannotReadConfigurationFile,
    kCannotLoadConfigurationFile,
    kCannotReadError,
    kParameterChangeFailed,  // 80
    kParameterNotFound,
    kZipCorrupted,
    kFlashFailed,
    kFlashRefused,
    kFlashNotSupported,
    kSiiWriteFailed,
    kSiiCorrupted,
    kSiiRestoreInternalError,
    kFirmwareImageNotFoundInZip,
    kFileWriteFailed,  // 90
    kFileRemoveFailed,
    kFileNotFound,
    kFileAlreadyExists,
    kFileInvalidName,
    kFileDiskFull,
    kFileAccessDenied,
    kFileInvalidEthercatState,
    kFileInternalError,
    kDeviceReloadFailed,
    kClientNotInControl,  // 100
    kInvalidTxPdoPosition,
    kInvalidRxPdoPosition,
    kPrCannotStartTimer,
    kPrCannotStopTimer,
    kUnknownMessageType,
    kRespondingSlaves,
    kCannotDetectSlaves,
    kCannotExecuteSlaveProfile,
    kFaultResetTimeoutReactionActive,
    kFaultResetTimeout,  // 110
    kFaultResetNoFault,
    kFaultResetNotPossible,
    kDeviceNotFound,
    kOsCommandAlreadyRunning,
    kOsCommandFailed,
    kOsCommandTimeout,
    kOsCommandNotResponding,
    kOsCommandInvalid,
    kOsCommandNotSupported,
    kOsCommandNotAllowed,  // 120
    kOsCommandReserved,
    kOsCommandAborted,
    kOsCommandAutoAborted,
    kOsCommandInternal,
    kOsCommandUnknown,
    kOpenLoopFieldControlAborted,
    kCirculoEncoderConfigurationNotSupported,
    kCirculoEncoderConfigurationAlreadyRunning,
    kCirculoEncoderConfigurationFailed,
    kCirculoEncoderConfigurationEncoderNotUsed,  // 130
    kMotorOutsideSoftwarePositionLimits,
    kInvalidSoftwarePositionLimits,
    kEncoderOrdinalInvalid,
    kEncoderPortInvalid,
    kEncoderConfigurationInvalid,
    kEncoderNoCommutationEncoder,
    kEncoderNoPositionControlEncoder,
    kHrdStreamInitFailed,
    kHrdStreamStreamingFailed,
    kHrdStreamDurationValue,  // 140
    kHrdStreamDataIndexValue,
    kHrdStreamActionValue,
    kOpenPhaseDetectionOpenTerminalA,
    kOpenPhaseDetectionOpenTerminalB,
    kOpenPhaseDetectionOpenTerminalC,
    kOpenPhaseDetectionOpenFetAHigh,
    kOpenPhaseDetectionOpenFetALow,
    kOpenPhaseDetectionOpenFetBHigh,
    kOpenPhaseDetectionOpenFetBLow,
    kOpenPhaseDetectionOpenFetCHigh,  // 150
    kOpenPhaseDetectionOpenFetCLow,
    kPolePairDetectionCurrentAmplitude,
    kPhaseResistanceMeasurementCurrentAmplitude,
    kPhaseInductanceMeasurementCurrentAmplitude,
    kFeedConstantInvalid,
    kQuickStopTimeout,
    kQuickStopFailed,
    kEthercatStateChangeFailed,
    kUnknown = 9999
  };
 
  MotionMasterError();
 
  explicit MotionMasterError(Error error) noexcept;
 
  explicit operator bool() const;
 
  bool operator==(const MotionMasterError& other) const;
 
  Error get_error() const;
 
 private:
  inline static const std::map<MotionMasterError::Error, std::string>
      error_to_message_map_ = {
          {Error::kNone, "No error"},
          {Error::kInvalidRequest, "Invalid request!"},
          {Error::kSmCannotGetState,
           "Cannot get the current state (state machine)!"},
          {Error::kSmCannotGetOpMode,
           "Cannot get the current OP mode (state machine)!"},
          {Error::kSmCannotSetOpMode,
           "Cannot set the OP mode (state machine)!"},
          {Error::kSmCannotSetState, "Cannot set the state (state machine)!"},
          {Error::kSmCannotSetStateOpMode,
           "Cannot set both the state and the OP mode (state machine)!"},
          {Error::kSmCannotSetStateStoSbc,
           "Cannot set the state (state machine) - STO/SBC active!"},
          {Error::kSmFaultState, "Drive in fault state (state machine)!"},
          {Error::kSmAborted, "State transition aborted (state machine)!"},
          {Error::kOffsetDetectionInitFailed,
           "Offset detection initialization failed!"},
          {Error::kOffsetDetectionNoCommutationEncoder,
           "Offset detection requires a commutation encoder to be defined!"},
          {Error::kOffsetDetectionTimeout,
           "Offset detection failed (timeout)!"},
          {Error::kOffsetDetectionFailed, "Offset detection failed!"},
          {Error::kOffsetDetectionAborted, "Offset detection aborted!"},
          {Error::kSystemIdentificationFailed,
           "Failed to extract a stable model of the plant from the data. "
           "Please restart the procedure."},
          {Error::kSystemIdentificationAborted,
           "System identification aborted!"},
          {Error::kSystemIdentificationZeroTorqueAmplitude,
           "Recorded torque amplitude is close to zero. Please check if "
           "torque control mode operates normally or increase torque "
           "amplitude slider."},
          {Error::kSystemIdentificationZeroVelocityAmplitude,
           "Recorded velocity amplitude is close to zero. Please check if "
           "position and velocity data is available. If so, increase torque "
           "amplitude or reduce frequency range."},
          {Error::kSystemIdentificationWrongEncoderPolarity,
           "Applied torque and resulting acceleration have different signs. "
           "Please check encoder polarity."},
          {Error::kSystemIdentificationWrongPositionVelocityPolarity,
           "Polarity of position and velocity encoders do not match. Check "
           "position encoder polarity."},
          {Error::kSystemIdentificationSmallMotionAmplitude,
           "Low frequency motion amplitude is too small to effectively "
           "extract a plant model. Please increase applied torque or reduce "
           "frequency range."},
          {Error::kSystemIdentificationInsufficientVelocityResolution,
           "The current velocity resolution isn't sufficient for precise "
           "system identification. Please increase velocity resolution by "
           "using the object 0x60A9 SI unit velocity."},
          {Error::kSystemIdentificationBadDataQuality,
           "The quality of the recorded system identification data is not "
           "good enough to extract a stable plant model!"},
          {Error::kAutoTuningPositionFailed,
           "A stable process model cannot be extracted from the data. "
           "Automatic position tuning failed!"},
          {Error::kAutoTuningPositionAborted, "Automatic tuning aborted!"},
          {Error::kAutoTuningNoPositionControlEncoder,
           "The position control encoder cannot be detected! Auto-tuning "
           "cannot be done!"},
          {Error::kAutoTuningCannotAchieveSettlingTime,
           "Failed to achieve requested settling time. The system likely "
           "reached marginal stability. Consider increasing the settling "
           "time and the damping ratio."},
          {Error::kAutoTuningVelocityFailed,
           "Automatic velocity tuning failed!"},
          {Error::kAutoTuningVelocityAborted,
           "Automatic velocity tuning aborted!"},
          {Error::kAutoTuningPlantModelInvalid,
           "The plant model loaded from the flash memory is corrupted or "
           "invalid! Automatic tuning cannot be done! Please rerun system "
           "identification."},
          {Error::kAutoTuningPlantModelNotFound,
           "The plant model cannot be found in the flash memory! Automatic "
           "tuning cannot be done! Please run system identification first."},
          {Error::kFullAutoTuningForbidden,
           "Full automatic tuning is not possible while a controller is "
           "enabled!"},
          {Error::kCoggingFailedHallEncoder,
           "Cogging torque compensation recording procedure is not possible "
           "if a HALL encoder is used for motor shaft positioning!"},
          {Error::kCoggingFailedInvalidResolution,
           "Cogging torque compensation recording procedure is not possible "
           "if the commutation encoder has resolution less than 1024!"},
          {Error::kCoggingFailedInvalidEncoderConfigurationWithGearboxV4,
           "The encoder configuration is invalid for Cogging Torque "
           "recording. Assign the following functions to the motor side "
           "encoder: Commutation and motion control. Re-tune position "
           "control loop."},
          {Error::kCoggingFailedInvalidEncoderConfigurationWithGearboxV5,
           "The encoder configuration is invalid for Cogging Torque "
           "recording. Assign the following functions to the motor side "
           "encoder: Commutation, Velocity, Position. Re-tune position "
           "control loop."},
          {Error::kCoggingFailedInvalidEncoderConfigurationNoGearbox,
           "The encoder configuration is invalid for Cogging Torque "
           "recording. Assign encoder(s) with both the position and velocity "
           "functions. Re-tune position control loop."},
          {Error::kCoggingFailedPositionControllerNotTuned,
           "Position controller gains are set to zero. The position control "
           "loop has to be tuned in order to use the cogging torque "
           "compensation recording procedure."},
          {Error::kCoggingFailedSmmConfigured,
           "Cogging torque compensation recording is not possible when "
           "encoder monitoring in SMM is configured. Please reconfigure SMM "
           "and set the \"Encoder source type\" to \"None\"."},
          {Error::kCoggingInitFailed,
           "Cogging torque compensation recording failed to initialize!"},
          {Error::kCoggingCannotReadData,
           "Cogging torque compensation data cannot be read, or doesn't "
           "exist!"},
          {Error::kCoggingDataCorrupted, "Cogging torque data corrupted!"},
          {Error::kCoggingRecordingFailed,
           "Cogging torque compensation recording failed!"},
          {Error::kCoggingRecordingAborted,
           "Cogging torque compensation recording aborted!"},
          {Error::kCoggingRecordingTimeout,
           "Cogging torque compensation recording failed (timeout)!"},
          {Error::kCoggingSavingFailed,
           "Saving of the cogging torque compensation data failed!"},
          {Error::kCoggingSavingAborted,
           "Saving of the cogging torque compensation data aborted!"},
          {Error::kCoggingSavingTimeout,
           "Saving of the cogging torque compensation data failed "
           "(timeout)!"},
          {Error::kCoggingNotEnoughMovementSpace,
           "It appears there is not enough space to successfully perform "
           "required preparations! Please move the motor away from the "
           "software position limits and try again."},
          {Error::kNarrowAngleCalibrationFailed,
           "Narrow angle calibration procedure failed!"},
          {Error::kNarrowAngleCalibrationInternalError,
           "Narrow angle calibration experienced an internal error! Please "
           "save the problem report and contact the support."},
          {Error::kNarrowAngleCalibrationAborted,
           "Narrow angle calibration procedure aborted!"},
          {Error::kNarrowAngleCalibrationTimedOut,
           "Narrow angle calibration timed out!"},
          {Error::kNarrowAngleCalibrationMotorNotMoving,
           "Narrow angle calibration - motor not moving!"},
          {Error::kNarrowAngleCalibrationTimeoutMotorTooSlow,
           "Narrow angle calibration - timeout - motor too slow!"},
          {Error::kNarrowAngleCalibrationMotorTooSlow,
           "Velocity during calibration is too slow. Make sure the velocity "
           "control loop is tuned and encoder ring can move freely."},
          {Error::kNarrowAngleCalibrationMotorSemiRotation,
           "The encoder system was not able to move during calibration. Make "
           "sure the velocity control loop is tuned and encoder ring can "
           "move freely."},
          {Error::kNarrowAngleCalibrationMaxMotorSpeedTooLow,
           "Max motor speed is set too low for the calibration procedure to "
           "reach 10 RPM on the driving shaft."},
          {Error::kNarrowAngleCalibrationDataOutOfRange,
           "Computed calibration values are out of range. Please tune the "
           "velocity controller softer (set smaller demanded bandwidth)."},
          {Error::kNarrowAngleCalibrationBadData,
           "Calibration data is distorted. Make sure the velocity control "
           "loop is tuned and the encoder ring isn't damaged and can move "
           "freely."},
          {Error::kNarrowAngleCalibrationNoniusPhaseErrorTooHigh,
           "Nonius phase error is too high to be compensated. The absolute "
           "position can't be computed reliably. Check mechanical assembly, "
           "ring damage or eccentricity."},
          {Error::kNarrowAngleCalibrationAbsResetFailed,
           "The encoder absolute position reset has failed! Please power "
           "cycle the drive and repeat the encoder calibration procedure. If "
           "the issue persists, please contact support."},
          {Error::kNarrowAngleCalibrationUnsafeAutoPositionAdjustment,
           "Required position adjustment not possible, or not safe. Please "
           "check the relevant parameter values and/or move the motor well "
           "within the software position limits."},
          {Error::kNarrowAngleCalibrationAutoPositionAdjustmentFailed,
           "Required position adjustment failed! Please make sure the motor "
           "can turn freely and all of the relevant parameters are correct."},
          {Error::kNarrowAngleCalibrationInternalLimitReached,
           "Internal limit reached! The necessary encoder calibration data "
           "cannot be reliably recorded! Please make sure all of the "
           "relevant parameter values are correct."},
          {Error::kNarrowAngleCalibrationNotEnoughMovementSpace,
           "It appears there is not enough space to perform a successful "
           "encoder calibration! Please adjust the software position limits "
           "and try again."},
          {Error::kNarrowAngleCalibrationInsufficientVelocityResolution,
           "The current velocity resolution isn't sufficient for precise "
           "encoder calibration. Please increase velocity resolution by "
           "using the object 0x60A9 SI unit velocity."},
          {Error::kNarrowAngleCalibrationEncoderDataRecordingFailed,
           "Calibration failed due to a file writing or a data logging "
           "issue! Please restart the procedure. If the problem persists, "
           "please download the error report and contact support."},
          {Error::kNarrowAngleCalibrationSmmConfigured,
           "Encoder calibration is not possible when encoder monitoring in "
           "SMM is configured. Please reconfigure SMM and set the \"Encoder "
           "source type\" to \"None\"."},
          {Error::kNarrowAngleCalibrationFault,
           "Encoder calibration failed due to a drive fault!"},
          {Error::kNarrowAngleCalibrationNotSupported,
           "Narrow angle calibration - not supported!"},
          {Error::kBrakeGetStatusFailed, "Failed to get the brake status!"},
          {Error::kBrakeSetStatusFailed, "Failed to enable/disable the brake!"},
          {Error::kBrakeSetTimeout,
           "Failed to enable/disable the brake (timeout)!"},
          {Error::kBrakeNotConfigured, "Brake has not been configured yet!"},
          {Error::kConfigurationSaveFailed,
           "Saving of the configuration to the flash memory has failed!"},
          {Error::kCannotReadConfigurationFile,
           "Cannot read the configuration file!"},
          {Error::kCannotLoadConfigurationFile,
           "Cannot load the configuration file!"},
          {Error::kCannotReadError, "Cannot read the current error!"},
          {Error::kParameterChangeFailed,
           "Configuration parameter change has failed!"},
          {Error::kParameterNotFound,
           "Configuration parameter cannot be found!"},
          {Error::kZipCorrupted, "The zip file is corrupted!"},
          {Error::kFlashFailed, "Failed to flash the device!"},
          {Error::kFlashRefused, "Flashing already in progress!"},
          {Error::kFlashNotSupported,
           "Flashing not supported for this device type!"},
          {Error::kSiiWriteFailed, "Failed to write the SII to the device!"},
          {Error::kSiiCorrupted,
           "The firmware package is not valid: The SII file is corrupted!"},
          {Error::kSiiRestoreInternalError,
           "SII restore failed due to an internal error!"},
          {Error::kFirmwareImageNotFoundInZip,
           "The firmware package is not valid: The binary firmware image "
           "file is missing!"},
          {Error::kFileWriteFailed,
           "Failed to write the file to the device flash memory!"},
          {Error::kFileRemoveFailed,
           "Failed to remove the file from the device flash memory!"},
          {Error::kFileNotFound, "File not found!"},
          {Error::kFileAlreadyExists, "File already exists!"},
          {Error::kFileInvalidName, "Invalid file name!"},
          {Error::kFileDiskFull, "Flash memory full!"},
          {Error::kFileAccessDenied, "Access denied!"},
          {Error::kFileInvalidEthercatState, "Invalid EtherCAT device state!"},
          {Error::kFileInternalError, "Internal file operation error!"},
          {Error::kDeviceReloadFailed,
           "Failed to reload the device! The PDO communication might be "
           "down!"},
          {Error::kClientNotInControl,
           "The client used to issue the command currently doesn't have "
           "control!"},
          {Error::kInvalidTxPdoPosition, "Internal Motion Master error!"},
          {Error::kInvalidRxPdoPosition, "Internal Motion Master error!"},
          {Error::kPrCannotStartTimer, "Internal Motion Master error!"},
          {Error::kPrCannotStopTimer, "Internal Motion Master error!"},
          {Error::kUnknownMessageType, "Unknown message type!"},
          {Error::kRespondingSlaves,
           "Number of responding slaves has changed!"},
          {Error::kCannotDetectSlaves,
           "Cannot detect any slaves. Please connect or power on the slaves "
           "and restart Motion Master."},
          {Error::kCannotExecuteSlaveProfile,
           "Failed to execute the profile on the slave!"},
          {Error::kFaultResetTimeoutReactionActive,
           "Failed to reset the fault - fault reaction active timeout!"},
          {Error::kFaultResetTimeout, "Failed to reset the fault - timeout!"},
          {Error::kFaultResetNoFault, "Failed to reset the fault - no fault!"},
          {Error::kFaultResetNotPossible, "Fault reset not possible!"},
          {Error::kDeviceNotFound, "Device not found!"},
          {Error::kOsCommandAlreadyRunning,
           "An OS command is already running on this device!"},
          {Error::kOsCommandFailed, "OS command has failed!"},
          {Error::kOsCommandTimeout, "OS command has timed out!"},
          {Error::kOsCommandNotResponding,
           "OS command was not responding and was aborted!"},
          {Error::kOsCommandInvalid, "Invalid OS command!"},
          {Error::kOsCommandNotSupported, "OS commands are not supported!"},
          {Error::kOsCommandNotAllowed,
           "The requested OS command is not allowed in this context!"},
          {Error::kOsCommandReserved,
           "The requested OS command has been reserved for internal uses "
           "only!"},
          {Error::kOsCommandAborted, "OS command was aborted!"},
          {Error::kOsCommandAutoAborted,
           "OS command was automatically aborted because the device "
           "executing it is not running any more (not in OP enabled)!"},
          {Error::kOsCommandInternal,
           "OS command failed due to an internal error!"},
          {Error::kOsCommandUnknown,
           "OS command execution has failed with an unknown error!"},
          {Error::kOpenLoopFieldControlAborted,
           "Open-loop field control aborted!"},
          {Error::kCirculoEncoderConfigurationNotSupported,
           "Circulo encoder configuration not supported!"},
          {Error::kCirculoEncoderConfigurationAlreadyRunning,
           "Circulo encoder configuration is already running on this "
           "device!"},
          {Error::kCirculoEncoderConfigurationFailed,
           "Circulo encoder configuration has failed!"},
          {Error::kCirculoEncoderConfigurationEncoderNotUsed,
           "The encoder that is being configured must be assigned to a "
           "controller first!"},
          {Error::kMotorOutsideSoftwarePositionLimits,
           "The current motor position is outside of the software position "
           "limits! Please move the motor within these limits before "
           "continuing!"},
          {Error::kInvalidSoftwarePositionLimits,
           "Invalid software position limits!"},
          {Error::kEncoderOrdinalInvalid, "Invalid encoder selected!"},
          {Error::kEncoderPortInvalid, "Invalid encoder port!"},
          {Error::kEncoderConfigurationInvalid,
           "The encoder configuration seems to be invalid! Please check all "
           "of the encoder related parameter values."},
          {Error::kEncoderNoCommutationEncoder,
           "Cannot find the commutation encoder!"},
          {Error::kEncoderNoPositionControlEncoder,
           "Cannot find the position control encoder!"},
          {Error::kHrdStreamInitFailed,
           "The initialization of the HRD stream OS command has failed! "
           "Please try restarting the procedure."},
          {Error::kHrdStreamStreamingFailed,
           "The stream recording phase of the HRD stream OS command has "
           "failed! Please try restarting the procedure."},
          {Error::kHrdStreamDurationValue,
           "OS command failed - Invalid HRD stream duration value!"},
          {Error::kHrdStreamDataIndexValue,
           "OS command failed - Invalid HRD stream data index value!"},
          {Error::kHrdStreamActionValue,
           "OS command failed - Invalid HRD stream action value!"},
          {Error::kOpenPhaseDetectionOpenTerminalA,
           "Open phase detected on terminal A!"},
          {Error::kOpenPhaseDetectionOpenTerminalB,
           "Open phase detected on terminal B!"},
          {Error::kOpenPhaseDetectionOpenTerminalC,
           "Open phase detected on terminal C!"},
          {Error::kOpenPhaseDetectionOpenFetAHigh, "Open FET A high detected!"},
          {Error::kOpenPhaseDetectionOpenFetALow, "Open FET A low detected!"},
          {Error::kOpenPhaseDetectionOpenFetBHigh, "Open FET B high detected!"},
          {Error::kOpenPhaseDetectionOpenFetBLow, "Open FET B low detected!"},
          {Error::kOpenPhaseDetectionOpenFetCHigh, "Open FET C high detected!"},
          {Error::kOpenPhaseDetectionOpenFetCLow, "Open FET C low detected!"},
          {Error::kPolePairDetectionCurrentAmplitude,
           "Pole pair detection - Current amplitude error!"},
          {Error::kPhaseResistanceMeasurementCurrentAmplitude,
           "Phase resistance measurement - Current amplitude error!"},
          {Error::kPhaseInductanceMeasurementCurrentAmplitude,
           "Phase inductance measurement - Current amplitude error!"},
          {Error::kFeedConstantInvalid, "Invalid Feed Constant values!"},
          {Error::kQuickStopTimeout, "Quick stop has failed - timeout!"},
          {Error::kQuickStopFailed, "Quick stop has failed!"},
          {Error::kEthercatStateChangeFailed,
           "Failed to change the EtherCAT state of a device!"},
          {Error::kUnknown, "Unknown error!"}};
 
  Error error_;
 
  static std::string get_error_message(Error error);
};