From b62a5fd699fcaedfea75b48aaf1dea4e9fb93bc2 Mon Sep 17 00:00:00 2001 From: smathis Date: Fri, 4 Apr 2025 13:30:52 +0200 Subject: [PATCH] Removed readInt32 method, since it is not needed. --- Makefile | 2 +- src/turboPmacAxis.cpp | 577 ++++++++++++++++++------------------ src/turboPmacAxis.h | 10 + src/turboPmacController.cpp | 19 +- src/turboPmacController.h | 18 +- 5 files changed, 309 insertions(+), 317 deletions(-) diff --git a/Makefile b/Makefile index 03994fb..a9d4d74 100644 --- a/Makefile +++ b/Makefile @@ -14,7 +14,7 @@ REQUIRED+=sinqMotor motorBase_VERSION=7.2.2 # Specify the version of sinqMotor we want to build against -sinqMotor_VERSION=0.10.0 +sinqMotor_VERSION=mathis_s # These headers allow to depend on this library for derived drivers. HEADERS += src/turboPmacAxis.h diff --git a/src/turboPmacAxis.cpp b/src/turboPmacAxis.cpp index 6688ade..9d7ebef 100644 --- a/src/turboPmacAxis.cpp +++ b/src/turboPmacAxis.cpp @@ -96,13 +96,8 @@ turboPmacAxis::turboPmacAxis(turboPmacController *pC, int axisNo, // turboPmac motors can always be disabled status = pC_->setIntegerParam(axisNo_, pC_->motorCanDisable(), 1); if (status != asynSuccess) { - asynPrint( - pC_->asynUserSelf(), ASYN_TRACE_ERROR, - "Controller \"%s\", axis %d => %s, line %d\nFATAL ERROR " - "(setting a parameter value failed with %s)\n. Terminating IOC", - pC_->portName, axisNo_, __PRETTY_FUNCTION__, __LINE__, - pC_->stringifyAsynStatus(status)); - exit(-1); + pC_->paramLibAccessFailed(status, "motorCanDisable", axisNo_, + __PRETTY_FUNCTION__, __LINE__); } // Default values for the watchdog timeout mechanism @@ -226,7 +221,7 @@ asynStatus turboPmacAxis::init() { asynStatus turboPmacAxis::doPoll(bool *moving) { // Return value for the poll - asynStatus poll_status = asynSuccess; + asynStatus errorStatus = asynSuccess; // Status of read-write-operations of ASCII commands to the controller asynStatus rw_status = asynSuccess; @@ -531,284 +526,7 @@ asynStatus turboPmacAxis::doPoll(bool *moving) { } } - // Create the unique callsite identifier manually so it can be used later in - // the shouldBePrinted calls. - msgPrintControlKey keyError = msgPrintControlKey( - pC_->portName, axisNo_, __PRETTY_FUNCTION__, __LINE__); - bool resetError = true; - - switch (error) { - case 0: - // No error -> Reset the message repetition watchdog - break; - case 1: - // EPICS should already prevent this issue in the first place, - // since it contains the user limits - if (pC_->getMsgPrintControl().shouldBePrinted(keyError, true, - pC_->asynUserSelf())) { - asynPrint(pC_->asynUserSelf(), ASYN_TRACE_ERROR, - "Controller \"%s\", axis %d => %s, line %d\nTarget " - "position would exceed user limits.%s\n", - pC_->portName, axisNo_, __PRETTY_FUNCTION__, __LINE__, - pC_->getMsgPrintControl().getSuffix()); - } - resetError = false; - - pl_status = setStringParam(pC_->motorMessageText(), - "Target position would exceed software " - "limits. Please call the support."); - if (pl_status != asynSuccess) { - return pC_->paramLibAccessFailed(pl_status, "motorMessageText_", - axisNo_, __PRETTY_FUNCTION__, - __LINE__); - } - - poll_status = asynError; - break; - case 5: - // Command not possible - if (pC_->getMsgPrintControl().shouldBePrinted(keyStatus, true, - pC_->asynUserSelf())) { - asynPrint( - pC_->asynUserSelf(), ASYN_TRACE_ERROR, - "Controller \"%s\", axis %d => %s, line %d\nAxis is " - "still moving, but received another move command. EPICS " - "should prevent this, check if *moving is set correctly.%s\n", - pC_->portName, axisNo_, __PRETTY_FUNCTION__, __LINE__, - pC_->getMsgPrintControl().getSuffix()); - } - resetError = false; - - pl_status = setStringParam(pC_->motorMessageText(), - "Axis received move command while it is " - "still moving. Please call the support."); - if (pl_status != asynSuccess) { - return pC_->paramLibAccessFailed(pl_status, "motorMessageText_", - axisNo_, __PRETTY_FUNCTION__, - __LINE__); - } - - poll_status = asynError; - break; - case 8: - if (pC_->getMsgPrintControl().shouldBePrinted(keyError, true, - pC_->asynUserSelf())) { - asynPrint(pC_->asynUserSelf(), ASYN_TRACE_ERROR, - "Controller \"%s\", axis %d => %s, line %d\nAir cushion " - "feedback stopped during movement (P%2.2d01 = %d).%s\n", - pC_->portName, axisNo_, __PRETTY_FUNCTION__, __LINE__, - axisNo_, error, pC_->getMsgPrintControl().getSuffix()); - } - resetError = false; - - snprintf(userMessage, sizeof(userMessage), - "Air cushion feedback stopped during movement (P%2.2d01 = " - "%d). Please call the support.", - axisNo_, error); - - pl_status = setStringParam(pC_->motorMessageText(), userMessage); - if (pl_status != asynSuccess) { - return pC_->paramLibAccessFailed(pl_status, "motorMessageText_", - axisNo_, __PRETTY_FUNCTION__, - __LINE__); - } - break; - case 9: - if (pC_->getMsgPrintControl().shouldBePrinted(keyError, true, - pC_->asynUserSelf())) { - asynPrint( - pC_->asynUserSelf(), ASYN_TRACE_ERROR, - "Controller \"%s\", axis %d => %s, line %d\nNo air cushion " - "feedback before movement start (P%2.2d01 = %d).%s\n", - pC_->portName, axisNo_, __PRETTY_FUNCTION__, __LINE__, axisNo_, - error, pC_->getMsgPrintControl().getSuffix()); - } - resetError = false; - - snprintf(userMessage, sizeof(userMessage), - "No air cushion feedback before movement start (P%2.2d01 = " - "%d). Please call the support.", - axisNo_, error); - pl_status = setStringParam(pC_->motorMessageText(), userMessage); - if (pl_status != asynSuccess) { - return pC_->paramLibAccessFailed(pl_status, "motorMessageText_", - axisNo_, __PRETTY_FUNCTION__, - __LINE__); - } - break; - case 10: - /* - Software limits of the controller have been hit. Since the EPICS limits - are derived from the software limits and are a little bit smaller, this - error case can only happen if either the axis has an incremental encoder - which is not properly homed or if a bug occured. - */ - - if (pC_->getMsgPrintControl().shouldBePrinted(keyError, true, - pC_->asynUserSelf())) { - asynPrint( - pC_->asynUserSelf(), ASYN_TRACE_ERROR, - "Controller \"%s\", axis %d => %s, line %d\nAxis hit the " - "controller limits.%s\n", - pC_->portName, axisNo_, __PRETTY_FUNCTION__, __LINE__, - pC_->getMsgPrintControl().getSuffix()); - } - resetError = false; - - snprintf(userMessage, sizeof(userMessage), - "Software limits or end switch hit (P%2.2d01 = %d). Try " - "homing the motor, moving in the opposite direction or check " - "the SPS for errors (if available). " - "Otherwise please call the support.", - axisNo_, error); - - pl_status = setStringParam(pC_->motorMessageText(), userMessage); - if (pl_status != asynSuccess) { - return pC_->paramLibAccessFailed(pl_status, "motorMessageText_", - axisNo_, __PRETTY_FUNCTION__, - __LINE__); - } - - poll_status = asynError; - break; - case 11: - // Following error - - if (pC_->getMsgPrintControl().shouldBePrinted(keyError, true, - pC_->asynUserSelf())) { - asynPrint( - pC_->asynUserSelf(), ASYN_TRACE_ERROR, - "Controller \"%s\", axis %d => %s, line %d\nMaximum allowed " - "following error exceeded.%s\n", - pC_->portName, axisNo_, __PRETTY_FUNCTION__, __LINE__, - pC_->getMsgPrintControl().getSuffix()); - } - resetError = false; - - snprintf(command, sizeof(command), - "Maximum allowed following error exceeded (P%2.2d01 = %d). " - "Check if movement range is blocked. " - "Otherwise please call the support.", - axisNo_, error); - pl_status = setStringParam(pC_->motorMessageText(), command); - if (pl_status != asynSuccess) { - return pC_->paramLibAccessFailed(pl_status, "motorMessageText_", - axisNo_, __PRETTY_FUNCTION__, - __LINE__); - } - - poll_status = asynError; - break; - - case 12: - if (pC_->getMsgPrintControl().shouldBePrinted(keyError, true, - pC_->asynUserSelf())) { - asynPrint(pC_->asynUserSelf(), ASYN_TRACE_ERROR, - "Controller \"%s\", axis %d => %s, line %d\nSecurity " - "input is triggered (P%2.2d01 = %d).%s\n", - pC_->portName, axisNo_, __PRETTY_FUNCTION__, __LINE__, - axisNo_, error, pC_->getMsgPrintControl().getSuffix()); - } - resetError = false; - - snprintf(command, sizeof(command), - "Security input is triggered (P%2.2d01 = %d). Check the SPS " - "for errors (if available). Otherwise please call " - "the support.", - axisNo_, error); - pl_status = setStringParam(pC_->motorMessageText(), command); - if (pl_status != asynSuccess) { - return pC_->paramLibAccessFailed(pl_status, "motorMessageText_", - axisNo_, __PRETTY_FUNCTION__, - __LINE__); - } - - poll_status = asynError; - break; - - case 13: - // Driver hardware error triggered - - if (pC_->getMsgPrintControl().shouldBePrinted(keyError, true, - pC_->asynUserSelf())) { - asynPrint(pC_->asynUserSelf(), ASYN_TRACE_ERROR, - "Controller \"%s\", axis %d => %s, line %d\nDriver " - "hardware error triggered.%s\n", - pC_->portName, axisNo_, __PRETTY_FUNCTION__, __LINE__, - pC_->getMsgPrintControl().getSuffix()); - } - resetError = false; - - snprintf(command, sizeof(command), - "Driver hardware error (P%2.2d01 = 13). " - "Please call the support.", - axisNo_); - pl_status = setStringParam(pC_->motorMessageText(), command); - if (pl_status != asynSuccess) { - return pC_->paramLibAccessFailed(pl_status, "motorMessageText_", - axisNo_, __PRETTY_FUNCTION__, - __LINE__); - } - - poll_status = asynError; - break; - case 14: - // EPICS should already prevent this issue in the first place, - // since it contains the user limits - - if (pC_->getMsgPrintControl().shouldBePrinted(keyError, true, - pC_->asynUserSelf())) { - asynPrint(pC_->asynUserSelf(), ASYN_TRACE_ERROR, - "Controller \"%s\", axis %d => %s, line %d\nMove " - "command exceeds hardware limits (P%2.2d01 = %d).%s\n", - pC_->portName, axisNo_, __PRETTY_FUNCTION__, __LINE__, - axisNo_, error, pC_->getMsgPrintControl().getSuffix()); - } - resetError = false; - - snprintf(userMessage, sizeof(userMessage), - "Move command exceeds hardware limits (P%2.2d01 = %d). Please " - "call the support.", - axisNo_, error); - pl_status = setStringParam(pC_->motorMessageText(), userMessage); - if (pl_status != asynSuccess) { - return pC_->paramLibAccessFailed(pl_status, "motorMessageText_", - axisNo_, __PRETTY_FUNCTION__, - __LINE__); - } - - poll_status = asynError; - break; - default: - - if (pC_->getMsgPrintControl().shouldBePrinted(keyError, true, - pC_->asynUserSelf())) { - asynPrint( - pC_->asynUserSelf(), ASYN_TRACE_ERROR, - "Controller \"%s\", axis %d => %s, line %d\nUnknown error " - "P%2.2d01 = %d.%s\n", - pC_->portName, axisNo_, __PRETTY_FUNCTION__, __LINE__, axisNo_, - error, pC_->getMsgPrintControl().getSuffix()); - } - resetError = false; - - snprintf(userMessage, sizeof(userMessage), - "Unknown error P%2.2d01 = %d. Please call the support.", - axisNo_, error); - pl_status = setStringParam(pC_->motorMessageText(), userMessage); - if (pl_status != asynSuccess) { - return pC_->paramLibAccessFailed(pl_status, "motorMessageText_", - axisNo_, __PRETTY_FUNCTION__, - __LINE__); - } - - poll_status = asynError; - break; - } - - if (resetError) { - pC_->getMsgPrintControl().resetCount(keyError, pC_->asynUserSelf()); - } + errorStatus = handleError(error, userMessage, sizeof(userMessage)); // Update the parameter library if (error != 0) { @@ -868,7 +586,292 @@ asynStatus turboPmacAxis::doPoll(bool *moving) { if (pl_status != asynSuccess) { return pl_status; } - return poll_status; + return errorStatus; +} + +asynStatus turboPmacAxis::handleError(int error, char *userMessage, + int sizeUserMessage) { + asynStatus status = asynSuccess; + + // Create the unique callsite identifier manually so it can be used later in + // the shouldBePrinted calls. + msgPrintControlKey keyError = msgPrintControlKey( + pC_->portName, axisNo_, __PRETTY_FUNCTION__, __LINE__); + bool resetError = true; + + switch (error) { + case 0: + // No error -> Reset the message repetition watchdog + break; + case 1: + // EPICS should already prevent this issue in the first place, + // since it contains the user limits + if (pC_->getMsgPrintControl().shouldBePrinted(keyError, true, + pC_->asynUserSelf())) { + asynPrint(pC_->asynUserSelf(), ASYN_TRACE_ERROR, + "Controller \"%s\", axis %d => %s, line %d\nTarget " + "position would exceed user limits.%s\n", + pC_->portName, axisNo_, __PRETTY_FUNCTION__, __LINE__, + pC_->getMsgPrintControl().getSuffix()); + } + resetError = false; + + status = setStringParam(pC_->motorMessageText(), + "Target position would exceed software " + "limits. Please call the support."); + if (status != asynSuccess) { + return pC_->paramLibAccessFailed(status, "motorMessageText_", + axisNo_, __PRETTY_FUNCTION__, + __LINE__); + } + + status = asynError; + break; + case 5: + // Command not possible + if (pC_->getMsgPrintControl().shouldBePrinted(keyError, true, + pC_->asynUserSelf())) { + asynPrint( + pC_->asynUserSelf(), ASYN_TRACE_ERROR, + "Controller \"%s\", axis %d => %s, line %d\nAxis is " + "still moving, but received another move command. EPICS " + "should prevent this, check if *moving is set correctly.%s\n", + pC_->portName, axisNo_, __PRETTY_FUNCTION__, __LINE__, + pC_->getMsgPrintControl().getSuffix()); + } + resetError = false; + + status = setStringParam(pC_->motorMessageText(), + "Axis received move command while it is " + "still moving. Please call the support."); + if (status != asynSuccess) { + return pC_->paramLibAccessFailed(status, "motorMessageText_", + axisNo_, __PRETTY_FUNCTION__, + __LINE__); + } + + status = asynError; + break; + case 8: + if (pC_->getMsgPrintControl().shouldBePrinted(keyError, true, + pC_->asynUserSelf())) { + asynPrint(pC_->asynUserSelf(), ASYN_TRACE_ERROR, + "Controller \"%s\", axis %d => %s, line %d\nAir cushion " + "feedback stopped during movement (P%2.2d01 = %d).%s\n", + pC_->portName, axisNo_, __PRETTY_FUNCTION__, __LINE__, + axisNo_, error, pC_->getMsgPrintControl().getSuffix()); + } + resetError = false; + + snprintf(userMessage, sizeUserMessage, + "Air cushion feedback stopped during movement (P%2.2d01 = " + "%d). Please call the support.", + axisNo_, error); + + status = setStringParam(pC_->motorMessageText(), userMessage); + if (status != asynSuccess) { + return pC_->paramLibAccessFailed(status, "motorMessageText_", + axisNo_, __PRETTY_FUNCTION__, + __LINE__); + } + break; + case 9: + if (pC_->getMsgPrintControl().shouldBePrinted(keyError, true, + pC_->asynUserSelf())) { + asynPrint( + pC_->asynUserSelf(), ASYN_TRACE_ERROR, + "Controller \"%s\", axis %d => %s, line %d\nNo air cushion " + "feedback before movement start (P%2.2d01 = %d).%s\n", + pC_->portName, axisNo_, __PRETTY_FUNCTION__, __LINE__, axisNo_, + error, pC_->getMsgPrintControl().getSuffix()); + } + resetError = false; + + snprintf(userMessage, sizeUserMessage, + "No air cushion feedback before movement start (P%2.2d01 = " + "%d). Please call the support.", + axisNo_, error); + status = setStringParam(pC_->motorMessageText(), userMessage); + if (status != asynSuccess) { + return pC_->paramLibAccessFailed(status, "motorMessageText_", + axisNo_, __PRETTY_FUNCTION__, + __LINE__); + } + break; + case 10: + /* + Software limits of the controller have been hit. Since the EPICS limits + are derived from the software limits and are a little bit smaller, this + error case can only happen if either the axis has an incremental encoder + which is not properly homed or if a bug occured. + */ + + if (pC_->getMsgPrintControl().shouldBePrinted(keyError, true, + pC_->asynUserSelf())) { + asynPrint( + pC_->asynUserSelf(), ASYN_TRACE_ERROR, + "Controller \"%s\", axis %d => %s, line %d\nAxis hit the " + "controller limits.%s\n", + pC_->portName, axisNo_, __PRETTY_FUNCTION__, __LINE__, + pC_->getMsgPrintControl().getSuffix()); + } + resetError = false; + + snprintf(userMessage, sizeUserMessage, + "Software limits or end switch hit (P%2.2d01 = %d). Try " + "homing the motor, moving in the opposite direction or check " + "the SPS for errors (if available). " + "Otherwise please call the support.", + axisNo_, error); + + status = setStringParam(pC_->motorMessageText(), userMessage); + if (status != asynSuccess) { + return pC_->paramLibAccessFailed(status, "motorMessageText_", + axisNo_, __PRETTY_FUNCTION__, + __LINE__); + } + + status = asynError; + break; + case 11: + // Following error + + if (pC_->getMsgPrintControl().shouldBePrinted(keyError, true, + pC_->asynUserSelf())) { + asynPrint( + pC_->asynUserSelf(), ASYN_TRACE_ERROR, + "Controller \"%s\", axis %d => %s, line %d\nMaximum allowed " + "following error exceeded.%s\n", + pC_->portName, axisNo_, __PRETTY_FUNCTION__, __LINE__, + pC_->getMsgPrintControl().getSuffix()); + } + resetError = false; + + snprintf(userMessage, sizeUserMessage, + "Maximum allowed following error exceeded (P%2.2d01 = %d). " + "Check if movement range is blocked. " + "Otherwise please call the support.", + axisNo_, error); + status = setStringParam(pC_->motorMessageText(), userMessage); + if (status != asynSuccess) { + return pC_->paramLibAccessFailed(status, "motorMessageText_", + axisNo_, __PRETTY_FUNCTION__, + __LINE__); + } + + status = asynError; + break; + + case 12: + if (pC_->getMsgPrintControl().shouldBePrinted(keyError, true, + pC_->asynUserSelf())) { + asynPrint(pC_->asynUserSelf(), ASYN_TRACE_ERROR, + "Controller \"%s\", axis %d => %s, line %d\nSecurity " + "input is triggered (P%2.2d01 = %d).%s\n", + pC_->portName, axisNo_, __PRETTY_FUNCTION__, __LINE__, + axisNo_, error, pC_->getMsgPrintControl().getSuffix()); + } + resetError = false; + + snprintf(userMessage, sizeUserMessage, + "Security input is triggered (P%2.2d01 = %d). Check the SPS " + "for errors (if available). Otherwise please call " + "the support.", + axisNo_, error); + status = setStringParam(pC_->motorMessageText(), userMessage); + if (status != asynSuccess) { + return pC_->paramLibAccessFailed(status, "motorMessageText_", + axisNo_, __PRETTY_FUNCTION__, + __LINE__); + } + + status = asynError; + break; + + case 13: + // Driver hardware error triggered + + if (pC_->getMsgPrintControl().shouldBePrinted(keyError, true, + pC_->asynUserSelf())) { + asynPrint(pC_->asynUserSelf(), ASYN_TRACE_ERROR, + "Controller \"%s\", axis %d => %s, line %d\nDriver " + "hardware error triggered.%s\n", + pC_->portName, axisNo_, __PRETTY_FUNCTION__, __LINE__, + pC_->getMsgPrintControl().getSuffix()); + } + resetError = false; + + snprintf(userMessage, sizeUserMessage, + "Driver hardware error (P%2.2d01 = 13). " + "Please call the support.", + axisNo_); + status = setStringParam(pC_->motorMessageText(), userMessage); + if (status != asynSuccess) { + return pC_->paramLibAccessFailed(status, "motorMessageText_", + axisNo_, __PRETTY_FUNCTION__, + __LINE__); + } + + status = asynError; + break; + case 14: + // EPICS should already prevent this issue in the first place, + // since it contains the user limits + + if (pC_->getMsgPrintControl().shouldBePrinted(keyError, true, + pC_->asynUserSelf())) { + asynPrint(pC_->asynUserSelf(), ASYN_TRACE_ERROR, + "Controller \"%s\", axis %d => %s, line %d\nMove " + "command exceeds hardware limits (P%2.2d01 = %d).%s\n", + pC_->portName, axisNo_, __PRETTY_FUNCTION__, __LINE__, + axisNo_, error, pC_->getMsgPrintControl().getSuffix()); + } + resetError = false; + + snprintf(userMessage, sizeUserMessage, + "Move command exceeds hardware limits (P%2.2d01 = %d). Please " + "call the support.", + axisNo_, error); + status = setStringParam(pC_->motorMessageText(), userMessage); + if (status != asynSuccess) { + return pC_->paramLibAccessFailed(status, "motorMessageText_", + axisNo_, __PRETTY_FUNCTION__, + __LINE__); + } + + status = asynError; + break; + default: + + if (pC_->getMsgPrintControl().shouldBePrinted(keyError, true, + pC_->asynUserSelf())) { + asynPrint( + pC_->asynUserSelf(), ASYN_TRACE_ERROR, + "Controller \"%s\", axis %d => %s, line %d\nUnknown error " + "P%2.2d01 = %d.%s\n", + pC_->portName, axisNo_, __PRETTY_FUNCTION__, __LINE__, axisNo_, + error, pC_->getMsgPrintControl().getSuffix()); + } + resetError = false; + + snprintf(userMessage, sizeUserMessage, + "Unknown error P%2.2d01 = %d. Please call the support.", + axisNo_, error); + status = setStringParam(pC_->motorMessageText(), userMessage); + if (status != asynSuccess) { + return pC_->paramLibAccessFailed(status, "motorMessageText_", + axisNo_, __PRETTY_FUNCTION__, + __LINE__); + } + + status = asynError; + break; + } + + if (resetError) { + pC_->getMsgPrintControl().resetCount(keyError, pC_->asynUserSelf()); + } + return status; } asynStatus turboPmacAxis::doMove(double position, int relative, diff --git a/src/turboPmacAxis.h b/src/turboPmacAxis.h index 35125cb..105d6fc 100644 --- a/src/turboPmacAxis.h +++ b/src/turboPmacAxis.h @@ -112,6 +112,16 @@ class turboPmacAxis : public sinqAxis { */ asynStatus rereadEncoder(); + /** + * @brief Interpret the error code and populate the user message accordingly + * + * @param error + * @param userMessage + * @param sizeUserMessage + * @return asynStatus + */ + asynStatus handleError(int error, char *userMessage, int sizeUserMessage); + protected: turboPmacController *pC_; diff --git a/src/turboPmacController.cpp b/src/turboPmacController.cpp index 13effa4..da7a86e 100644 --- a/src/turboPmacController.cpp +++ b/src/turboPmacController.cpp @@ -484,20 +484,11 @@ asynStatus turboPmacController::writeInt32(asynUser *pasynUser, } } -asynStatus turboPmacController::readInt32(asynUser *pasynUser, - epicsInt32 *value) { - // PMACs can be disabled - if (pasynUser->reason == motorCanDisable_) { - *value = 1; - return asynSuccess; - } else { - return sinqController::readInt32(pasynUser, value); - } -} - -asynStatus turboPmacController::couldNotParseResponse( - const char *command, const char *response, int axisNo, - const char *functionName, int lineNumber) { +asynStatus turboPmacController::couldNotParseResponse(const char *command, + const char *response, + int axisNo, + const char *functionName, + int lineNumber) { char modifiedResponse[MAXBUF_] = {0}; adjustResponseForPrint(modifiedResponse, response, MAXBUF_); return sinqController::couldNotParseResponse( diff --git a/src/turboPmacController.h b/src/turboPmacController.h index 69281ff..eee4a64 100644 --- a/src/turboPmacController.h +++ b/src/turboPmacController.h @@ -51,17 +51,6 @@ class turboPmacController : public sinqController { */ turboPmacAxis *getTurboPmacAxis(int axisNo); - /** - * @brief Overloaded function of sinqController - * - * The function is overloaded in order to read motorCanDisable_. - * - * @param pasynUser - * @param value - * @return asynStatus - */ - virtual asynStatus readInt32(asynUser *pasynUser, epicsInt32 *value); - /** * @brief Overloaded function of sinqController * @@ -110,10 +99,9 @@ class turboPmacController : public sinqController { called. It is recommended to use a macro, e.g. __LINE__. * @return asynStatus Returns asynError. */ - asynStatus couldNotParseResponse(const char *command, - const char *response, int axisNo_, - const char *functionName, - int lineNumber); + asynStatus couldNotParseResponse(const char *command, const char *response, + int axisNo_, const char *functionName, + int lineNumber); // Accessors for additional PVs int rereadEncoderPosition() { return rereadEncoderPosition_; }