Fixed a bug in msgPrintControl

properties. This also enabled the removal of "friend classes".

README.md

@@ -171,7 +171,10 @@ sinqMotor offers a variety of additional methods for children classes to standar
 - `setMaxSubsequentTimeouts`: Set the limit for the number of subsequent timeouts before the user is informed.
 
 #### sinqAxis.h
-- `enable`: This function is called if the "Enable" PV from db/sinqMotor.db is set. This is an empty function which should be overwritten by concrete driver implementations.
+- `enable`: This function is called if the `$(INSTR)$(M):Enable` PV from db/sinqMotor.db is set. 
+This is an empty function which should be overwritten by concrete driver implementations.
+- `reset`: This function is called when the `$(INSTR)$(M):Reset` PV from db/sinqMotor.db is set. 
+This is an empty function which should be overwritten by concrete driver implementations.
 - `move`: This function sets the absolute target position in the parameter library and then calls `doMove`.
 - `doMove`: This is an empty function which should be overwritten by concrete driver implementations.
 - `home`: This function sets the internal status flags for the homing process and then calls doHome.
@@ -187,7 +190,6 @@ sinqMotor offers a variety of additional methods for children classes to standar
   - Reset `motorStatusProblem_`, `motorStatusCommsError_` and `motorMessageText_` if `doPoll` returned `asynSuccess`
   - Run `callParamCallbacks`
   - Return the status of `doPoll`
-- `doPoll`: This is an empty function which should be overwritten by concrete driver implementations.
 - `setVeloFields`: Populates the motor record fields VELO (actual velocity), VBAS (minimum allowed velocity) and VMAX (maximum allowed velocity) from the driver.
 - `setAcclField`: Populates the motor record field ACCL from the driver.
 - `startMovTimeoutWatchdog`: Starts a watchdog for the movement time. This watchdog compares the actual time spent in a movement operation with an expected time, which is calculated based on the distance of the current and the target position.

db/sinqMotor.db

@@ -41,11 +41,29 @@ record(motor,"$(INSTR)$(M)")
     field(RMOD,"3") # Retry mode 3 ("In-Position"): This suppresses any retries from the motor record.
 }
 
+# This PV reads out the 10th bit of the MSTA field of the motor record, which
+# is the "motorStatusProblem_" bit. The 10th bit is adressed by 0x0200. If the 
+# bit is 0, the .VAL field is 0 as well. If the bit is 1, we need to divide by 
+# 512 (=2^9) in order to set the .VAL field to 1 (and not to 512).
+record(calc, "$(INSTR)$(M):StatusProblem")
+{
+    field(INPA,  "$(INSTR)$(M).MSTA CP")
+    field(CALC, "(A&0x200)/512")
+}
+
+# Call the reset function of the corresponding sinqAxis
+# This record is coupled to the parameter library via motorReset_ -> MOTOR_RESET.
+record(longout, "$(INSTR)$(M):Reset") {
+    field(DTYP, "asynInt32")
+    field(OUT, "@asyn($(CONTROLLER),$(AXIS),1) MOTOR_RESET")
+    field(PINI, "NO")
+}
+
 # This PV allows force-stopping the motor record from within the driver by setting
 # the motorForceStop_ value in the parameter library to 1. It should be reset to 0 by the driver afterwards.
 # The implementation strategy is taken from https://epics.anl.gov/tech-talk/2022/msg00464.php.
 # This record is coupled to the parameter library via motorForceStop_ -> MOTOR_FORCE_STOP.
-record(longin, "$(INSTR)$(M):STOP_RBV")
+record(longin, "$(INSTR)$(M):StopRBV")
 {
     field(DTYP, "asynInt32")
     field(INP,  "@asyn($(CONTROLLER),$(AXIS)) MOTOR_FORCE_STOP")
@@ -53,7 +71,7 @@ record(longin, "$(INSTR)$(M):STOP_RBV")
     field(FLNK, "$(INSTR)$(M):Stop2Field")
 }
 record(longout, "$(INSTR)$(M):Stop2Field") {
-    field(DOL,  "$(INSTR)$(M):STOP_RBV CP")
+    field(DOL,  "$(INSTR)$(M):StopRBV CP")
     field(OUT,  "$(INSTR)$(M).STOP")
     field(OMSL, "closed_loop")
 }

src/msgPrintControl.cpp

