Updated sinqMotor version and removed unnecessary require

Reviewed-on: #1

Makefile

@@ -4,7 +4,7 @@ include /ioc/tools/driver.makefile
 MODULE=masterMacs
 BUILDCLASSES=Linux
 EPICS_VERSIONS=7.0.7
-ARCH_FILTER=RHEL8%
+ARCH_FILTER=RHEL%
 
 # Specify the version of asynMotor we want to build against
 motorBase_VERSION=7.2.2

src/masterMacsAxis.cpp

@@ -363,14 +363,8 @@ asynStatus masterMacsAxis::doPoll(bool *moving) {
         }
 
         if (timedOut) {
-            pl_status =
-                setStringParam(pC_->motorMessageText(),
+            setAxisParamChecked(this, motorMessageText,
                                 "Timed out while waiting for a handshake");
-            if (pl_status != asynSuccess) {
-                return pC_->paramLibAccessFailed(pl_status, "motorMessageText_",
-                                                 axisNo_, __PRETTY_FUNCTION__,
-                                                 __LINE__);
-            }
         }
 
         pC_->read(axisNo_, 86, response);
@@ -394,32 +388,15 @@ asynStatus masterMacsAxis::doPoll(bool *moving) {
             // poll. This is already part of the movement procedure.
             *moving = true;
 
-            pl_status = setIntegerParam(pC_->motorStatusMoving(), *moving);
-            if (pl_status != asynSuccess) {
-                return pC_->paramLibAccessFailed(pl_status,
-                                                 "motorStatusMoving_", axisNo_,
-                                                 __PRETTY_FUNCTION__, __LINE__);
-            }
-
-            pl_status = setIntegerParam(pC_->motorStatusDone(), !(*moving));
-            if (pl_status != asynSuccess) {
-                return pC_->paramLibAccessFailed(pl_status, "motorStatusDone_",
-                                                 axisNo_, __PRETTY_FUNCTION__,
-                                                 __LINE__);
-            }
+            setAxisParamChecked(this, motorStatusMoving, *moving);
+            setAxisParamChecked(this, motorStatusDone, !(*moving));
 
             return asynSuccess;
         }
     }
 
     // Motor resolution from parameter library
-    pl_status = pC_->getDoubleParam(axisNo_, pC_->motorRecResolution(),
-                                    &motorRecResolution);
-    if (pl_status != asynSuccess) {
-        return pC_->paramLibAccessFailed(pl_status, "motorRecResolution_",
-                                         axisNo_, __PRETTY_FUNCTION__,
-                                         __LINE__);
-    }
+    getAxisParamChecked(this, motorRecResolution, &motorRecResolution);
 
     // Read the previous motor position
     pl_status = motorPosition(&previousPosition);
@@ -483,15 +460,9 @@ asynStatus masterMacsAxis::doPoll(bool *moving) {
                           pC_->getMsgPrintControl().getSuffix());
             }
 
-            pl_status =
-                setStringParam(pC_->motorMessageText(),
+            setAxisParamChecked(this, motorMessageText,
                                 "Communication error between PC and motor "
                                 "controller. Please call the support.");
-            if (pl_status != asynSuccess) {
-                return pC_->paramLibAccessFailed(pl_status, "motorMessageText_",
-                                                 axisNo_, __PRETTY_FUNCTION__,
-                                                 __LINE__);
-            }
 
             poll_status = asynError;
         } else {
@@ -643,12 +614,7 @@ asynStatus masterMacsAxis::doPoll(bool *moving) {
                 }
             }
 
