lin-epics-modules/mastermacs
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Applied PIMPL principle

Browse Source
This commit is contained in:
mathis_s
2025-05-23 12:16:25 +02:00
parent e0a74c5598
commit d1d694ad6b
5 changed files with 328 additions and 98 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
sinqMotor

Submodule sinqMotor updated: 275672aaef...87980e403c

256
src/masterMacsAxis.cpp
View File

@ -11,6 +11,21 @@
#include <string.h>
#include <unistd.h>
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<masterMaxsAxisImpl>((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 */

88
src/masterMacsAxis.h
View File

@ -1,13 +1,15 @@
#ifndef masterMacsAXIS_H
#define masterMacsAXIS_H
#include "sinqAxis.h"
#include <bitset>
#include <memory>
// 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<masterMaxsAxisImpl> pMasterMacsA_;
};
#endif

70
src/masterMacsController.cpp
View File

@ -12,6 +12,15 @@
#include <string>
#include <unistd.h>
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>((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 */

10
src/masterMacsController.h
View File

@ -11,6 +11,9 @@
#include "masterMacsAxis.h"
#include "sinqAxis.h"
#include "sinqController.h"
#include <memory>
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<masterMacsControllerImpl> pMasterMacsC_;
};
#endif /* masterMacsController_H */