@@ -69,13 +69,16 @@ bool msgPrintControl::shouldBePrinted(msgPrintControlKey &key, bool wantToPrint,
          */
         if (map_.find(key) != map_.end()) {
             if (map_[key] != 0) {
-                char formattedKey[100] = {0};
+                if (pasynUser != nullptr) {
-                key.format(formattedKey, sizeof(formattedKey));
+                    char formattedKey[100] = {0};
-                asynPrint(pasynUser, ASYN_TRACE_ERROR,
+                    key.format(formattedKey, sizeof(formattedKey));
-                          "Controller \"%s\", axis %d  => %s, line %d\nError "
+                    asynPrint(
-                          "associated with key \"%s\" has been resolved.\n",
+                        pasynUser, ASYN_TRACE_ERROR,
-                          key.controller_.c_str(), key.axisNo_,
+                        "Controller \"%s\", axis %d  => %s, line %d\nError "
-                          key.functionName_, key.line_, formattedKey);
+                        "associated with key \"%s\" has been resolved.\n",
+                        key.controller_.c_str(), key.axisNo_, key.functionName_,
+                        key.line_, formattedKey);
+                }
                 map_[key] = 0;
             }
         }
@@ -91,9 +94,20 @@ bool msgPrintControl::shouldBePrinted(char *portName, int axisNo,
     return shouldBePrinted(key, wantToPrint, pasynUser);
 }
 
-void msgPrintControl::resetCount(msgPrintControlKey &key) {
+void msgPrintControl::resetCount(msgPrintControlKey &key, asynUser *pasynUser) {
     if (map_.find(key) != map_.end()) {
-        map_[key] = 0;
+        if (map_[key] != 0) {
+            if (pasynUser != nullptr) {
+                char formattedKey[100] = {0};
+                key.format(formattedKey, sizeof(formattedKey));
+                asynPrint(pasynUser, ASYN_TRACE_ERROR,
+                          "Controller \"%s\", axis %d  => %s, line %d\nError "
+                          "associated with key \"%s\" has been resolved.\n",
+                          key.controller_.c_str(), key.axisNo_,
+                          key.functionName_, key.line_, formattedKey);
+            }
+            map_[key] = 0;
+        }
     }
 }
 

src/msgPrintControl.h

@@ -93,6 +93,9 @@ class msgPrintControl {
      * identify individual messages
      * @param wantToPrint       If the message associated with key should be
      * printed, this value should be true, otherwise false.
+     * @param pasynUser         If the problem has been resolved (wantToPrint =
+     * false), a corresponding status message is printed using the given
+     * asynUser. If this pointer is a nullptr, no message is printed.
      * @return bool             If true, the message should be printed, if
      * false, it should not.
      */
@@ -108,13 +111,22 @@ class msgPrintControl {
      * @param fileName
      * @param line
      * @param wantToPrint
-     * @return true
+     * @param pasynUser
-     * @return false
      */
     bool shouldBePrinted(char *controller, int axisNo, const char *functionName,
                          int line, bool wantToPrint, asynUser *pasynUser);
 
-    void resetCount(msgPrintControlKey &key);
+    /**
+     * @brief Reset the error message count incremented in shouldBePrinted for
+     * the given key
+     *
+     * @param key               Key associated with the message, used to
+     * identify individual messages
+     * @param pasynUser         If the problem has been resolved (wantToPrint =
+     * false), a corresponding status message is printed using the given
+     * asynUser. If this pointer is a nullptr, no message is printed.
+     */
+    void resetCount(msgPrintControlKey &key, asynUser *pasynUser);
 
     /**
      * @brief Maximum number of times a message is printed before it is
@@ -127,7 +139,7 @@ class msgPrintControl {
 
   private:
     std::unordered_map<msgPrintControlKey, size_t> map_;
-    char suffix_[200] = {0};
+    char suffix_[300] = {0};
 };
 
 #endif

src/sinqAxis.cpp

@@ -15,10 +15,23 @@ sinqAxis::sinqAxis(class sinqController *pC, int axisNo)
     offsetMovTimeout_ = 30;
     targetPosition_ = 0.0;
 
+    // This check is also done in asynMotorAxis, but there the IOC continues
+    // running even though the configuration is incorrect. When failing this
+    // check, the IOC is stopped, since this is definitely a configuration
+    // problem.
+    if ((axisNo < 0) || (axisNo >= pC->numAxes())) {
+        asynPrint(pC_->asynUserSelf(), ASYN_TRACE_ERROR,
+                  "Controller \"%s\", axis %d => %s, line %d:\nFATAL ERROR "
+                  "(axis index %d is not in range 0 to %d)\n. Terminating IOC",
+                  pC->portName, axisNo_, __PRETTY_FUNCTION__, __LINE__, axisNo,
+                  pC->numAxes() - 1);
+        exit(-1);
+    }
+
     // Motor is assumed to be enabled
-    status = setIntegerParam(pC_->motorEnableRBV_, 1);
+    status = setIntegerParam(pC_->motorEnableRBV(), 1);
     if (status != asynSuccess) {
-        asynPrint(pC_->pasynUserSelf, ASYN_TRACE_ERROR,
+        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",
@@ -28,9 +41,9 @@ sinqAxis::sinqAxis(class sinqController *pC, int axisNo)
     }
 
     // By default, motors cannot be disabled
-    status = setIntegerParam(pC_->motorCanDisable_, 0);
+    status = setIntegerParam(pC_->motorCanDisable(), 0);
     if (status != asynSuccess) {
-        asynPrint(pC_->pasynUserSelf, ASYN_TRACE_ERROR,
+        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",
@@ -40,9 +53,9 @@ sinqAxis::sinqAxis(class sinqController *pC, int axisNo)
     }
 
     // Provide a default value for the motor position.
-    status = setDoubleParam(pC_->motorPosition_, 0.0);
+    status = setDoubleParam(pC_->motorPosition(), 0.0);
     if (status != asynSuccess) {
-        asynPrint(pC_->pasynUserSelf, ASYN_TRACE_ERROR,
+        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",
@@ -52,9 +65,9 @@ sinqAxis::sinqAxis(class sinqController *pC, int axisNo)
     }
 
     // We assume that the motor has no status problems initially
-    status = setIntegerParam(pC_->motorStatusProblem_, 0);
+    status = setIntegerParam(pC_->motorStatusProblem(), 0);
     if (status != asynSuccess) {
-        asynPrint(pC_->pasynUserSelf, ASYN_TRACE_ERROR,
+        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",
@@ -64,9 +77,9 @@ sinqAxis::sinqAxis(class sinqController *pC, int axisNo)
     }
 
     // Set the homing-related flags
-    status = setIntegerParam(pC_->motorStatusHome_, 0);
+    status = setIntegerParam(pC_->motorStatusHome(), 0);
     if (status != asynSuccess) {
-        asynPrint(pC_->pasynUserSelf, ASYN_TRACE_ERROR,
+        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",
@@ -74,9 +87,9 @@ sinqAxis::sinqAxis(class sinqController *pC, int axisNo)
                   pC_->stringifyAsynStatus(status));
         exit(-1);
     }
-    status = setIntegerParam(pC_->motorStatusHomed_, 0);
+    status = setIntegerParam(pC_->motorStatusHomed(), 0);
     if (status != asynSuccess) {
-        asynPrint(pC_->pasynUserSelf, ASYN_TRACE_ERROR,
+        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",
@@ -84,9 +97,9 @@ sinqAxis::sinqAxis(class sinqController *pC, int axisNo)
                   pC_->stringifyAsynStatus(status));
         exit(-1);
     }
-    status = setIntegerParam(pC_->motorStatusAtHome_, 0);
+    status = setIntegerParam(pC_->motorStatusAtHome(), 0);
     if (status != asynSuccess) {
-        asynPrint(pC_->pasynUserSelf, ASYN_TRACE_ERROR,
+        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",
@@ -110,17 +123,17 @@ asynStatus sinqAxis::poll(bool *moving) {
 
     The motorStatusProblem_ field changes the motor record fields SEVR and STAT.
     */
-    pl_status = setIntegerParam(pC_->motorStatusProblem_, false);
+    pl_status = setIntegerParam(pC_->motorStatusProblem(), false);
     if (pl_status != asynSuccess) {
         pC_->paramLibAccessFailed(pl_status, "motorStatusProblem_", axisNo_,
                                   __PRETTY_FUNCTION__, __LINE__);
     }
-    pl_status = setIntegerParam(pC_->motorStatusCommsError_, false);
+    pl_status = setIntegerParam(pC_->motorStatusCommsError(), false);
     if (pl_status != asynSuccess) {
         pC_->paramLibAccessFailed(pl_status, "motorStatusCommsError_", axisNo_,
                                   __PRETTY_FUNCTION__, __LINE__);
     }
-    pl_status = setStringParam(pC_->motorMessageText_, "");
+    pl_status = setStringParam(pC_->motorMessageText(), "");
     if (pl_status != asynSuccess) {
         return pC_->paramLibAccessFailed(pl_status, "motorMessageText_",
                                          axisNo_, __PRETTY_FUNCTION__,
@@ -136,20 +149,20 @@ asynStatus sinqAxis::poll(bool *moving) {
     // The poll did not succeed: Something went wrong and the motor has a status
     // problem.
     if (poll_status != asynSuccess) {
-        pl_status = setIntegerParam(pC_->motorStatusProblem_, true);
+        pl_status = setIntegerParam(pC_->motorStatusProblem(), true);
         if (pl_status != asynSuccess) {
             pC_->paramLibAccessFailed(pl_status, "motorStatusProblem_", axisNo_,
                                       __PRETTY_FUNCTION__, __LINE__);
         }
     }
 
-    pl_status = pC_->getIntegerParam(axisNo_, pC_->motorStatusHomed_, &homed);
+    pl_status = pC_->getIntegerParam(axisNo_, pC_->motorStatusHomed(), &homed);
     if (pl_status != asynSuccess) {
         return pC_->paramLibAccessFailed(pl_status, "motorStatusHomed_",
                                          axisNo_, __PRETTY_FUNCTION__,
                                          __LINE__);
     }
-    pl_status = pC_->getIntegerParam(axisNo_, pC_->motorStatusHome_, &homing);
+    pl_status = pC_->getIntegerParam(axisNo_, pC_->motorStatusHome(), &homing);
     if (pl_status != asynSuccess) {
         return pC_->paramLibAccessFailed(pl_status, "motorStatusHome_", axisNo_,
                                          __PRETTY_FUNCTION__, __LINE__);
@@ -158,19 +171,19 @@ asynStatus sinqAxis::poll(bool *moving) {
     if (homing == 1 && !(*moving)) {
 
         // Set the homing-related flags
-        pl_status = setIntegerParam(pC_->motorStatusHome_, 0);
+        pl_status = setIntegerParam(pC_->motorStatusHome(), 0);
         if (pl_status != asynSuccess) {
             return pC_->paramLibAccessFailed(pl_status, "motorStatusHome_",
                                              axisNo_, __PRETTY_FUNCTION__,
                                              __LINE__);
         }
-        pl_status = setIntegerParam(pC_->motorStatusHomed_, 1);
+        pl_status = setIntegerParam(pC_->motorStatusHomed(), 1);
         if (pl_status != asynSuccess) {
             return pC_->paramLibAccessFailed(pl_status, "motorStatusHomed_",
                                              axisNo_, __PRETTY_FUNCTION__,
                                              __LINE__);
         }
-        pl_status = setIntegerParam(pC_->motorStatusAtHome_, 1);
+        pl_status = setIntegerParam(pC_->motorStatusAtHome(), 1);
         if (pl_status != asynSuccess) {
             return pC_->paramLibAccessFailed(pl_status, "motorStatusAtHome_",
                                              axisNo_, __PRETTY_FUNCTION__,
@@ -187,15 +200,15 @@ asynStatus sinqAxis::poll(bool *moving) {
     // function should be called at the end of a poll implementation.
     pl_status = callParamCallbacks();
     bool wantToPrint = pl_status != asynSuccess;
-    if (pC_->msgPrintControl_.shouldBePrinted(
+    if (pC_->getMsgPrintControl().shouldBePrinted(
             pC_->portName, axisNo_, __PRETTY_FUNCTION__, __LINE__, wantToPrint,
-            pC_->pasynUserSelf)) {
+            pC_->asynUserSelf())) {
-        asynPrint(pC_->pasynUserSelf, ASYN_TRACE_ERROR,
+        asynPrint(pC_->asynUserSelf(), ASYN_TRACE_ERROR,
                   "Controller \"%s\", axis %d => %s, line "
                   "%d:\ncallParamCallbacks failed with %s.%s\n",
                   pC_->portName, axisNo_, __PRETTY_FUNCTION__, __LINE__,
                   pC_->stringifyAsynStatus(poll_status),
-                  pC_->msgPrintControl_.getSuffix());
+                  pC_->getMsgPrintControl().getSuffix());
     }
     if (wantToPrint) {
         poll_status = pl_status;
@@ -216,19 +229,19 @@ asynStatus sinqAxis::move(double position, int relative, double minVelocity,
     // =========================================================================
 
     // When a new move is done, the motor is not homed anymore
-    pl_status = setIntegerParam(pC_->motorStatusHomed_, 0);
+    pl_status = setIntegerParam(pC_->motorStatusHomed(), 0);
     if (pl_status != asynSuccess) {
         return pC_->paramLibAccessFailed(pl_status, "motorStatusHomed_",
                                          axisNo_, __PRETTY_FUNCTION__,
                                          __LINE__);
     }
-    pl_status = setIntegerParam(pC_->motorStatusAtHome_, 0);
+    pl_status = setIntegerParam(pC_->motorStatusAtHome(), 0);
     if (pl_status != asynSuccess) {
         return pC_->paramLibAccessFailed(pl_status, "motorStatusAtHome_",
                                          axisNo_, __PRETTY_FUNCTION__,
                                          __LINE__);
     }
-    pl_status = pC_->getDoubleParam(axisNo_, pC_->motorRecResolution_,
+    pl_status = pC_->getDoubleParam(axisNo_, pC_->motorRecResolution(),
                                     &motorRecResolution);
     if (pl_status != asynSuccess) {
         return pC_->paramLibAccessFailed(pl_status, "motorRecResolution_",
@@ -256,7 +269,7 @@ asynStatus sinqAxis::home(double minVelocity, double maxVelocity,
 
     if (status == asynSuccess) {
 
-        status = setStringParam(pC_->motorMessageText_, "Homing");
+        status = setStringParam(pC_->motorMessageText(), "Homing");
         if (status != asynSuccess) {
             return pC_->paramLibAccessFailed(status, "motorMessageText_",
                                              axisNo_, __PRETTY_FUNCTION__,
@@ -264,19 +277,19 @@ asynStatus sinqAxis::home(double minVelocity, double maxVelocity,
         }
 
         // Set the homing-related flags
-        status = setIntegerParam(pC_->motorStatusHome_, 1);
+        status = setIntegerParam(pC_->motorStatusHome(), 1);
         if (status != asynSuccess) {
             return pC_->paramLibAccessFailed(status, "motorStatusHome_",
                                              axisNo_, __PRETTY_FUNCTION__,
                                              __LINE__);
         }
-        status = setIntegerParam(pC_->motorStatusHomed_, 0);
+        status = setIntegerParam(pC_->motorStatusHomed(), 0);
         if (status != asynSuccess) {
             return pC_->paramLibAccessFailed(status, "motorStatusHomed_",
                                              axisNo_, __PRETTY_FUNCTION__,
                                              __LINE__);
         }
-        status = setIntegerParam(pC_->motorStatusAtHome_, 0);
+        status = setIntegerParam(pC_->motorStatusAtHome(), 0);
         if (status != asynSuccess) {
             return pC_->paramLibAccessFailed(status, "motorStatusAtHome_",
                                              axisNo_, __PRETTY_FUNCTION__,
@@ -288,7 +301,7 @@ asynStatus sinqAxis::home(double minVelocity, double maxVelocity,
 
     } else if (status == asynError) {
         // asynError means that we tried to home an absolute encoder
-        status = setStringParam(pC_->motorMessageText_,
+        status = setStringParam(pC_->motorMessageText(),
                                 "Can't home a motor with absolute encoder");
         if (status != asynSuccess) {
             return pC_->paramLibAccessFailed(status, "motorMessageText_",
@@ -309,6 +322,8 @@ asynStatus sinqAxis::doHome(double minVelocity, double maxVelocity,
     return asynSuccess;
 }
 
+asynStatus sinqAxis::reset() { return asynSuccess; }
+
 asynStatus sinqAxis::enable(bool on) { return asynSuccess; }
 
 asynStatus sinqAxis::setVeloFields(double velo, double vbas, double vmax) {
@@ -317,7 +332,7 @@ asynStatus sinqAxis::setVeloFields(double velo, double vbas, double vmax) {
 
     // Can the speed of the motor be varied?
     status =
-        pC_->getIntegerParam(axisNo_, pC_->motorCanSetSpeed_, &variableSpeed);
+        pC_->getIntegerParam(axisNo_, pC_->motorCanSetSpeed(), &variableSpeed);
     if (status != asynSuccess) {
         return pC_->paramLibAccessFailed(status, "motorCanSetSpeed_", axisNo_,
                                          __PRETTY_FUNCTION__, __LINE__);
@@ -326,7 +341,7 @@ asynStatus sinqAxis::setVeloFields(double velo, double vbas, double vmax) {
 
         // Check the inputs and create corresponding error messages
         if (vbas > vmax) {
-            asynPrint(pC_->lowLevelPortUser_, ASYN_TRACE_ERROR,
+            asynPrint(pC_->asynUserSelf(), ASYN_TRACE_ERROR,
                       "Controller \"%s\", axis %d => %s, line %d:\nLower speed "
                       "limit vbas=%lf must not be smaller than upper limit "
                       "vmax=%lf.\n",
@@ -334,7 +349,7 @@ asynStatus sinqAxis::setVeloFields(double velo, double vbas, double vmax) {
                       vbas, vmax);
 
             status = setStringParam(
-                pC_->motorMessageText_,
+                pC_->motorMessageText(),
                 "Lower speed limit must not be smaller than upper speed limit");
             if (status != asynSuccess) {
                 return pC_->paramLibAccessFailed(status, "motorMessageText_",
@@ -344,14 +359,14 @@ asynStatus sinqAxis::setVeloFields(double velo, double vbas, double vmax) {
             return asynError;
         }
         if (velo < vbas || velo > vmax) {
-            asynPrint(pC_->lowLevelPortUser_, ASYN_TRACE_ERROR,
+            asynPrint(pC_->asynUserSelf(), ASYN_TRACE_ERROR,
                       "Controller \"%s\", axis %d => %s, line %d:\nActual "
                       "speed velo=%lf must be between lower limit vbas=%lf and "
                       "upper limit vmax=%lf.\n",
                       pC_->portName, axisNo_, __PRETTY_FUNCTION__, __LINE__,
                       velo, vbas, vmax);
 
-            status = setStringParam(pC_->motorMessageText_,
+            status = setStringParam(pC_->motorMessageText(),
                                     "Speed is not inside limits");
             if (status != asynSuccess) {
                 return pC_->paramLibAccessFailed(status, "motorMessageText_",
@@ -361,21 +376,21 @@ asynStatus sinqAxis::setVeloFields(double velo, double vbas, double vmax) {
             return asynError;
         }
 
-        status = pC_->setDoubleParam(axisNo_, pC_->motorVbasFromDriver_, vbas);
+        status = pC_->setDoubleParam(axisNo_, pC_->motorVbasFromDriver(), vbas);
         if (status != asynSuccess) {
             return pC_->paramLibAccessFailed(status, "motorVbasFromDriver_",
                                              axisNo_, __PRETTY_FUNCTION__,
                                              __LINE__);
         }
 
-        status = pC_->setDoubleParam(axisNo_, pC_->motorVeloFromDriver_, velo);
+        status = pC_->setDoubleParam(axisNo_, pC_->motorVeloFromDriver(), velo);
         if (status != asynSuccess) {
             return pC_->paramLibAccessFailed(status, "motorVeloFromDriver_",
                                              axisNo_, __PRETTY_FUNCTION__,
                                              __LINE__);
         }
 
-        status = pC_->setDoubleParam(axisNo_, pC_->motorVmaxFromDriver_, vmax);
+        status = pC_->setDoubleParam(axisNo_, pC_->motorVmaxFromDriver(), vmax);
         if (status != asynSuccess) {
             return pC_->paramLibAccessFailed(status, "motorVmaxFromDriver_",
                                              axisNo_, __PRETTY_FUNCTION__,
@@ -383,21 +398,21 @@ asynStatus sinqAxis::setVeloFields(double velo, double vbas, double vmax) {
         }
     } else {
         // Set minimum and maximum speed equal to the set speed
-        status = pC_->setDoubleParam(axisNo_, pC_->motorVbasFromDriver_, velo);
+        status = pC_->setDoubleParam(axisNo_, pC_->motorVbasFromDriver(), velo);
         if (status != asynSuccess) {
             return pC_->paramLibAccessFailed(status, "motorVbasFromDriver_",
                                              axisNo_, __PRETTY_FUNCTION__,
                                              __LINE__);
         }
 
-        status = pC_->setDoubleParam(axisNo_, pC_->motorVeloFromDriver_, velo);
+        status = pC_->setDoubleParam(axisNo_, pC_->motorVeloFromDriver(), velo);
         if (status != asynSuccess) {
             return pC_->paramLibAccessFailed(status, "motorVeloFromDriver_",
                                              axisNo_, __PRETTY_FUNCTION__,
                                              __LINE__);
         }
 
-        status = pC_->setDoubleParam(axisNo_, pC_->motorVmaxFromDriver_, velo);
+        status = pC_->setDoubleParam(axisNo_, pC_->motorVmaxFromDriver(), velo);
         if (status != asynSuccess) {
             return pC_->paramLibAccessFailed(status, "motorVmaxFromDriver_",
                                              axisNo_, __PRETTY_FUNCTION__,
@@ -413,7 +428,7 @@ asynStatus sinqAxis::setAcclField(double accl) {
         return asynError;
     }
 
-    asynStatus status = setDoubleParam(pC_->motorAcclFromDriver_, accl);
+    asynStatus status = setDoubleParam(pC_->motorAcclFromDriver(), accl);
     if (status != asynSuccess) {
         return pC_->paramLibAccessFailed(status, "motorAcclFromDriver_",
                                          axisNo_, __PRETTY_FUNCTION__,
@@ -423,14 +438,14 @@ asynStatus sinqAxis::setAcclField(double accl) {
 }
 
 asynStatus sinqAxis::setWatchdogEnabled(bool enable) {
-    return setIntegerParam(pC_->motorEnableMovWatchdog_, enable);
+    return setIntegerParam(pC_->motorEnableMovWatchdog(), enable);
 }
 
 asynStatus sinqAxis::startMovTimeoutWatchdog() {
     asynStatus pl_status;
     int enableMovWatchdog = 0;
 
-    pl_status = pC_->getIntegerParam(axisNo_, pC_->motorEnableMovWatchdog_,
+    pl_status = pC_->getIntegerParam(axisNo_, pC_->motorEnableMovWatchdog(),
                                      &enableMovWatchdog);
     if (pl_status != asynSuccess) {
         return pC_->paramLibAccessFailed(pl_status, "motorEnableMovWatchdog_",
@@ -458,7 +473,7 @@ asynStatus sinqAxis::startMovTimeoutWatchdog() {
         to save the read result to the member variable earlier), since the
         parameter library is updated at a later stage!
         */
-        pl_status = pC_->getDoubleParam(axisNo_, pC_->motorRecResolution_,
+        pl_status = pC_->getDoubleParam(axisNo_, pC_->motorRecResolution(),
                                         &motorRecResolution);
         if (pl_status != asynSuccess) {
             return pC_->paramLibAccessFailed(pl_status, "motorRecResolution_",
@@ -466,7 +481,7 @@ asynStatus sinqAxis::startMovTimeoutWatchdog() {
                                              __LINE__);
         }
 
-        pl_status = pC_->getDoubleParam(axisNo_, pC_->motorPosition_,
+        pl_status = pC_->getDoubleParam(axisNo_, pC_->motorPosition(),
                                         &motorPositionRec);
         if (pl_status != asynSuccess) {
             return pC_->paramLibAccessFailed(pl_status, "motorPosition",
@@ -490,7 +505,7 @@ asynStatus sinqAxis::startMovTimeoutWatchdog() {
          */
 
         // Read the velocity
-        pl_status = pC_->getDoubleParam(axisNo_, pC_->motorVelocity_,
+        pl_status = pC_->getDoubleParam(axisNo_, pC_->motorVelocity(),
                                         &motorVelocityRec);
 
         // Only calculate timeContSpeed if the motorVelocity has been populated
@@ -506,7 +521,7 @@ asynStatus sinqAxis::startMovTimeoutWatchdog() {
         }
 
         pl_status =
-            pC_->getDoubleParam(axisNo_, pC_->motorAccel_, &motorAccelRec);
+            pC_->getDoubleParam(axisNo_, pC_->motorAccel(), &motorAccelRec);
         if (pl_status == asynSuccess && motorVelocityRec > 0.0 &&
             motorAccelRec > 0.0) {
 
@@ -531,7 +546,7 @@ asynStatus sinqAxis::checkMovTimeoutWatchdog(bool moving) {
     asynStatus pl_status;
     int enableMovWatchdog = 0;
 
-    pl_status = pC_->getIntegerParam(axisNo_, pC_->motorEnableMovWatchdog_,
+    pl_status = pC_->getIntegerParam(axisNo_, pC_->motorEnableMovWatchdog(),
                                      &enableMovWatchdog);
     if (pl_status != asynSuccess) {
         return pC_->paramLibAccessFailed(pl_status, "motorEnableMovWatchdog_",
@@ -548,14 +563,14 @@ asynStatus sinqAxis::checkMovTimeoutWatchdog(bool moving) {
     // Check if the expected time of arrival has been exceeded.
     if (expectedArrivalTime_ < time(NULL)) {
         // Check the watchdog
-        asynPrint(pC_->pasynUserSelf, ASYN_TRACE_ERROR,
+        asynPrint(pC_->asynUserSelf(), ASYN_TRACE_ERROR,
                   "Controller \"%s\", axis %d => %s, line %d:\nExceeded "
                   "expected arrival time %ld (current time is %ld).\n",
                   pC_->portName, axisNo_, __PRETTY_FUNCTION__, __LINE__,
                   expectedArrivalTime_, time(NULL));
 
         pl_status = setStringParam(
-            pC_->motorMessageText_,
+            pC_->motorMessageText(),
             "Exceeded expected arrival time. Check if the axis is blocked.");
         if (pl_status != asynSuccess) {
             return pC_->paramLibAccessFailed(pl_status, "motorMessageText_",
@@ -563,7 +578,7 @@ asynStatus sinqAxis::checkMovTimeoutWatchdog(bool moving) {
                                              __LINE__);
         }
 
-        pl_status = setIntegerParam(pC_->motorStatusProblem_, true);
+        pl_status = setIntegerParam(pC_->motorStatusProblem(), true);
         if (pl_status != asynSuccess) {
             pC_->paramLibAccessFailed(pl_status, "motorStatusProblem_", axisNo_,
                                       __PRETTY_FUNCTION__, __LINE__);
@@ -697,9 +712,9 @@ asynStatus setScaleMovTimeout(const char *portName, int axisNo,
     sinqAxis *axis = dynamic_cast<sinqAxis *>(asynAxis);
     if (axis == nullptr) {
         errlogPrintf("Controller \"%s\" => %s, line %d:\nAxis %d does not "
-                     "exist or is not an "
+                     "exist or is not an instance of sinqAxis.",
-                     "instance of sinqAxis.",
                      portName, __PRETTY_FUNCTION__, __LINE__, axisNo);
+        return asynError;
     }
 
     return axis->setScaleMovTimeout(scaleMovTimeout);

src/sinqAxis.h

@@ -160,10 +160,23 @@ class epicsShareClass sinqAxis : public asynMotorAxis {
     virtual asynStatus doHome(double minVelocity, double maxVelocity,
                               double acceleration, int forwards);
 
+    /**
+     * @brief This function is called when the PV "$(INSTR)$(M):Reset" is set to
+     * any value. This method should be implemented by a child class of
+     * sinqAxis.
+     *
+     * @return asynStatus
+     */
+    virtual asynStatus reset();
+
     /**
      * @brief This function enables / disables an axis. It should be implemented
      * by a child class of sinqAxis.
      *
+     * The concrete implementation should (but doesn't need to) follow the
+     * convetion that a value of 0 disables the axis and any other value enables
+     * it.
+     *
      * @param on
      * @return asynStatus
      */
@@ -291,7 +304,12 @@ class epicsShareClass sinqAxis : public asynMotorAxis {
         return asynSuccess;
     }
 
-    friend class sinqController;
+    /**
+     * @brief Return the axis number of this axis
+     *
+     * @return int
+     */
+    int axisNo() { return axisNo_; }
 
   protected:
     // Internal variables used in the movement timeout watchdog

src/sinqController.cpp

@@ -51,7 +51,7 @@ sinqController::sinqController(const char *portName,
       msgPrintControl_(4) {
 
     asynStatus status = asynSuccess;
-    lowLevelPortUser_ = nullptr;
+    ipPortUser_ = nullptr;
 
     // Initial values for the average timeout mechanism, can be overwritten
     // later by a FFI function
@@ -74,8 +74,8 @@ sinqController::sinqController(const char *portName,
     We try to connect to the port via the port name provided by the constructor.
     If this fails, the function is terminated via exit.
     */
-    pasynOctetSyncIO->connect(ipPortConfigName, 0, &lowLevelPortUser_, NULL);
+    pasynOctetSyncIO->connect(ipPortConfigName, 0, &ipPortUser_, NULL);
-    if (status != asynSuccess || lowLevelPortUser_ == nullptr) {
+    if (status != asynSuccess || ipPortUser_ == nullptr) {
         errlogPrintf("Controller \"%s\" => %s, line %d:\nFATAL ERROR (cannot "
                      "connect to MCU controller).\n"
                      "Terminating IOC",
@@ -109,6 +109,16 @@ sinqController::sinqController(const char *portName,
         exit(-1);
     }
 
+    status = createParam("MOTOR_RESET", asynParamInt32, &motorReset_);
+    if (status != asynSuccess) {
+        asynPrint(this->pasynUserSelf, ASYN_TRACE_ERROR,
+                  "Controller \"%s\" => %s, line %d:\nFATAL ERROR (creating a "
+                  "parameter failed with %s).\nTerminating IOC",
+                  portName, __PRETTY_FUNCTION__, __LINE__,
+                  stringifyAsynStatus(status));
+        exit(-1);
+    }
+
     status = createParam("MOTOR_ENABLE_RBV", asynParamInt32, &motorEnableRBV_);
     if (status != asynSuccess) {
         asynPrint(this->pasynUserSelf, ASYN_TRACE_ERROR,
@@ -264,9 +274,15 @@ sinqController::sinqController(const char *portName,
 }
 
 sinqController::~sinqController(void) {
-    /*
+
-    Cleanup of the memory allocated in the asynMotorController constructor
+    // Free all axes
-    */
+    for (int axisNo = 0; axisNo < numAxes_; axisNo++) {
+        if (pAxes_[axisNo] != nullptr) {
+            delete pAxes_[axisNo];
+        }
+    }
+
+    // Cleanup of the array allocated in the asynMotorController constructor
     free(this->pAxes_);
 }
 
@@ -286,13 +302,15 @@ asynStatus sinqController::writeInt32(asynUser *pasynUser, epicsInt32 value) {
         asynPrint(this->pasynUserSelf, ASYN_TRACE_ERROR,
                   "Controller \"%s\", axis %d => %s, line %d:\nAxis is not an "
                   "instance of sinqAxis",
-                  portName, axis->axisNo_, __PRETTY_FUNCTION__, __LINE__);
+                  portName, axis->axisNo(), __PRETTY_FUNCTION__, __LINE__);
         return asynError;
     }
 
     // Handle custom PVs
     if (function == motorEnable_) {
         return axis->enable(value != 0);
+    } else if (function == motorReset_) {
+        return axis->reset();
     } else if (function == motorForceStop_) {
         return axis->stop(0.0);
     } else {
@@ -302,7 +320,7 @@ asynStatus sinqController::writeInt32(asynUser *pasynUser, epicsInt32 value) {
 
 asynStatus sinqController::readInt32(asynUser *pasynUser, epicsInt32 *value) {
 
-    // Casting into a sinqAxis is necessary to get access to the field axisNo_
+    // Casting into a sinqAxis is necessary to get access to the field axisNo()
     asynMotorAxis *asynAxis = getAxis(pasynUser);
     sinqAxis *axis = dynamic_cast<sinqAxis *>(asynAxis);
 
@@ -310,14 +328,14 @@ asynStatus sinqController::readInt32(asynUser *pasynUser, epicsInt32 *value) {
         asynPrint(this->pasynUserSelf, ASYN_TRACE_ERROR,
                   "Controller \"%s\", axis %d => %s, line %d:\nAxis is not an "
                   "instance of sinqAxis.\n",
-                  portName, axis->axisNo_, __PRETTY_FUNCTION__, __LINE__);
+                  portName, axis->axisNo(), __PRETTY_FUNCTION__, __LINE__);
         return asynError;
     }
 
     if (pasynUser->reason == motorEnableRBV_) {
-        return getIntegerParam(axis->axisNo_, motorEnableRBV_, value);
+        return getIntegerParam(axis->axisNo(), motorEnableRBV_, value);
     } else if (pasynUser->reason == motorCanDisable_) {
-        return getIntegerParam(axis->axisNo_, motorCanDisable_, value);
+        return getIntegerParam(axis->axisNo(), motorCanDisable_, value);
     } else {
         return asynMotorController::readInt32(pasynUser, value);
     }
@@ -330,7 +348,7 @@ asynStatus sinqController::errMsgCouldNotParseResponse(const char *command,
                                                        int line) {
     asynStatus pl_status = asynSuccess;
 
-    asynPrint(lowLevelPortUser_, ASYN_TRACE_ERROR,
+    asynPrint(ipPortUser_, ASYN_TRACE_ERROR,
               "Controller \"%s\", axis %d => %s, line %d:\nCould not interpret "
               "response \"%s\" for command \"%s\".\n",
               portName, axisNo, functionName, line, response, command);
@@ -359,7 +377,7 @@ asynStatus sinqController::paramLibAccessFailed(asynStatus status,
                                                 int line) {
 
     if (status != asynSuccess) {
-        asynPrint(lowLevelPortUser_, ASYN_TRACE_ERROR,
+        asynPrint(ipPortUser_, ASYN_TRACE_ERROR,
                   "Controller \"%s\", axis %d => %s, line %d:\n Accessing the "
                   "parameter library failed for parameter %s with error %s.\n",
                   portName, axisNo, functionName, line, parameter,
@@ -434,12 +452,12 @@ asynStatus sinqController::checkComTimeoutWatchdog(sinqAxis *axis) {
     char motorMessage[200] = {0};
 
     asynStatus status =
-        checkComTimeoutWatchdog(axis->axisNo_, motorMessage, 200);
+        checkComTimeoutWatchdog(axis->axisNo(), motorMessage, 200);
     if (status == asynError) {
         status = axis->setStringParam(motorMessageText_, motorMessage);
         if (status != asynSuccess) {
             return paramLibAccessFailed(status, "motorMessageText_",
-                                        axis->axisNo_, __PRETTY_FUNCTION__,
+                                        axis->axisNo(), __PRETTY_FUNCTION__,
                                         __LINE__);
         }
     }
@@ -486,13 +504,13 @@ asynStatus sinqController::checkMaxSubsequentTimeouts(int timeoutNo,
 
     char motorMessage[200] = {0};
 
-    asynStatus status =
+    asynStatus status = checkMaxSubsequentTimeouts(axis->axisNo(), timeoutNo,
-        checkMaxSubsequentTimeouts(axis->axisNo_, timeoutNo, motorMessage, 200);
+                                                   motorMessage, 200);
     if (status == asynError) {
         status = axis->setStringParam(motorMessageText_, motorMessage);
         if (status != asynSuccess) {
             return paramLibAccessFailed(status, "motorMessageText_",
-                                        axis->axisNo_, __PRETTY_FUNCTION__,
+                                        axis->axisNo(), __PRETTY_FUNCTION__,
                                         __LINE__);
         }
     }
@@ -628,9 +646,9 @@ asynStatus setMaxSubsequentTimeouts(const char *portName,
     if (ptr == nullptr) {
         /*
         We can't use asynPrint here since this macro would require us
-        to get a lowLevelPortUser_ from a pointer to an asynPortDriver.
+        to get a ipPortUser_ from a pointer to an asynPortDriver.
         However, the given pointer is a nullptr and therefore doesn't
-        have a lowLevelPortUser_! printf is an EPICS alternative which
+        have a ipPortUser_! printf is an EPICS alternative which
         works w/o that, but doesn't offer the comfort provided
         by the asynTrace-facility
         */

src/sinqController.h

@@ -218,15 +218,92 @@ class epicsShareClass sinqController : public asynMotorController {
      * @brief Get a reference to the map used to control the maximum number of
      * message repetitions. See the documentation of printRepetitionWatchdog in
      * msgPrintControl.h for details.
-     *
-     * @return std::unordered_map<msgPrintControlKey, size_t>&
      */
     msgPrintControl &getMsgPrintControl();
 
-    friend class sinqAxis;
+    // =========================================================================
+    // Public getters for protected members
+
+    // Accessors for double parameters
+    int motorMoveRel() { return motorMoveRel_; }
+    int motorMoveAbs() { return motorMoveAbs_; }
+    int motorMoveVel() { return motorMoveVel_; }
+    int motorHome() { return motorHome_; }
+    int motorStop() { return motorStop_; }
+    int motorVelocity() { return motorVelocity_; }
+    int motorVelBase() { return motorVelBase_; }
+    int motorAccel() { return motorAccel_; }
+    int motorPosition() { return motorPosition_; }
+    int motorEncoderPosition() { return motorEncoderPosition_; }
+    int motorDeferMoves() { return motorDeferMoves_; }
+    int motorMoveToHome() { return motorMoveToHome_; }
+    int motorResolution() { return motorResolution_; }
+    int motorEncoderRatio() { return motorEncoderRatio_; }
+    int motorPGain() { return motorPGain_; }
+    int motorIGain() { return motorIGain_; }
+    int motorDGain() { return motorDGain_; }
+    int motorHighLimit() { return motorHighLimit_; }
+    int motorLowLimit() { return motorLowLimit_; }
+    int motorClosedLoop() { return motorClosedLoop_; }
+    int motorPowerAutoOnOff() { return motorPowerAutoOnOff_; }
+    int motorPowerOnDelay() { return motorPowerOnDelay_; }
+    int motorPowerOffDelay() { return motorPowerOffDelay_; }
+    int motorPowerOffFraction() { return motorPowerOffFraction_; }
+    int motorPostMoveDelay() { return motorPostMoveDelay_; }
+    int motorStatus() { return motorStatus_; }
+    int motorUpdateStatus() { return motorUpdateStatus_; }
+
+    // Accessors for sztatus bits (integers)
+    int motorStatusDirection() { return motorStatusDirection_; }
+    int motorStatusDone() { return motorStatusDone_; }
+    int motorStatusHighLimit() { return motorStatusHighLimit_; }
+    int motorStatusAtHome() { return motorStatusAtHome_; }
+    int motorStatusSlip() { return motorStatusSlip_; }
+    int motorStatusPowerOn() { return motorStatusPowerOn_; }
+    int motorStatusFollowingError() { return motorStatusFollowingError_; }
+    int motorStatusHome() { return motorStatusHome_; }
+    int motorStatusHasEncoder() { return motorStatusHasEncoder_; }
+    int motorStatusProblem() { return motorStatusProblem_; }
+    int motorStatusMoving() { return motorStatusMoving_; }
+    int motorStatusGainSupport() { return motorStatusGainSupport_; }
+    int motorStatusCommsError() { return motorStatusCommsError_; }
+    int motorStatusLowLimit() { return motorStatusLowLimit_; }
+    int motorStatusHomed() { return motorStatusHomed_; }
+
+    // Parameters for passing additional motor record information to the driver
+    int motorRecResolution() { return motorRecResolution_; }
+    int motorRecDirection() { return motorRecDirection_; }
+    int motorRecOffset() { return motorRecOffset_; }
+
+    // Accessors for additional PVs defined in sinqController
+    int motorMessageText() { return motorMessageText_; }
+    int motorReset() { return motorReset_; }
+    int motorEnable() { return motorEnable_; }
+    int motorEnableRBV() { return motorEnableRBV_; }
+    int motorCanDisable() { return motorCanDisable_; }
+    int motorEnableMovWatchdog() { return motorEnableMovWatchdog_; }
+    int motorCanSetSpeed() { return motorCanSetSpeed_; }
+    int motorLimitsOffset() { return motorLimitsOffset_; }
+    int motorForceStop() { return motorForceStop_; }
+    int motorVeloFromDriver() { return motorVeloFromDriver_; }
+    int motorVbasFromDriver() { return motorVbasFromDriver_; }
+    int motorVmaxFromDriver() { return motorVmaxFromDriver_; }
+    int motorAcclFromDriver() { return motorAcclFromDriver_; }
+    int motorHighLimitFromDriver() { return motorHighLimitFromDriver_; }
+    int motorLowLimitFromDriver() { return motorLowLimitFromDriver_; }
+    int encoderType() { return encoderType_; }
+
+    // Additional members
+    int numAxes() { return numAxes_; }
+    asynUser *asynUserSelf() { return pasynUserSelf; }
+    asynUser *ipPortUser() { return ipPortUser_; }
+
+    // =========================================================================
 
   protected:
-    asynUser *lowLevelPortUser_;
+    // Pointer to the port user which is specified by the char array
+    // ipPortConfigName in the constructor
+    asynUser *ipPortUser_;
     double movingPollPeriod_;
     double idlePollPeriod_;
     msgPrintControl msgPrintControl_;
@@ -245,6 +322,7 @@ class epicsShareClass sinqController : public asynMotorController {
 
 #define FIRST_SINQMOTOR_PARAM motorMessageText_
     int motorMessageText_;
+    int motorReset_;
     int motorEnable_;
     int motorEnableRBV_;
     int motorCanDisable_;