-            pl_status = setStringParam(pC_->motorMessageText(), errorMessage);
-            if (pl_status != asynSuccess) {
-                return pC_->paramLibAccessFailed(pl_status, "motorMessageText_",
-                                                 axisNo_, __PRETTY_FUNCTION__,
-                                                 __LINE__);
-            }
+            setAxisParamChecked(this, motorMessageText, errorMessage);
         }
     } else {
         pC_->getMsgPrintControl().resetCount(keyError, pC_->pasynUser());
@@ -689,40 +655,18 @@ asynStatus masterMacsAxis::doPoll(bool *moving) {
         directly, but need to shrink them a bit. In this case, we're shrinking
         them by 0.1 mm or 0.1 degree (depending on the axis type) on both sides.
         */
-        pl_status = pC_->getDoubleParam(axisNo_, pC_->motorLimitsOffset(),
-                                        &limitsOffset);
-        if (pl_status != asynSuccess) {
-            return pC_->paramLibAccessFailed(pl_status, "motorLimitsOffset_",
-                                             axisNo_, __PRETTY_FUNCTION__,
-                                             __LINE__);
-        }
+        getAxisParamChecked(this, motorLimitsOffset, &limitsOffset);
+
         highLimit = highLimit - limitsOffset;
         lowLimit = lowLimit + limitsOffset;
 
-        pl_status = pC_->setDoubleParam(
-            axisNo_, pC_->motorHighLimitFromDriver(), highLimit);
-        if (pl_status != asynSuccess) {
-            return pC_->paramLibAccessFailed(
-                pl_status, "motorHighLimitFromDriver_", axisNo_,
-                __PRETTY_FUNCTION__, __LINE__);
-        }
-
-        pl_status = pC_->setDoubleParam(axisNo_, pC_->motorLowLimitFromDriver(),
-                                        lowLimit);
-        if (pl_status != asynSuccess) {
-            return pC_->paramLibAccessFailed(pl_status, "motorLowLimit_",
-                                             axisNo_, __PRETTY_FUNCTION__,
-                                             __LINE__);
-        }
+        setAxisParamChecked(this, motorHighLimitFromDriver, highLimit);
+        setAxisParamChecked(this, motorLowLimitFromDriver, lowLimit);
     }
 
     // Update the enable PV
-    pl_status = setIntegerParam(pC_->motorEnableRBV(),
+    setAxisParamChecked(this, motorEnableRBV,
                         readyToBeSwitchedOn() && switchedOn());
-    if (pl_status != asynSuccess) {
-        return pC_->paramLibAccessFailed(pl_status, "motorEnableRBV_", axisNo_,
-                                         __PRETTY_FUNCTION__, __LINE__);
-    }
 
     if (*moving) {
         // If the axis is moving, evaluate the movement direction
@@ -735,32 +679,11 @@ asynStatus masterMacsAxis::doPoll(bool *moving) {
 
     // Update the parameter library
     if (hasError) {
-        pl_status = setIntegerParam(pC_->motorStatusProblem(), true);
-        if (pl_status != asynSuccess) {
-            return pC_->paramLibAccessFailed(pl_status, "motorStatusProblem_",
-                                             axisNo_, __PRETTY_FUNCTION__,
-                                             __LINE__);
-        }
-    }
-    pl_status = setIntegerParam(pC_->motorStatusMoving(), *moving);
-    if (pl_status != asynSuccess) {
-        return pC_->paramLibAccessFailed(pl_status, "motorStatusMoving_",
-                                         axisNo_, __PRETTY_FUNCTION__,
-                                         __LINE__);
-    }
-
-    pl_status = setIntegerParam(pC_->motorStatusDone(), !(*moving));
-    if (pl_status != asynSuccess) {
-        return pC_->paramLibAccessFailed(pl_status, "motorStatusDone_", axisNo_,
-                                         __PRETTY_FUNCTION__, __LINE__);
-    }
-
-    pl_status = setIntegerParam(pC_->motorStatusDirection(), direction);
-    if (pl_status != asynSuccess) {
-        return pC_->paramLibAccessFailed(pl_status, "motorStatusDirection_",
-                                         axisNo_, __PRETTY_FUNCTION__,
-                                         __LINE__);
+        setAxisParamChecked(this, motorStatusProblem, true);
     }
+    setAxisParamChecked(this, motorStatusMoving, *moving);
+    setAxisParamChecked(this, motorStatusDone, !(*moving));
+    setAxisParamChecked(this, motorStatusDirection, direction);
 
     pl_status = setMotorPosition(currentPosition);
     if (pl_status != asynSuccess) {
@@ -775,10 +698,7 @@ asynStatus masterMacsAxis::doMove(double position, int relative,
                                   double acceleration) {
 
     // Status of read-write-operations of ASCII commands to the controller
-    asynStatus rw_status = asynSuccess;
-
-    // Status of parameter library operations
-    asynStatus pl_status = asynSuccess;
+    asynStatus status = asynSuccess;
 
     char value[pC_->MAXBUF_];
     double motorCoordinatesPosition = 0.0;
@@ -789,19 +709,8 @@ asynStatus masterMacsAxis::doMove(double position, int relative,
 
     // =========================================================================
 
-    pl_status = pC_->getIntegerParam(axisNo_, pC_->motorEnableRBV(), &enabled);
-    if (pl_status != asynSuccess) {
-        return pC_->paramLibAccessFailed(pl_status, "enableMotorRBV_", axisNo_,
-                                         __PRETTY_FUNCTION__, __LINE__);
-    }
-
-    pl_status = pC_->getDoubleParam(axisNo_, pC_->motorRecResolution(),
-                                    &motorRecResolution);
-    if (pl_status != asynSuccess) {
-        return pC_->paramLibAccessFailed(pl_status, "motorRecResolution_",
-                                         axisNo_, __PRETTY_FUNCTION__,
-                                         __LINE__);
-    }
+    getAxisParamChecked(this, motorEnableRBV, &enabled);
+    getAxisParamChecked(this, motorRecResolution, &motorRecResolution);
 
     if (enabled == 0) {
         asynPrint(pC_->pasynUser(), ASYN_TRACE_ERROR,
@@ -821,24 +730,13 @@ asynStatus masterMacsAxis::doMove(double position, int relative,
         pC_->portName, axisNo_, __PRETTY_FUNCTION__, __LINE__, position);
 
     // Check if the speed is allowed to be changed
-    pl_status = pC_->getIntegerParam(axisNo_, pC_->motorCanSetSpeed(),
-                                     &motorCanSetSpeed);
-    if (pl_status != asynSuccess) {
-        return pC_->paramLibAccessFailed(pl_status, "motorCanSetSpeed_",
-                                         axisNo_, __PRETTY_FUNCTION__,
-                                         __LINE__);
-    }
+    getAxisParamChecked(this, motorCanSetSpeed, &motorCanSetSpeed);
 
     // Initialize the movement handshake
-    rw_status = pC_->write(axisNo_, 86, "0");
-    if (rw_status != asynSuccess) {
-        pl_status = setIntegerParam(pC_->motorStatusProblem(), true);
-        if (pl_status != asynSuccess) {
-            return pC_->paramLibAccessFailed(pl_status, "motorStatusProblem_",
-                                             axisNo_, __PRETTY_FUNCTION__,
-                                             __LINE__);
-        }
-        return rw_status;
+    status = pC_->write(axisNo_, 86, "0");
+    if (status != asynSuccess) {
+        setAxisParamChecked(this, motorStatusProblem, true);
+        return status;
     }
 
     // Set the new motor speed, if the user is allowed to do so and if the
@@ -848,15 +746,10 @@ asynStatus masterMacsAxis::doMove(double position, int relative,
         pMasterMacsA_->lastSetSpeed = motorVelocity;
 
         snprintf(value, sizeof(value), "%lf", motorVelocity);
-        rw_status = pC_->write(axisNo_, 05, value);
-        if (rw_status != asynSuccess) {
-            pl_status = setIntegerParam(pC_->motorStatusProblem(), true);
-            if (pl_status != asynSuccess) {
-                return pC_->paramLibAccessFailed(pl_status,
-                                                 "motorStatusProblem_", axisNo_,
-                                                 __PRETTY_FUNCTION__, __LINE__);
-            }
-            return rw_status;
+        status = pC_->write(axisNo_, 05, value);
+        if (status != asynSuccess) {
+            setAxisParamChecked(this, motorStatusProblem, true);
+            return status;
         }
 
         asynPrint(pC_->pasynUser(), ASYN_TRACE_FLOW,
@@ -868,15 +761,10 @@ asynStatus masterMacsAxis::doMove(double position, int relative,
 
     // Set the target position
     snprintf(value, sizeof(value), "%lf", motorCoordinatesPosition);
-    rw_status = pC_->write(axisNo_, 02, value);
-    if (rw_status != asynSuccess) {
-        pl_status = setIntegerParam(pC_->motorStatusProblem(), true);
-        if (pl_status != asynSuccess) {
-            return pC_->paramLibAccessFailed(pl_status, "motorStatusProblem_",
-                                             axisNo_, __PRETTY_FUNCTION__,
-                                             __LINE__);
-        }
-        return rw_status;
+    status = pC_->write(axisNo_, 02, value);
+    if (status != asynSuccess) {
+        setAxisParamChecked(this, motorStatusProblem, true);
+        return status;
     }
 
     // If the motor has just been enabled, use Enable
@@ -888,18 +776,13 @@ asynStatus masterMacsAxis::doMove(double position, int relative,
 
     // Start the move
     if (relative) {
-        rw_status = pC_->write(axisNo_, 00, "2", timeout);
+        status = pC_->write(axisNo_, 00, "2", timeout);
     } else {
-        rw_status = pC_->write(axisNo_, 00, "1", timeout);
+        status = pC_->write(axisNo_, 00, "1", timeout);
     }
-    if (rw_status != asynSuccess) {
-        pl_status = setIntegerParam(pC_->motorStatusProblem(), true);
-        if (pl_status != asynSuccess) {
-            return pC_->paramLibAccessFailed(pl_status, "motorStatusProblem_",
-                                             axisNo_, __PRETTY_FUNCTION__,
-                                             __LINE__);
-        }
-        return rw_status;
+    if (status != asynSuccess) {
+        setAxisParamChecked(this, motorStatusProblem, true);
+        return status;
     }
 
     // In the next poll, we will check if the handshake has been performed in a
@@ -913,60 +796,35 @@ asynStatus masterMacsAxis::doMove(double position, int relative,
         return asynError;
     }
 
-    return rw_status;
+    return status;
 }
 
 asynStatus masterMacsAxis::stop(double acceleration) {
 
-    // Status of read-write-operations of ASCII commands to the controller
-    asynStatus rw_status = asynSuccess;
-
-    // Status of parameter library operations
-    asynStatus pl_status = asynSuccess;
-
-    // =========================================================================
-
-    rw_status = pC_->write(axisNo_, 00, "8");
-    if (rw_status != asynSuccess) {
-        pl_status = setIntegerParam(pC_->motorStatusProblem(), true);
-        if (pl_status != asynSuccess) {
-            return pC_->paramLibAccessFailed(pl_status, "motorStatusProblem_",
-                                             axisNo_, __PRETTY_FUNCTION__,
-                                             __LINE__);
-        }
+    asynStatus status = pC_->write(axisNo_, 00, "8");
+    if (status != asynSuccess) {
+        setAxisParamChecked(this, motorStatusProblem, true);
     }
 
     // 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;
+    return status;
 }
 
 asynStatus masterMacsAxis::doReset() {
-    // Status of read-write-operations of ASCII commands to the controller
-    asynStatus rw_status = asynSuccess;
 
-    // Status of parameter library operations
-    asynStatus pl_status = asynSuccess;
-
-    // =========================================================================
-
-    rw_status = pC_->write(axisNo_, 17, "");
-    if (rw_status != asynSuccess) {
-        pl_status = setIntegerParam(pC_->motorStatusProblem(), true);
-        if (pl_status != asynSuccess) {
-            return pC_->paramLibAccessFailed(pl_status, "motorStatusProblem_",
-                                             axisNo_, __PRETTY_FUNCTION__,
-                                             __LINE__);
-        }
+    asynStatus status = pC_->write(axisNo_, 17, "");
+    if (status != asynSuccess) {
+        setAxisParamChecked(this, motorStatusProblem, true);
     }
 
     // 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;
+    return status;
 }
 
 /*
@@ -975,41 +833,25 @@ Home the axis. On absolute encoder systems, this is a no-op
 asynStatus masterMacsAxis::doHome(double min_velocity, double max_velocity,
                                   double acceleration, int forwards) {
 
-    // Status of read-write-operations of ASCII commands to the controller
-    asynStatus rw_status = asynSuccess;
-
-    // Status of parameter library operations
-    asynStatus pl_status = asynSuccess;
-
     char response[pC_->MAXBUF_] = {0};
 
     // =========================================================================
 
-    pl_status = pC_->getStringParam(axisNo_, pC_->encoderType(),
-                                    sizeof(response), response);
-    if (pl_status != asynSuccess) {
-        return pC_->paramLibAccessFailed(pl_status, "encoderType_", axisNo_,
-                                         __PRETTY_FUNCTION__, __LINE__);
-    }
+    getAxisParamChecked(this, encoderType, &response);
 
     // Only send the home command if the axis has an incremental encoder
     if (strcmp(response, IncrementalEncoder) == 0) {
 
         // Initialize the movement handshake
-        rw_status = pC_->write(axisNo_, 86, "0");
-        if (rw_status != asynSuccess) {
-            pl_status = setIntegerParam(pC_->motorStatusProblem(), true);
-            if (pl_status != asynSuccess) {
-                return pC_->paramLibAccessFailed(pl_status,
-                                                 "motorStatusProblem_", axisNo_,
-                                                 __PRETTY_FUNCTION__, __LINE__);
-            }
-            return rw_status;
+        asynStatus status = pC_->write(axisNo_, 86, "0");
+        if (status != asynSuccess) {
+            setAxisParamChecked(this, motorStatusProblem, true);
+            return status;
         }
 
-        rw_status = pC_->write(axisNo_, 00, "9");
-        if (rw_status != asynSuccess) {
-            return rw_status;
+        status = pC_->write(axisNo_, 00, "9");
+        if (status != asynSuccess) {
+            return status;
         }
 
         // In the next poll, we will check if the handshake has been performed
@@ -1027,12 +869,6 @@ Read the encoder type and update the parameter library accordingly
 */
 asynStatus masterMacsAxis::readEncoderType() {
 
-    // Status of read-write-operations of ASCII commands to the controller
-    asynStatus rw_status = asynSuccess;
-
-    // Status of parameter library operations
-    asynStatus pl_status = asynSuccess;
-
     char command[pC_->MAXBUF_] = {0};
     char response[pC_->MAXBUF_] = {0};
     int nvals = 0;
@@ -1041,9 +877,9 @@ asynStatus masterMacsAxis::readEncoderType() {
     // =========================================================================
 
     // Check if this is an absolute encoder
-    rw_status = pC_->read(axisNo_, 60, response);
-    if (rw_status != asynSuccess) {
-        return rw_status;
+    asynStatus status = pC_->read(axisNo_, 60, response);
+    if (status != asynSuccess) {
+        return status;
     }
 
     nvals = sscanf(response, "%d", &encoder_id);
@@ -1059,28 +895,18 @@ asynStatus masterMacsAxis::readEncoderType() {
     2=SSI (Absolute encoder with BiSS interface)
      */
     if (encoder_id == 0) {
-        pl_status = setStringParam(pC_->encoderType(), IncrementalEncoder);
+        setAxisParamChecked(this, encoderType, IncrementalEncoder);
     } else {
-        pl_status = setStringParam(pC_->encoderType(), AbsoluteEncoder);
+        setAxisParamChecked(this, encoderType, AbsoluteEncoder);
     }
 
-    if (pl_status != asynSuccess) {
-        return pC_->paramLibAccessFailed(pl_status, "encoderType_", axisNo_,
-                                         __PRETTY_FUNCTION__, __LINE__);
-    }
     return asynSuccess;
 }
 
 asynStatus masterMacsAxis::enable(bool on) {
 
     int timeout_enable_disable = 2;
-    char value[pC_->MAXBUF_];
-
-    // Status of read-write-operations of ASCII commands to the controller
-    asynStatus rw_status = asynSuccess;
-
-    // Status of parameter library operations
-    asynStatus pl_status = asynSuccess;
+    char msg[pC_->MAXBUF_];
 
     // =========================================================================
 
@@ -1110,14 +936,8 @@ asynStatus masterMacsAxis::enable(bool on) {
                   "idle and can therefore not be disabled.\n",
                   pC_->portName, axisNo_, __PRETTY_FUNCTION__, __LINE__);
 
-        pl_status =
-            setStringParam(pC_->motorMessageText(),
+        setAxisParamChecked(this, motorMessageText,
                             "Axis cannot be disabled while it is moving.");
-        if (pl_status != asynSuccess) {
-            return pC_->paramLibAccessFailed(pl_status, "motorMessageText_",
-                                             axisNo_, __PRETTY_FUNCTION__,
-                                             __LINE__);
-        }
 
         return asynError;
     }
@@ -1135,7 +955,7 @@ asynStatus masterMacsAxis::enable(bool on) {
     }
 
     // Enable / disable the axis if it is not moving
-    snprintf(value, sizeof(value), "%d", on);
+    snprintf(msg, sizeof(msg), "%d", on);
     asynPrint(pC_->pasynUser(), ASYN_TRACE_FLOW,
               "Controller \"%s\", axis %d => %s, line %d:\n%s axis.\n",
               pC_->portName, axisNo_, __PRETTY_FUNCTION__, __LINE__,
@@ -1150,9 +970,9 @@ asynStatus masterMacsAxis::enable(bool on) {
         timeout = PowerCycleTimeout;
     }
 
-    rw_status = pC_->write(axisNo_, 04, value, timeout);
-    if (rw_status != asynSuccess) {
-        return rw_status;
+    asynStatus status = pC_->write(axisNo_, 04, msg, timeout);
+    if (status != asynSuccess) {
+        return status;
     }
 
     // Query the axis status every few milliseconds until the axis has been
@@ -1162,9 +982,9 @@ asynStatus masterMacsAxis::enable(bool on) {
 
         // Read the axis status
         usleep(100000);
-        rw_status = readAxisStatus();
-        if (rw_status != asynSuccess) {
-            return rw_status;
+        status = readAxisStatus();
+        if (status != asynSuccess) {
+            return status;
         }
 
         if (switchedOn() == on) {
@@ -1184,14 +1004,10 @@ asynStatus masterMacsAxis::enable(bool on) {
               on ? "enable" : "disable", timeout_enable_disable);
 
     // Output message to user
-    snprintf(value, sizeof(value), "Failed to %s within %d seconds",
+    snprintf(msg, sizeof(msg), "Failed to %s within %d seconds",
              on ? "enable" : "disable", timeout_enable_disable);
-    pl_status = setStringParam(pC_->motorMessageText(), value);
-    if (pl_status != asynSuccess) {
-        return pC_->paramLibAccessFailed(pl_status, "motorMessageText_",
-                                         axisNo_, __PRETTY_FUNCTION__,
-                                         __LINE__);
-    }
+
+    setAxisParamChecked(this, motorMessageText, msg);
     return asynError;
 }
 

src/masterMacsAxis.h

@@ -1,13 +1,9 @@
 #ifndef masterMacsAXIS_H
 #define masterMacsAXIS_H
+#include "masterMacsController.h"
 #include "sinqAxis.h"
 #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 masterMacsAxisImpl;
 
 class masterMacsAxis : public sinqAxis {
@@ -122,7 +118,10 @@ class masterMacsAxis : public sinqAxis {
      */
     void setNeedInit(bool needInit);
 
-    asynStatus readConfig();
+    /**
+     * @brief Return a pointer to the axis controller
+     */
+    virtual masterMacsController *pController() override { return pC_; };
 
     /**
      * @brief Read the Master MACS status with the xR10 command and store the

src/masterMacsController.cpp

@@ -136,7 +136,6 @@ asynStatus masterMacsController::writeRead(int axisNo, int tcpCmd,
 
     // Definition of local variables.
     asynStatus status = asynSuccess;
-    asynStatus pl_status = asynSuccess;
     char fullCommand[MAXBUF_] = {0};
     char fullResponse[MAXBUF_] = {0};
     char drvMessageText[MAXBUF_] = {0};
@@ -255,7 +254,7 @@ asynStatus masterMacsController::writeRead(int axisNo, int tcpCmd,
 
     // Log the overall status (communication successfull or not)
     if (status == asynSuccess) {
-        pl_status = axis->setIntegerParam(this->motorStatusCommsError_, 0);
+        setAxisParamChecked(axis, motorStatusCommsError, false);
     } else {
 
         /*
@@ -274,35 +273,12 @@ asynStatus masterMacsController::writeRead(int axisNo, int tcpCmd,
         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__);
-        }
+        getAxisParamChecked(axis, motorStatusProblem, &motorStatusProblem);
 
         if (motorStatusProblem == 0) {
-            pl_status =
-                axis->setStringParam(motorMessageText(), drvMessageText);
-            if (pl_status != asynSuccess) {
-                return paramLibAccessFailed(pl_status, "motorMessageText",
-                                            axisNo, __PRETTY_FUNCTION__,
-                                            __LINE__);
-            }
-
-            pl_status = axis->setIntegerParam(motorStatusProblem_, 1);
-            if (pl_status != asynSuccess) {
-                return paramLibAccessFailed(pl_status, "motorStatusProblem",
-                                            axisNo, __PRETTY_FUNCTION__,
-                                            __LINE__);
-            }
-
-            pl_status = axis->setIntegerParam(motorStatusProblem_, 1);
-            if (pl_status != asynSuccess) {
-                return paramLibAccessFailed(pl_status, "motorStatusCommsError_",
-                                            axisNo, __PRETTY_FUNCTION__,
-                                            __LINE__);
-            }
+            setAxisParamChecked(axis, motorMessageText, drvMessageText);
+            setAxisParamChecked(axis, motorStatusProblem, true);
+            setAxisParamChecked(axis, motorStatusCommsError, false);
         }
     }
 
@@ -332,13 +308,14 @@ asynStatus masterMacsController::parseResponse(
     msgPrintControlKey parseKey =
         msgPrintControlKey(portName, axisNo, __PRETTY_FUNCTION__, __LINE__);
 
-    // Was the motor previously connected?
-    status = getIntegerParam(axisNo, motorConnected(), &prevConnected);
-    if (status != asynSuccess) {
-        return paramLibAccessFailed(status, "motorConnected", axisNo,
-                                    __PRETTY_FUNCTION__, __LINE__);
+    masterMacsAxis *axis = getMasterMacsAxis(axisNo);
+    if (axis == nullptr) {
+        return asynError;
     }
 
+    // Was the motor previously connected?
+    getAxisParamChecked(axis, motorConnected, &prevConnected);
+
     // We don't use strlen here since the C string terminator 0x00
     // occurs in the middle of the char array.
     for (uint32_t i = 0; i < MAXBUF_; i++) {
@@ -361,16 +338,7 @@ asynStatus masterMacsController::parseResponse(
                           "connected.\n",
                           portName, axisNo, __PRETTY_FUNCTION__, __LINE__);
 
-                masterMacsAxis *axis = getMasterMacsAxis(axisNo);
-                if (axis == nullptr) {
-                    return asynError;
-                }
-                status = axis->setIntegerParam(motorConnected(), 1);
-                if (status != asynSuccess) {
-                    return paramLibAccessFailed(status, "motorConnected",
-                                                axisNo, __PRETTY_FUNCTION__,
-                                                __LINE__);
-                }
+                setAxisParamChecked(axis, motorConnected, true);
                 status = callParamCallbacks();
                 if (status != asynSuccess) {
                     asynPrint(this->pasynUserSelf, ASYN_TRACE_ERROR,
@@ -398,16 +366,7 @@ asynStatus masterMacsController::parseResponse(
                           "disconnected.\n",
                           portName, axisNo, __PRETTY_FUNCTION__, __LINE__);
 
-                masterMacsAxis *axis = getMasterMacsAxis(axisNo);
-                if (axis == nullptr) {
-                    return asynError;
-                }
-                status = axis->setIntegerParam(motorConnected(), 0);
-                if (status != asynSuccess) {
-                    return paramLibAccessFailed(status, "motorConnected",
-                                                axisNo, __PRETTY_FUNCTION__,
-                                                __LINE__);
-                }
+                setAxisParamChecked(axis, motorConnected, false);
                 status = callParamCallbacks();
                 if (status != asynSuccess) {
                     asynPrint(this->pasynUserSelf, ASYN_TRACE_ERROR,

src/masterMacsController.h

@@ -8,11 +8,15 @@
 
 #ifndef masterMacsController_H
 #define masterMacsController_H
-#include "masterMacsAxis.h"
 #include "sinqAxis.h"
 #include "sinqController.h"
 #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 masterMacsAxis;
+
 struct masterMacsControllerImpl;
 
 class masterMacsController : public sinqController {