diff --git a/sinqMotor b/sinqMotor index 275672a..87980e4 160000 --- a/sinqMotor +++ b/sinqMotor @@ -1 +1 @@ -Subproject commit 275672aaef41aba2ec425d79f8bbb65d5f18f80c +Subproject commit 87980e403cc59bd0287f97b7eef0c970213913a2 diff --git a/src/masterMacsAxis.cpp b/src/masterMacsAxis.cpp index 3693ec8..f79f8ed 100644 --- a/src/masterMacsAxis.cpp +++ b/src/masterMacsAxis.cpp @@ -11,6 +11,21 @@ #include #include +struct masterMacsAxisImpl { + /* + The axis status and axis error of MasterMACS are given as an integer from + the controller. The 16 individual bits contain the actual information. + */ + std::bitset<16> axisStatus; + std::bitset<16> axisError; + + double lastSetSpeed; + bool waitForHandshake; + time_t timeAtHandshake; + bool needInit = true; + bool targetReachedUninitialized; +}; + /* A special communication timeout is used in the following two cases: 1) Enable command @@ -104,17 +119,14 @@ masterMacsAxis::masterMacsAxis(masterMacsController *pC, int axisNo) // Collect all axes into this list which will be used in the hook function axes.push_back(this); - // Initialize all member variables - axisStatus_ = std::bitset<16>(0); - axisError_ = std::bitset<16>(0); - - // Initial value for the motor speed, is overwritten in atFirstPoll. - lastSetSpeed_ = 0.0; - - // Flag for handshake waiting - waitForHandshake_ = false; - timeAtHandshake_ = 0; - targetReachedUninitialized_ = true; + pMasterMacsA_ = std::make_unique((masterMacsAxisImpl){ + .axisStatus = std::bitset<16>(0), + .axisError = std::bitset<16>(0), + .lastSetSpeed = 0.0, + .waitForHandshake = false, + .timeAtHandshake = 0, + .targetReachedUninitialized = true, + }); // masterMacs motors can always be disabled status = pC_->setIntegerParam(axisNo_, pC_->motorCanDisable(), 1); @@ -253,7 +265,7 @@ asynStatus masterMacsAxis::init() { // Cache the motor speed. If this value differs from the one in the motor // record at the start of a movement, the motor record value is sent to // MasterMACS. - lastSetSpeed_ = motorVelocity; + pMasterMacsA_->lastSetSpeed = motorVelocity; // Store the motor position in the parameter library pl_status = setMotorPosition(motorPosition); @@ -289,6 +301,10 @@ asynStatus masterMacsAxis::init() { pC_->stringifyAsynStatus(pl_status)); return pl_status; } + + // Axis is fully initialized + setNeedInit(false); + return pl_status; } @@ -319,13 +335,21 @@ asynStatus masterMacsAxis::doPoll(bool *moving) { // ========================================================================= + // Does the axis need to be intialized? + if (needInit()) { + rw_status = init(); + if (rw_status != asynSuccess) { + return rw_status; + } + } + // Are we currently waiting for a handshake? - if (waitForHandshake_) { + if (pMasterMacsA_->waitForHandshake) { // Check if the handshake takes too long and communicate an error in // this case. A handshake should not take more than 5 seconds. time_t currentTime = time(NULL); - bool timedOut = (currentTime > timeAtHandshake_ + 5); + bool timedOut = (currentTime > pMasterMacsA_->timeAtHandshake + 5); if (pC_->getMsgPrintControl().shouldBePrinted( pC_->portName, axisNo_, __PRETTY_FUNCTION__, __LINE__, timedOut, @@ -335,7 +359,7 @@ asynStatus masterMacsAxis::doPoll(bool *moving) { "handshake at %ld s and didn't get a positive reply yet " "(current time is %ld s).\n", pC_->portName, axisNo_, __PRETTY_FUNCTION__, __LINE__, - timeAtHandshake_, currentTime); + pMasterMacsA_->timeAtHandshake, currentTime); } if (timedOut) { @@ -363,8 +387,8 @@ asynStatus masterMacsAxis::doPoll(bool *moving) { if (handshakePerformed == 1.0) { // Handshake has been performed successfully -> Continue with the // poll - waitForHandshake_ = false; - targetReachedUninitialized_ = false; + pMasterMacsA_->waitForHandshake = false; + pMasterMacsA_->targetReachedUninitialized = false; } else { // Still waiting for the handshake - try again in the next busy // poll. This is already part of the movement procedure. @@ -409,7 +433,7 @@ asynStatus masterMacsAxis::doPoll(bool *moving) { return rw_status; } - if (targetReachedUninitialized_) { + if (pMasterMacsA_->targetReachedUninitialized) { *moving = false; } else { if (targetReached() || !switchedOn()) { @@ -420,7 +444,7 @@ asynStatus masterMacsAxis::doPoll(bool *moving) { } if (targetReached()) { - targetReachedUninitialized_ = false; + pMasterMacsA_->targetReachedUninitialized = false; } // Read the current position @@ -819,7 +843,7 @@ asynStatus masterMacsAxis::doMove(double position, int relative, // Set the new motor speed, if the user is allowed to do so and if the // motor speed changed since the last move command. - if (motorCanSetSpeed != 0 && lastSetSpeed_ != motorVelocity) { + if (motorCanSetSpeed != 0 && pMasterMacsA_->lastSetSpeed != motorVelocity) { lastSetSpeed_ = motorVelocity; @@ -857,7 +881,8 @@ asynStatus masterMacsAxis::doMove(double position, int relative, // If the motor has just been enabled, use Enable double timeout = pC_->comTimeout(); - if (targetReachedUninitialized_ && timeout < PowerCycleTimeout) { + if (pMasterMacsA_->targetReachedUninitialized && + timeout < PowerCycleTimeout) { timeout = PowerCycleTimeout; } @@ -879,8 +904,8 @@ asynStatus masterMacsAxis::doMove(double position, int relative, // In the next poll, we will check if the handshake has been performed in a // reasonable time - waitForHandshake_ = true; - timeAtHandshake_ = time(NULL); + pMasterMacsA_->waitForHandshake = true; + pMasterMacsA_->timeAtHandshake = time(NULL); // Waiting for a handshake is already part of the movement procedure => // Start the watchdog @@ -911,6 +936,10 @@ asynStatus masterMacsAxis::stop(double acceleration) { } } + // Reset the driver to idle state and move out of the handshake wait loop, + // if we're currently inside it. + pMasterMacsA_->waitForHandshake = false; + return rw_status; } @@ -933,6 +962,10 @@ asynStatus masterMacsAxis::doReset() { } } + // Reset the driver to idle state and move out of the handshake wait loop, + // if we're currently inside it. + pMasterMacsA_->waitForHandshake = false; + return rw_status; } @@ -981,8 +1014,8 @@ asynStatus masterMacsAxis::doHome(double min_velocity, double max_velocity, // In the next poll, we will check if the handshake has been performed // in a reasonable time - waitForHandshake_ = true; - timeAtHandshake_ = time(NULL); + pMasterMacsA_->waitForHandshake = true; + pMasterMacsA_->timeAtHandshake = time(NULL); return asynSuccess; } else { return asynError; @@ -1056,7 +1089,7 @@ asynStatus masterMacsAxis::enable(bool on) { 0. In order to prevent the poll method in interpreting the motor state as "moving", this flag is used. It is reset in the handshake. */ - targetReachedUninitialized_ = true; + pMasterMacsA_->targetReachedUninitialized = true; /* Continue regardless of the status returned by the poll; we just want to @@ -1112,7 +1145,8 @@ asynStatus masterMacsAxis::enable(bool on) { // hence we wait for a custom timespan in seconds instead of // pC_->comTimeout_ double timeout = pC_->comTimeout(); - if (targetReachedUninitialized_ && timeout < PowerCycleTimeout) { + if (pMasterMacsA_->targetReachedUninitialized && + timeout < PowerCycleTimeout) { timeout = PowerCycleTimeout; } @@ -1190,7 +1224,7 @@ asynStatus masterMacsAxis::readAxisStatus() { __PRETTY_FUNCTION__, __LINE__); } - axisStatus_ = toBitset(axisStatus); + pMasterMacsA_->axisStatus = toBitset(axisStatus); } return rw_status; @@ -1210,11 +1244,175 @@ asynStatus masterMacsAxis::readAxisError() { return pC_->couldNotParseResponse("R11", response, axisNo_, __PRETTY_FUNCTION__, __LINE__); } - axisError_ = toBitset(axisError); + pMasterMacsA_->axisError = toBitset(axisError); } return rw_status; } +asynStatus readConfig(); + +/** + * @brief Read the Master MACS status with the xR10 command and store the + * result in pMasterMacsA_->axisStatus + * + */ +asynStatus readAxisStatus(); + +/* +The functions below read the specified status bit from the +pMasterMacsA_->axisStatus bitset. Since a bit can either be 0 or 1, the return +value is given as a boolean. +*/ + +/** + * @brief Read the property from pMasterMacsA_->axisStatus + */ +bool readyToBeSwitchedOn() { return pMasterMacsA_->axisStatus[0]; } + +/** + * @brief Read the property from pMasterMacsA_->axisStatus + */ +bool switchedOn() { return pMasterMacsA_->axisStatus[1]; } + +// Bit 2 is unused + +/** + * @brief Read the property from pMasterMacsA_->axisStatus + */ +bool faultConditionSet() { return pMasterMacsA_->axisStatus[3]; } + +/** + * @brief Read the property from pMasterMacsA_->axisStatus + */ +bool voltagePresent() { return pMasterMacsA_->axisStatus[4]; } + +/** + * @brief Read the property from pMasterMacsA_->axisStatus + */ +bool quickStopping() { return pMasterMacsA_->axisStatus[5] == 0; } + +/** + * @brief Read the property from pMasterMacsA_->axisStatus + */ +bool switchOnDisabled() { return pMasterMacsA_->axisStatus[6]; } + +/** + * @brief Read the property from pMasterMacsA_->axisStatus + */ +bool warning() { return pMasterMacsA_->axisStatus[7]; } + +// Bit 8 is unused + +/** + * @brief Read the property from pMasterMacsA_->axisStatus + */ +bool remoteMode() { return pMasterMacsA_->axisStatus[9]; } + +/** + * @brief Read the property from pMasterMacsA_->axisStatus + */ +bool targetReached() { return pMasterMacsA_->axisStatus[10]; } + +/** + * @brief Read the property from pMasterMacsA_->axisStatus + */ +bool internalLimitActive() { return pMasterMacsA_->axisStatus[11]; } + +// Bits 12 and 13 are unused + +/** + * @brief Read the property from pMasterMacsA_->axisStatus + */ +bool setEventHasOcurred() { return pMasterMacsA_->axisStatus[14]; } + +/** + * @brief Read the property from pMasterMacsA_->axisStatus + */ +bool powerEnabled() { return pMasterMacsA_->axisStatus[15]; } + +/** + * @brief Read the Master MACS status with the xR10 command and store the + * result in pMasterMacsA_->axisStatus + * + */ +asynStatus readAxisError(); + +/* +The functions below read the specified error bit from the +pMasterMacsA_->axisError bitset. Since a bit can either be 0 or 1, the return +value is given as a boolean. +*/ + +/** + * @brief Read the property from pMasterMacsA_->axisError + */ +bool shortCircuit() { return pMasterMacsA_->axisError[1]; } + +/** + * @brief Read the property from pMasterMacsA_->axisError + */ +bool encoderError() { return pMasterMacsA_->axisError[2]; } + +/** + * @brief Read the property from pMasterMacsA_->axisError + */ +bool followingError() { return pMasterMacsA_->axisError[3]; } + +/** + * @brief Read the property from pMasterMacsA_->axisError + */ +bool communicationError() { return pMasterMacsA_->axisError[4]; } + +/** + * @brief Read the property from pMasterMacsA_->axisError + */ +bool feedbackError() { return pMasterMacsA_->axisError[5]; } + +/** + * @brief Read the property from pMasterMacsA_->axisError + */ +bool positiveLimitSwitch() { return pMasterMacsA_->axisError[6]; } + +/** + * @brief Read the property from pMasterMacsA_->axisError + */ +bool negativeLimitSwitch() { return pMasterMacsA_->axisError[7]; } + +/** + * @brief Read the property from pMasterMacsA_->axisError + */ +bool positiveSoftwareLimit() { return pMasterMacsA_->axisError[8]; } + +/** + * @brief Read the property from pMasterMacsA_->axisError + */ +bool negativeSoftwareLimit() { return pMasterMacsA_->axisError[9]; } + +/** + * @brief Read the property from pMasterMacsA_->axisError + */ +bool overCurrent() { return pMasterMacsA_->axisError[10]; } + +/** + * @brief Read the property from pMasterMacsA_->axisError + */ +bool overTemperature() { return pMasterMacsA_->axisError[11]; } + +/** + * @brief Read the property from pMasterMacsA_->axisError + */ +bool overVoltage() { return pMasterMacsA_->axisError[12]; } + +/** + * @brief Read the property from pMasterMacsA_->axisError + */ +bool underVoltage() { return pMasterMacsA_->axisError[13]; } + +/** + * @brief Read the property from pMasterMacsA_->axisError + */ +bool stoFault() { return pMasterMacsA_->axisError[15]; } + /***************************************************************************/ /** The following functions are C-wrappers, and can be called directly from * iocsh */ diff --git a/src/masterMacsAxis.h b/src/masterMacsAxis.h index 77c9d74..5cd0e2c 100644 --- a/src/masterMacsAxis.h +++ b/src/masterMacsAxis.h @@ -1,13 +1,15 @@ #ifndef masterMacsAXIS_H #define masterMacsAXIS_H #include "sinqAxis.h" -#include +#include // Forward declaration of the controller class to resolve the cyclic dependency // between the controller and the axis .h-file. See // https://en.cppreference.com/w/cpp/language/class. class masterMacsController; +struct masterMaxsAxisImpl; + class masterMacsAxis : public sinqAxis { public: /** @@ -105,23 +107,23 @@ class masterMacsAxis : public sinqAxis { */ asynStatus readEncoderType(); - protected: - masterMacsController *pC_; - double lastSetSpeed_; - bool waitForHandshake_; - time_t timeAtHandshake_; + /** + * @brief Check if the axis needs to run its initialization function + * + * @return true + * @return false + */ + bool needInit(); - bool targetReachedUninitialized_; + /** + * @brief Instruct the axis to run its init() function during the next poll + * + * @param needInit + */ + void setNeedInit(bool needInit); asynStatus readConfig(); - /* - The axis status and axis error of MasterMACS are given as an integer from - the controller. The 16 individual bits contain the actual information. - */ - std::bitset<16> axisStatus_; - std::bitset<16> axisError_; - /** * @brief Read the Master MACS status with the xR10 command and store the * result in axisStatus_ @@ -130,7 +132,7 @@ class masterMacsAxis : public sinqAxis { asynStatus readAxisStatus(); /* - The functions below read the specified status bit from the axisStatus_ + The functions below read the specified status bit from the axisStatus bitset. Since a bit can either be 0 or 1, the return value is given as a boolean. */ @@ -138,68 +140,68 @@ class masterMacsAxis : public sinqAxis { /** * @brief Read the property from axisStatus_ */ - bool readyToBeSwitchedOn() { return axisStatus_[0]; } + bool readyToBeSwitchedOn(); /** * @brief Read the property from axisStatus_ */ - bool switchedOn() { return axisStatus_[1]; } + bool switchedOn(); // Bit 2 is unused /** * @brief Read the property from axisStatus_ */ - bool faultConditionSet() { return axisStatus_[3]; } + bool faultConditionSet(); /** * @brief Read the property from axisStatus_ */ - bool voltagePresent() { return axisStatus_[4]; } + bool voltagePresent(); /** * @brief Read the property from axisStatus_ */ - bool quickStopping() { return axisStatus_[5] == 0; } + bool quickStopping(); /** * @brief Read the property from axisStatus_ */ - bool switchOnDisabled() { return axisStatus_[6]; } + bool switchOnDisabled(); /** * @brief Read the property from axisStatus_ */ - bool warning() { return axisStatus_[7]; } + bool warning(); // Bit 8 is unused /** * @brief Read the property from axisStatus_ */ - bool remoteMode() { return axisStatus_[9]; } + bool remoteMode(); /** * @brief Read the property from axisStatus_ */ - bool targetReached() { return axisStatus_[10]; } + bool targetReached(); /** * @brief Read the property from axisStatus_ */ - bool internalLimitActive() { return axisStatus_[11]; } + bool internalLimitActive(); // Bits 12 and 13 are unused /** * @brief Read the property from axisStatus_ */ - bool setEventHasOcurred() { return axisStatus_[14]; } + bool setEventHasOcurred(); /** * @brief Read the property from axisStatus_ */ - bool powerEnabled() { return axisStatus_[15]; } + bool powerEnabled(); /** * @brief Read the Master MACS status with the xR10 command and store the @@ -217,72 +219,76 @@ class masterMacsAxis : public sinqAxis { /** * @brief Read the property from axisError_ */ - bool shortCircuit() { return axisError_[1]; } + bool shortCircuit(); /** * @brief Read the property from axisError_ */ - bool encoderError() { return axisError_[2]; } + bool encoderError(); /** * @brief Read the property from axisError_ */ - bool followingError() { return axisError_[3]; } + bool followingError(); /** * @brief Read the property from axisError_ */ - bool communicationError() { return axisError_[4]; } + bool communicationError(); /** * @brief Read the property from axisError_ */ - bool feedbackError() { return axisError_[5]; } + bool feedbackError(); /** * @brief Read the property from axisError_ */ - bool positiveLimitSwitch() { return axisError_[6]; } + bool positiveLimitSwitch(); /** * @brief Read the property from axisError_ */ - bool negativeLimitSwitch() { return axisError_[7]; } + bool negativeLimitSwitch(); /** * @brief Read the property from axisError_ */ - bool positiveSoftwareLimit() { return axisError_[8]; } + bool positiveSoftwareLimit(); /** * @brief Read the property from axisError_ */ - bool negativeSoftwareLimit() { return axisError_[9]; } + bool negativeSoftwareLimit(); /** * @brief Read the property from axisError_ */ - bool overCurrent() { return axisError_[10]; } + bool overCurrent(); /** * @brief Read the property from axisError_ */ - bool overTemperature() { return axisError_[11]; } + bool overTemperature(); /** * @brief Read the property from axisError_ */ - bool overVoltage() { return axisError_[12]; } + bool overVoltage(); /** * @brief Read the property from axisError_ */ - bool underVoltage() { return axisError_[13]; } + bool underVoltage(); /** * @brief Read the property from axisError_ */ - bool stoFault() { return axisError_[15]; } + bool stoFault(); + + private: + masterMacsController *pC_; + std::unique_ptr pMasterMacsA_; }; #endif diff --git a/src/masterMacsController.cpp b/src/masterMacsController.cpp index 2e9e52d..fdf8905 100644 --- a/src/masterMacsController.cpp +++ b/src/masterMacsController.cpp @@ -12,6 +12,15 @@ #include #include +struct masterMacsControllerImpl { + double comTimeout; +}; + +/* +Stores the constructor input comTimeout +*/ +double; + /** * @brief Copy src into dst and replace all NULL terminators up to the carriage * return with spaces. This allows to print *dst with asynPrint. @@ -59,8 +68,10 @@ masterMacsController::masterMacsController(const char *portName, // Initialization of local variables asynStatus status = asynSuccess; - // Initialization of all member variables - comTimeout_ = comTimeout; + pMasterMacsC_ = + std::make_unique((masterMacsControllerImpl){ + .comTimeout = comTimeout, + }); // ========================================================================= @@ -158,7 +169,7 @@ asynStatus masterMacsController::writeRead(int axisNo, int tcpCmd, // Check if a custom timeout has been given if (comTimeout < 0.0) { - comTimeout = comTimeout_; + comTimeout = pMasterMacsC_->comTimeout; } masterMacsAxis *axis = getMasterMacsAxis(axisNo); @@ -192,7 +203,7 @@ asynStatus masterMacsController::writeRead(int axisNo, int tcpCmd, msgPrintControlKey comKey = msgPrintControlKey(portName, axisNo, __PRETTY_FUNCTION__, __LINE__); if (status != asynSuccess) { - if (msgPrintControl_.shouldBePrinted(comKey, true, pasynUserSelf)) { + if (getMsgPrintControl().shouldBePrinted(comKey, true, pasynUserSelf)) { char printableCommand[MAXBUF_] = {0}; adjustForPrint(printableCommand, fullCommand, MAXBUF_); asynPrint(this->pasynUserSelf, ASYN_TRACE_ERROR, @@ -202,7 +213,7 @@ asynStatus masterMacsController::writeRead(int axisNo, int tcpCmd, stringifyAsynStatus(status), printableCommand); } } else { - msgPrintControl_.resetCount(comKey, pasynUserSelf); + getMsgPrintControl().resetCount(comKey, pasynUserSelf); } // Create custom error messages for different failure modes @@ -252,21 +263,34 @@ asynStatus masterMacsController::writeRead(int axisNo, int tcpCmd, pl_status = axis->setIntegerParam(this->motorStatusCommsError_, 0); } else { - // Check if the axis already is in an error communication mode. If - // it is not, upstream the error. This is done to avoid "flooding" - // the user with different error messages if more than one error - // ocurred before an error-free communication + /* + Since the communication failed, there is the possibility that the + controller is not connected at all to the network. In that case, we + cannot be sure that the information read out in the init method of the + axis is still up-to-date the next time we get a connection. Therefore, + an info flag is set which the axis object can use at the start of its + poll method to try to initialize itself. + */ + axis->setNeedInit(true); + + /* + Check if the axis already is in an error communication mode. If + it is not, upstream the error. This is done to avoid "flooding" + the user with different error messages if more than one error + ocurred before an error-free communication + */ pl_status = getIntegerParam(axisNo, motorStatusProblem_, &motorStatusProblem); if (pl_status != asynSuccess) { - return paramLibAccessFailed(pl_status, "motorStatusProblem_", - axisNo, __PRETTY_FUNCTION__, __LINE__); + return paramLibAccessFailed(pl_status, "motorStatusProblem", axisNo, + __PRETTY_FUNCTION__, __LINE__); } if (motorStatusProblem == 0) { - pl_status = axis->setStringParam(motorMessageText_, drvMessageText); + pl_status = + axis->setStringParam(motorMessageText(), drvMessageText); if (pl_status != asynSuccess) { - return paramLibAccessFailed(pl_status, "motorMessageText_", + return paramLibAccessFailed(pl_status, "motorMessageText", axisNo, __PRETTY_FUNCTION__, __LINE__); } @@ -405,15 +429,15 @@ asynStatus masterMacsController::parseResponse( "Tried to write with a read-only command. This is a " "bug, please call the support."); - if (msgPrintControl_.shouldBePrinted(parseKey, true, - pasynUserSelf)) { + if (getMsgPrintControl().shouldBePrinted(parseKey, true, + pasynUserSelf)) { adjustForPrint(printableCommand, fullCommand, MAXBUF_); asynPrint( this->pasynUserSelf, ASYN_TRACE_ERROR, "Controller \"%s\", axis %d => %s, line %d:\nTried to " "write with the read-only command %s.%s\n", portName, axisNo, __PRETTY_FUNCTION__, __LINE__, - printableCommand, msgPrintControl_.getSuffix()); + printableCommand, getMsgPrintControl().getSuffix()); } responseValid = false; break; @@ -421,7 +445,7 @@ asynStatus masterMacsController::parseResponse( } if (responseValid) { - msgPrintControl_.resetCount(parseKey, pasynUserSelf); + getMsgPrintControl().resetCount(parseKey, pasynUserSelf); // Check if the response matches the expectations. Each response // contains the string "axisNo R tcpCmd" (including the spaces) @@ -445,15 +469,15 @@ asynStatus masterMacsController::parseResponse( adjustForPrint(printableCommand, fullCommand, MAXBUF_); adjustForPrint(printableResponse, fullResponse, MAXBUF_); - if (msgPrintControl_.shouldBePrinted(parseKey, true, - pasynUserSelf)) { + if (getMsgPrintControl().shouldBePrinted(parseKey, true, + pasynUserSelf)) { asynPrint(this->pasynUserSelf, ASYN_TRACEIO_DRIVER, "Controller \"%s\", axis %d => %s, line " "%d:\nMismatched " "response %s to command %s.%s\n", portName, axisNo, __PRETTY_FUNCTION__, __LINE__, printableResponse, printableCommand, - msgPrintControl_.getSuffix()); + getMsgPrintControl().getSuffix()); } snprintf(drvMessageText, MAXBUF_, @@ -462,7 +486,7 @@ asynStatus masterMacsController::parseResponse( printableResponse, printableCommand); return asynError; } else { - msgPrintControl_.resetCount(responseMatchKey, pasynUserSelf); + getMsgPrintControl().resetCount(responseMatchKey, pasynUserSelf); } } return asynSuccess; @@ -471,7 +495,7 @@ asynStatus masterMacsController::parseResponse( asynStatus masterMacsController::readInt32(asynUser *pasynUser, epicsInt32 *value) { // masterMacs can be disabled - if (pasynUser->reason == motorCanDisable_) { + if (pasynUser->reason == motorCanDisable()) { *value = 1; return asynSuccess; } else { @@ -479,6 +503,8 @@ asynStatus masterMacsController::readInt32(asynUser *pasynUser, } } +double masterMacsController::comTimeout() { return pMasterMacsC_->comTimeout; } + /***************************************************************************/ /** The following functions are C-wrappers, and can be called directly from * iocsh */ diff --git a/src/masterMacsController.h b/src/masterMacsController.h index 2d48847..849ae44 100644 --- a/src/masterMacsController.h +++ b/src/masterMacsController.h @@ -11,6 +11,9 @@ #include "masterMacsAxis.h" #include "sinqAxis.h" #include "sinqController.h" +#include + +struct masterMacsControllerImpl; class masterMacsController : public sinqController { @@ -132,13 +135,10 @@ class masterMacsController : public sinqController { * * @return double Timeout in seconds */ - double comTimeout() { return comTimeout_; } + double comTimeout(); private: - /* - Stores the constructor input comTimeout - */ - double comTimeout_; + std::unique_ptr pMasterMacsC_; }; #endif /* masterMacsController_H */