Made forcedPoll non-virtual so it doesn't break the ABI

The poll method does various tasks. One of them is skipping the poll if
adaptive polling is enabled and certain conditions are fulfilled (see
docs). However, sometimes it is needed to force a poll regardless.
Therefore, a new method forcedPoll was added which is wrapped by poll
now and does all tasks of the previous poll function except for the skip
check.

.gitea/workflows/action.yaml

@@ -0,0 +1,23 @@
+name: Test And Build
+on: [push]
+
+jobs:
+  Lint:
+    runs-on: linepics
+    steps:
+      - name: checkout repo
+        uses: actions/checkout@v4
+      - name: cppcheck
+        run: cppcheck --std=c++17 --addon=cert --addon=misc --error-exitcode=1 src/*.cpp
+      - name: formatting
+        run: clang-format --style=file --Werror --dry-run src/*.cpp
+  Build:
+    runs-on: linepics
+    steps:
+      - name: checkout repo
+        uses: actions/checkout@v4
+        with:
+          submodules: 'true'
+      - run: |
+          sed -i 's/ARCH_FILTER=.*/ARCH_FILTER=linux%/' Makefile
+          make install

.gitlab-ci.yml

@@ -1,41 +0,0 @@
-default:
-  image: docker.psi.ch:5000/sinqdev/sinqepics:latest
-
-stages:
-  - lint
-  - build
-  - test
-
-cppcheck:
-  stage: lint
-  script:
-    - cppcheck --std=c++17 --addon=cert --addon=misc --error-exitcode=1 src/*.cpp
-  artifacts:
-    expire_in: 1 week
-  tags:
-    - sinq
-
-formatting:
-  stage: lint
-  script:
-    - clang-format --style=file --Werror --dry-run src/*.cpp
-  artifacts:
-    expire_in: 1 week
-  tags:
-    - sinq
-
-build_module:
-  stage: build
-  script:
-    - sed -i 's/ARCH_FILTER=.*/ARCH_FILTER=linux%/' Makefile
-    - echo "LIBVERSION=${CI_COMMIT_TAG:-0.0.1}" >> Makefile
-    - make install
-    - cp -rT "/ioc/modules/sinqMotor/$(ls -U /ioc/modules/sinqMotor/ | head -1)" "./sinqMotor-${CI_COMMIT_TAG:-$CI_COMMIT_SHORT_SHA}"
-  artifacts:
-    name: "sinqMotor-${CI_COMMIT_TAG:-$CI_COMMIT_SHORT_SHA}"
-    paths:
-      - "sinqMotor-${CI_COMMIT_TAG:-$CI_COMMIT_SHORT_SHA}/*"
-    expire_in: 1 week
-  when: always
-  tags:
-    - sinq

README.md

@@ -230,7 +230,15 @@ It calls `doReset` and performs some fast polls after `doReset` returns.
 - `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.
 - `doHome`: This is an empty function which should be overwritten by concrete driver implementations.
-- `poll`: This is a wrapper around `doPoll` which performs some bookkeeping tasks before and after calling `doPoll`:
+- `poll`: This is a wrapper around `forcedPoll` which does the following checks before calling `forcedPoll`:
+  - Are there any outstanding fast polls (method `outstandingForcedFastPolls` of the controller returns a value greater zero)?
+  - Was the axis moving last time its status was polled?
+  - Is adaptive polling disabled?
+  - Did an idle period pass since the last poll?
+If all of these conditions are false, no poll is performed. Otherwise, the `forcedPoll` method is called.
+This method should not be called in the driver code itself if a poll is needed - use `forcedPoll` instead!
+
+- `forcedPoll`: This is a wrapper around `doPoll` which performs some bookkeeping tasks before and after calling `doPoll`:
 
   Before calling `doPoll`:
   - Check if the paramLib already contains an old error message. If so, put it into a temporary bufffer
@@ -277,18 +285,28 @@ To use the library when writing a concrete motor driver, include it in the makef
 
 ### Usage as static dependency
 
-This repository is included as a git submodule in some of the driver repositories depending upon sinqMotor. When installing via a Makefile (`make install`) using the PSI build system, the following git command is executed within `/ioc/tools/driver.makefile`:
+This repository is included as a git submodule in the driver repositories depending upon sinqMotor. When installing via a Makefile (`make install`) using the PSI build system, the following git command is executed within `/ioc/tools/driver.makefile`:
 
 `git submodule update --init --recursive`
 
 This forces each submodule to be checked out at the latest commit hash stored in the remote repository. However, this is usually unwanted behaviour, since the higher-level drivers are usually designed to be compiled against a specific version of sinqMotor. In order to set the submodule to a specific version, the following steps need to be done BEFORE calling `make install`:
 
 - `cd sinqMotor`
-- `git checkout 0.1`
+- `git checkout 1.0`
 - `cd ..`
 
-Then, the fixation of the version to 0.1 needs to be committed in the parent repository:
+Then, the fixation of the version to 1.0 needs to be committed in the parent repository:
 
-- `git commit -m "Update sinqMotor to 0.1"`
+- `git commit -m "Update sinqMotor to 1.0"`
 
-After this commit, running `make install` will use the correct driver version for compilation.
+After this commit, running `make install` will use the correct driver version for compilation. 
+
+If your driver uses another driver as a static dependency via git submodule which in turn includes a sinqMotor submodule, it is not necessary to specify the version of sinqMotor. Instead, specify the desired commit of the direct dependency, commit this change and then update all submodules:
+
+- `cd turboPmac`
+- `git checkout 1.0`
+- `cd ..`
+- `git commit -m "Update turboPmac to 1.0"`
+- `git submodule update --init --recursive`
+
+This will update sinqMotor to the version specified in the 1.0 commit of turboPmac.

src/sinqAxis.cpp

@@ -10,6 +10,8 @@
 #include <math.h>
 #include <unistd.h>
 
+#define getControllerMethod pController
+
 struct sinqAxisImpl {
     // Internal variables used in the movement timeout watchdog
     time_t expectedArrivalTime;
@@ -28,178 +30,6 @@ struct sinqAxisImpl {
     epicsTimeStamp lastPollTime;
 };
 
-// Generic fallback - if the compiler tries to compile this function, it fails.
-template <typename T>
-asynStatus setAxisParam(sinqAxis *axis, const char *indexName,
-                        int (sinqController::*func)(), T writeValue,
-                        const char *callerFunctionName, int lineNumber) {
-    static_assert(
-        sizeof(T) == 0,
-        "no specialization of setAxisParam exists for the given type");
-    return asynError;
-}
-
-template <>
-asynStatus setAxisParam<int>(sinqAxis *axis, const char *indexName,
-                             int (sinqController::*func)(), int writeValue,
-                             const char *callerFunctionName, int lineNumber) {
-    int indexValue = (axis->pController()->*func)();
-    asynStatus status = axis->setIntegerParam(indexValue, writeValue);
-    if (status != asynSuccess) {
-        return axis->pController()->paramLibAccessFailed(
-            status, indexName, axis->axisNo(), callerFunctionName, lineNumber);
-    }
-    return asynSuccess;
-}
-
-template <>
-asynStatus setAxisParam<bool>(sinqAxis *axis, const char *indexName,
-                              int (sinqController::*func)(), bool writeValue,
-                              const char *callerFunctionName, int lineNumber) {
-    return setAxisParam(axis, indexName, func, static_cast<int>(writeValue),
-                        callerFunctionName, lineNumber);
-}
-
-template <>
-asynStatus
-setAxisParam<double>(sinqAxis *axis, const char *indexName,
-                     int (sinqController::*func)(), double writeValue,
-                     const char *callerFunctionName, int lineNumber) {
-    int indexValue = (axis->pController()->*func)();
-    asynStatus status = axis->setDoubleParam(indexValue, writeValue);
-    if (status != asynSuccess) {
-        return axis->pController()->paramLibAccessFailed(
-            status, indexName, axis->axisNo(), callerFunctionName, lineNumber);
-    }
-    return asynSuccess;
-}
-
-template <>
-asynStatus setAxisParam<char *>(sinqAxis *axis, const char *indexName,
-                                int (sinqController::*func)(), char *writeValue,
-                                const char *callerFunctionName,
-                                int lineNumber) {
-    int indexValue = (axis->pController()->*func)();
-    asynStatus status = axis->setStringParam(indexValue, writeValue);
-    if (status != asynSuccess) {
-        return axis->pController()->paramLibAccessFailed(
-            status, indexName, axis->axisNo(), callerFunctionName, lineNumber);
-    }
-    return asynSuccess;
-}
-
-template <>
-asynStatus setAxisParam<const char *>(sinqAxis *axis, const char *indexName,
-                                      int (sinqController::*func)(),
-                                      const char *writeValue,
-                                      const char *callerFunctionName,
-                                      int lineNumber) {
-    int indexValue = (axis->pController()->*func)();
-    asynStatus status = axis->setStringParam(indexValue, writeValue);
-    if (status != asynSuccess) {
-        return axis->pController()->paramLibAccessFailed(
-            status, indexName, axis->axisNo(), callerFunctionName, lineNumber);
-    }
-    return asynSuccess;
-}
-
-// Generic fallback - if the compiler tries to compile this function, it fails.
-template <typename T>
-asynStatus getAxisParam(sinqAxis *axis, const char *indexName,
-                        int (sinqController::*func)(), T *readValue,
-                        const char *callerFunctionName, int lineNumber) {
-    static_assert(
-        sizeof(T) == 0,
-        "no specialization of getAxisParam exists for the given type");
-    return asynError;
-}
-
-template <>
-asynStatus getAxisParam<int>(sinqAxis *axis, const char *indexName,
-                             int (sinqController::*func)(), int *readValue,
-                             const char *callerFunctionName, int lineNumber) {
-    int indexValue = (axis->pController()->*func)();
-    asynStatus status = axis->pController()->getIntegerParam(
-        axis->axisNo(), indexValue, readValue);
-    if (status != asynSuccess) {
-        return axis->pController()->paramLibAccessFailed(
-            status, indexName, axis->axisNo(), callerFunctionName, lineNumber);
-    }
-    return asynSuccess;
-}
-
-template <>
-asynStatus getAxisParam<bool>(sinqAxis *axis, const char *indexName,
-                              int (sinqController::*func)(), bool *readValue,
-                              const char *callerFunctionName, int lineNumber) {
-    return getAxisParam(axis, indexName, func, (int *)readValue,
-                        callerFunctionName, lineNumber);
-}
-
-template <>
-asynStatus
-getAxisParam<double>(sinqAxis *axis, const char *indexName,
-                     int (sinqController::*func)(), double *readValue,
-                     const char *callerFunctionName, int lineNumber) {
-    int indexValue = (axis->pController()->*func)();
-    asynStatus status = axis->pController()->getDoubleParam(
-        axis->axisNo(), indexValue, readValue);
-    if (status != asynSuccess) {
-        return axis->pController()->paramLibAccessFailed(
-            status, indexName, axis->axisNo(), callerFunctionName, lineNumber);
-    }
-    return asynSuccess;
-}
-
-template <>
-asynStatus getAxisParam<char>(sinqAxis *axis, const char *indexName,
-                              int (sinqController::*func)(), char *readValue,
-                              const char *callerFunctionName, int lineNumber) {
-
-    int maxChars = 200;
-
-    int indexValue = (axis->pController()->*func)();
-    asynStatus status = axis->pController()->getStringParam(
-        axis->axisNo(), indexValue, maxChars, readValue);
-    if (status != asynSuccess) {
-        return axis->pController()->paramLibAccessFailed(
-            status, indexName, axis->axisNo(), callerFunctionName, lineNumber);
-    }
-    return asynSuccess;
-}
-
-template <size_t N>
-asynStatus getAxisParam(sinqAxis *axis, const char *indexName,
-                        int (sinqController::*func)(), char (&readValue)[N],
-                        const char *callerFunctionName, int lineNumber) {
-    // Decay the array to char*
-    return getAxisParam<char>(axis, indexName, func,
-                              static_cast<char *>(readValue),
-                              callerFunctionName, lineNumber);
-}
-
-template <>
-asynStatus
-getAxisParam<std::string>(sinqAxis *axis, const char *indexName,
-                          int (sinqController::*func)(), std::string *readValue,
-                          const char *callerFunctionName, int lineNumber) {
-    int indexValue = (axis->pController()->*func)();
-
-    // Convert the pointer to a reference, since getStringParam expects the
-    // latter.
-    std::string &rReadValue = *readValue;
-
-    asynStatus status = axis->pController()->getStringParam(
-        axis->axisNo(), indexValue, rReadValue);
-    if (status != asynSuccess) {
-        return axis->pController()->paramLibAccessFailed(
-            status, indexName, axis->axisNo(), callerFunctionName, lineNumber);
-    }
-    return asynSuccess;
-}
-
-// =============================================================================
-
 sinqAxis::sinqAxis(class sinqController *pC, int axisNo)
     : asynMotorAxis((asynMotorController *)pC, axisNo), pC_(pC) {
     asynStatus status = asynSuccess;
@@ -341,14 +171,7 @@ sinqAxis::sinqAxis(class sinqController *pC, int axisNo)
 sinqAxis::~sinqAxis() = default;
 
 asynStatus sinqAxis::poll(bool *moving) {
-
-    // Local variable declaration
-    asynStatus pl_status = asynSuccess;
-    asynStatus poll_status = asynSuccess;
-    int homing = 0;
     int adaptivePolling = 0;
-    char waitingMessage[pC_->MAXBUF_] = {0};
-    char newMessage[pC_->MAXBUF_] = {0};
 
     /*
     If adaptive polling is enabled:
@@ -371,22 +194,33 @@ asynStatus sinqAxis::poll(bool *moving) {
     Check if both adaptive polling is enabled and no forced fast polls are still
     required.
      */
-    if (adaptivePolling != 0 && pC_->outstandingForcedFastPolls() == 0) {
-        // Motor wasn't moving during the last poll
-        if (!pSinqA_->wasMoving) {
+    if (adaptivePolling != 0 && pC_->outstandingForcedFastPolls() == 0 &&
+        !pSinqA_->wasMoving) {
 
-            // Add the idle poll period
-            epicsTimeStamp earliestTimeNextPoll = pSinqA_->lastPollTime;
-            epicsTimeAddSeconds(&earliestTimeNextPoll, pC_->idlePollPeriod());
+        // Add the idle poll period
+        epicsTimeStamp earliestTimeNextPoll = pSinqA_->lastPollTime;
+        epicsTimeAddSeconds(&earliestTimeNextPoll, pC_->idlePollPeriod());
 
-            if (epicsTimeLessThanEqual(&earliestTimeNextPoll, &ts) == 0) {
-                *moving = false;
-                return asynSuccess;
-            }
+        if (epicsTimeLessThanEqual(&earliestTimeNextPoll, &ts) == 0) {
+            *moving = false;
+            return asynSuccess;
         }
     }
+    return forcedPoll(moving);
+}
+
+asynStatus sinqAxis::forcedPoll(bool *moving) {
+
+    // Local variable declaration
+    asynStatus pl_status = asynSuccess;
+    asynStatus poll_status = asynSuccess;
+    int homing = 0;
+    char waitingMessage[pC_->MAXBUF_] = {0};
+    char newMessage[pC_->MAXBUF_] = {0};
 
     // Update the start time of the last poll
+    epicsTimeStamp ts;
+    epicsTimeGetCurrent(&ts);
     pSinqA_->lastPollTime = ts;
 
     /*

src/sinqAxis.h

@@ -31,6 +31,27 @@ class epicsShareClass sinqAxis : public asynMotorAxis {
      */
     ~sinqAxis();
 
+    /**
+     * @brief Check if a poll should be performed. If yes, call `forcedPoll`.
+     *
+    This is a wrapper around `forcedPoll` which does the following checks before
+    calling `forcedPoll`:
+    - Are there any outstanding fast polls (method `outstandingForcedFastPolls`
+    of the controller returns a value greater zero)?
+    - Was the axis moving last time its status was polled?
+    - Is adaptive polling disabled?
+    - Did an idle period pass since the last poll?
+    If all of these conditions are false, no poll is performed. Otherwise, the
+    `forcedPoll` method is called. This method should not be called in the
+    driver code itself if a poll is needed - use `forcedPoll` instead!
+    *
+    * @param moving              Forwarded to `forcedPoll` or set to false
+    (depending on whether `forcedPoll was called`).
+    * @return asynStatus         Forward the status of `forcedPoll` or set to
+    asynSuccess (depending on whether `forcedPoll was called`).
+     */
+    virtual asynStatus poll(bool *moving);
+
     /**
      * @brief Perform some standardized operations before and after the concrete
     `doPoll` implementation.
@@ -46,7 +67,7 @@ class epicsShareClass sinqAxis : public asynMotorAxis {
 
     - The flags `motorStatusHome_`, `motorStatusHomed_` and
     `motorStatusAtHome_` are set to their idle values (0, 1 and 1 respectively)
-    in the `poll()` method once the homing procedure is finished. See the
+    in the `forcedPoll()` method once the homing procedure is finished. See the
     documentation of the `home()` method for more details.
 
     - Run `callParamCallbacks()`
@@ -56,9 +77,9 @@ class epicsShareClass sinqAxis : public asynMotorAxis {
      * @param moving              Forwarded to `doPoll`.
      * @return asynStatus         Forward the status of `doPoll`, unless one of
     the parameter library operation fails (in that case, returns the status of
-    the failed operation.
+    the failed operation).
      */
-    virtual asynStatus poll(bool *moving);
+    asynStatus forcedPoll(bool *moving);
 
     /**
      * @brief Implementation of the "proper", device-specific poll method. This
@@ -142,7 +163,7 @@ class epicsShareClass sinqAxis : public asynMotorAxis {
      *
      * The flags `motorStatusHome_`, `motorStatusHomed_` and
     `motorStatusAtHome_` are set to their idle values (0, 1 and 1 respectively)
-    in the `poll()` method once the homing procedure is finished.
+    in the `forcedPoll())` method once the homing procedure is finished.
      *
      * @param minVelocity         Forwarded to `doHome`.
      * @param maxVelocity         Forwarded to `doHome`.
@@ -365,9 +386,22 @@ class epicsShareClass sinqAxis : public asynMotorAxis {
     asynStatus assertConnected();
 
     /**
-     * @brief Return a pointer to the axis controller
+     * @brief Return a pointer to the axis controller.
+     *
+     * This function should be overriden in derived classes using the `override`
+     * keyword so the macros `getAxisParamChecked` and `setAxisParamChecked`
+     * work correctly:
+     *
+     * ```
+     * class mySpecialAxis : public sinqAxis {
+        public:
+            mySpecialController* getControllerMethod() override {
+                return mySpecialControllerPtr;
+            }
+        };
+     * ```
      */
-    sinqController *pController() { return pC_; };
+    virtual sinqController *pController() { return pC_; };
 
     /**
      * @brief Returns true, if the axis was moving in the last poll cycle, and
@@ -407,6 +441,84 @@ class epicsShareClass sinqAxis : public asynMotorAxis {
 // =============================================================================
 // Helper functions and definitions for the macro setAxisParamChecked
 
+template <typename T> struct TypeTag {};
+
+// Generic fallback - if the compiler tries to compile this function, it fails.
+template <typename A, typename C, typename T>
+asynStatus setAxisParamImpl(A *axis, C *controller, const char *indexName,
+                            int (C::*func)(), T writeValue,
+                            const char *callerFunctionName, int lineNumber,
+                            TypeTag<void>) {
+    static_assert(sizeof(T) == 0, "Unsupported type for setAxisParamImpl");
+    return asynError;
+}
+
+template <typename A, typename C>
+asynStatus setAxisParamImpl(A *axis, C *controller, const char *indexName,
+                            int (C::*func)(), int writeValue,
+                            const char *callerFunctionName, int lineNumber,
+                            TypeTag<int>) {
+    int indexValue = (controller->*func)();
+    asynStatus status = axis->setIntegerParam(indexValue, writeValue);
+    if (status != asynSuccess) {
+        return controller->paramLibAccessFailed(
+            status, indexName, axis->axisNo(), callerFunctionName, lineNumber);
+    }
+    return asynSuccess;
+}
+
+template <typename A, typename C>
+asynStatus setAxisParamImpl(A *axis, C *controller, const char *indexName,
+                            int (C::*func)(), bool writeValue,
+                            const char *callerFunctionName, int lineNumber,
+                            TypeTag<bool>) {
+    return setAxisParamImpl(axis, controller, indexName, func,
+                            static_cast<int>(writeValue), callerFunctionName,
+                            lineNumber, TypeTag<int>{});
+}
+
+template <typename A, typename C>
+asynStatus setAxisParamImpl(A *axis, C *controller, const char *indexName,
+                            int (C::*func)(), double writeValue,
+                            const char *callerFunctionName, int lineNumber,
+                            TypeTag<double>) {
+    int indexValue = (controller->*func)();
+    asynStatus status = axis->setDoubleParam(indexValue, writeValue);
+    if (status != asynSuccess) {
+        return controller->paramLibAccessFailed(
+            status, indexName, axis->axisNo(), callerFunctionName, lineNumber);
+    }
+    return asynSuccess;
+}
+
+template <typename A, typename C>
+asynStatus setAxisParamImpl(A *axis, C *controller, const char *indexName,
+                            int (C::*func)(), char *writeValue,
+                            const char *callerFunctionName, int lineNumber,
+                            TypeTag<char *>) {
+    int indexValue = (controller->*func)();
+    asynStatus status = axis->setStringParam(indexValue, writeValue);
+    if (status != asynSuccess) {
+        return controller->paramLibAccessFailed(
+            status, indexName, axis->axisNo(), callerFunctionName, lineNumber);
+    }
+    return asynSuccess;
+}
+
+template <typename A, typename C>
+asynStatus setAxisParamImpl(A *axis, C *controller, const char *indexName,
+                            int (C::*func)(), const char *writeValue,
+                            const char *callerFunctionName, int lineNumber,
+                            TypeTag<const char *>) {
+    int indexValue = (controller->*func)();
+    asynStatus status = axis->setStringParam(indexValue, writeValue);
+    if (status != asynSuccess) {
+        return controller->paramLibAccessFailed(
+            status, indexName, axis->axisNo(), callerFunctionName, lineNumber);
+    }
+    return asynSuccess;
+}
+
 /**
  * @brief Helper function to set an integer / double / string parameter for an
  * axis in the paramLib
@@ -414,8 +526,11 @@ class epicsShareClass sinqAxis : public asynMotorAxis {
  * This function should not be used directly, but rather through its macro
  * variant `setAxisParamChecked`.
  *
+ * @tparam A
+ * @tparam C
  * @tparam T
  * @param axis
+ * @param controller
  * @param indexName
  * @param func
  * @param writeValue
@@ -423,10 +538,13 @@ class epicsShareClass sinqAxis : public asynMotorAxis {
  * @param lineNumber
  * @return asynStatus
  */
-template <typename T>
-asynStatus setAxisParam(sinqAxis *axis, const char *indexName,
-                        int (sinqController::*func)(), T writeValue,
-                        const char *callerFunctionName, int lineNumber);
+template <typename A, typename C, typename T>
+asynStatus setAxisParam(A *axis, C *controller, const char *indexName,
+                        int (C::*func)(), T writeValue,
+                        const char *callerFunctionName, int lineNumber) {
+    return setAxisParamImpl(axis, controller, indexName, func, writeValue,
+                            callerFunctionName, lineNumber, TypeTag<T>{});
+}
 
 /**
  * @brief Macro to set an paramLib parameter and error checking the return value
@@ -442,10 +560,10 @@ asynStatus setAxisParam(sinqAxis *axis, const char *indexName,
  * expands into the following code:
  * ```
  * {
- * int indexValue = axis->pController()->motorStatusProblem_();
+ * int indexValue = controller->motorStatusProblem_();
  * asynStatus status = axis->setIntegerParam(indexValue, writeValue);
  * if (status != asynSuccess) {
- *     return axis->pController()->paramLibAccessFailed(
+ *     return controller->paramLibAccessFailed(
  *         status, "motorStatusProblem_", axis->axisNo(), __PRETTY_FUNCTION__,
  *         __LINE__);
  * }
@@ -454,23 +572,116 @@ asynStatus setAxisParam(sinqAxis *axis, const char *indexName,
  * ```
  * =============================================================================
  */
-#define setAxisParamChecked(axis, indexGetterFunction, writeValue)             \
-    {                                                                          \
-        asynStatus setStatus = setAxisParam(                                   \
-            axis, #indexGetterFunction,                                        \
-            &std::remove_pointer<                                              \
-                decltype(axis->pController())>::type::indexGetterFunction,     \
-            writeValue, __PRETTY_FUNCTION__, __LINE__);                        \
-        if (setStatus != asynSuccess) {                                        \
+#define setAxisParamChecked(axis, indexSetterFunction, writeValue)             \
+    do {                                                                       \
+        auto *ctrlPtr = (axis)->pController();                                 \
+        using ControllerType =                                                 \
+            typename std::remove_pointer<decltype(ctrlPtr)>::type;             \
+        asynStatus setStatus =                                                 \
+            setAxisParam(axis, ctrlPtr, #indexSetterFunction,                  \
+                         static_cast<int (ControllerType::*)()>(               \
+                             &ControllerType::indexSetterFunction),            \
+                         writeValue, __PRETTY_FUNCTION__, __LINE__);           \
+        if (setStatus != asynSuccess)                                          \
             return setStatus;                                                  \
-        }                                                                      \
-    }
+    } while (0)
 
 // =============================================================================
 // Helper functions and definitions for the macro getAxisParamChecked
 
+// Generic fallback - if the compiler tries to compile this function, it fails.
+template <typename A, typename C, typename T>
+asynStatus getAxisParamImpl(A *axis, C *controller, const char *indexName,
+                            int (C::*func)(), T *readValue,
+                            const char *callerFunctionName, int lineNumber,
+                            size_t msgSize, TypeTag<void>) {
+    static_assert(
+        sizeof(T) == 0,
+        "no specialization of getAxisParam exists for the given type");
+    return asynError;
+}
+
+template <typename A, typename C>
+asynStatus getAxisParamImpl(A *axis, C *controller, const char *indexName,
+                            int (C::*func)(), int *readValue,
+                            const char *callerFunctionName, int lineNumber,
+                            size_t msgSize, TypeTag<int>) {
+    int indexValue = (controller->*func)();
+    asynStatus status =
+        controller->getIntegerParam(axis->axisNo(), indexValue, readValue);
+    if (status != asynSuccess) {
+        return controller->paramLibAccessFailed(
+            status, indexName, axis->axisNo(), callerFunctionName, lineNumber);
+    }
+    return asynSuccess;
+}
+
+template <typename A, typename C>
+asynStatus getAxisParamImpl(A *axis, C *controller, const char *indexName,
+                            int (C::*func)(), bool *readValue,
+                            const char *callerFunctionName, int lineNumber,
+                            size_t msgSize, TypeTag<bool>) {
+    int readValueInt = 0;
+    asynStatus status = getAxisParamImpl(axis, controller, indexName, func,
+                                         &readValueInt, callerFunctionName,
+                                         lineNumber, msgSize, TypeTag<int>{});
+    *readValue = readValueInt != 0;
+    return status;
+}
+
+template <typename A, typename C>
+asynStatus getAxisParamImpl(A *axis, C *controller, const char *indexName,
+                            int (C::*func)(), double *readValue,
+                            const char *callerFunctionName, int lineNumber,
+                            size_t msgSize, TypeTag<double>) {
+    int indexValue = (controller->*func)();
+    asynStatus status =
+        controller->getDoubleParam(axis->axisNo(), indexValue, readValue);
+    if (status != asynSuccess) {
+        return controller->paramLibAccessFailed(
+            status, indexName, axis->axisNo(), callerFunctionName, lineNumber);
+    }
+    return asynSuccess;
+}
+
+template <typename A, typename C>
+asynStatus getAxisParamImpl(A *axis, C *controller, const char *indexName,
+                            int (C::*func)(), char *readValue,
+                            const char *callerFunctionName, int lineNumber,
+                            size_t msgSize, TypeTag<char>) {
+
+    int indexValue = (controller->*func)();
+    asynStatus status = controller->getStringParam(axis->axisNo(), indexValue,
+                                                   msgSize, readValue);
+    if (status != asynSuccess) {
+        return controller->paramLibAccessFailed(
+            status, indexName, axis->axisNo(), callerFunctionName, lineNumber);
+    }
+    return asynSuccess;
+}
+
+template <typename A, typename C>
+asynStatus getAxisParamImpl(A *axis, C *controller, const char *indexName,
+                            int (C::*func)(), std::string *readValue,
+                            const char *callerFunctionName, int lineNumber,
+                            size_t msgSize, TypeTag<std::string>) {
+    int indexValue = (controller->*func)();
+
+    // Convert the pointer to a reference, since getStringParam expects the
+    // latter.
+    std::string &rReadValue = *readValue;
+
+    asynStatus status =
+        controller->getStringParam(axis->axisNo(), indexValue, rReadValue);
+    if (status != asynSuccess) {
+        return controller->paramLibAccessFailed(
+            status, indexName, axis->axisNo(), callerFunctionName, lineNumber);
+    }
+    return asynSuccess;
+}
+
 /**
- * @brief Helper function to set an integer / double / string parameter for an
+ * @brief Helper function to get an integer / double / string parameter for an
  * axis in the paramLib
  *
  * This function should not be used directly, but rather through its macro
@@ -478,6 +689,7 @@ asynStatus setAxisParam(sinqAxis *axis, const char *indexName,
  *
  * @tparam T
  * @param axis
+ * @param controller
  * @param indexName
  * @param func
  * @param readValue
@@ -488,17 +700,48 @@ asynStatus setAxisParam(sinqAxis *axis, const char *indexName,
  * to.
  * @return asynStatus
  */
-template <typename T>
-asynStatus getAxisParam(sinqAxis *axis, const char *indexName,
-                        int (sinqController::*func)(), T *readValue,
-                        const char *callerFunctionName, int lineNumber);
+template <typename A, typename C, typename T>
+asynStatus getAxisParam(A *axis, C *controller, const char *indexName,
+                        int (C::*func)(), T *readValue,
+                        const char *callerFunctionName, int lineNumber) {
+    return getAxisParamImpl(axis, controller, indexName, func, readValue,
+                            callerFunctionName, lineNumber,
+                            controller->msgSize(), TypeTag<T>{});
+}
+
+/**
+ * @brief Helper function to get a string parameter for an
+ * axis in the paramLib into a char array
+ *
+ * This function should not be used directly, but rather through its macro
+ * variant `getAxisParamChecked`. It is a specialized variant of the general
+ * getAxisParam defined above for char arrays.
+ *
+ * @tparam A
+ * @tparam C
+ * @tparam N
+ * @param axis
+ * @param controller
+ * @param indexName
+ * @param func
+ * @param callerFunctionName
+ * @param lineNumber
+ * @return asynStatus
+ */
+template <typename A, typename C, size_t N>
+asynStatus getAxisParam(A *axis, C *controller, const char *indexName,
+                        int (C::*func)(), char (*readValue)[N],
+                        const char *callerFunctionName, int lineNumber) {
+    return getAxisParamImpl(axis, controller, indexName, func, *readValue,
+                            callerFunctionName, lineNumber, N, TypeTag<char>{});
+}
 
 /**
  * @brief Macro to get an paramLib parameter and error checking the return value
  *
  * This macro is a wrapper around `getIntegerParam` / `getDoubleParam` /
  * `getStringParam` which checks if the operation was successfull. If it wasn't,
- * it returns by calling the paramLibAccessFailed function.
+ * it returns by calling the paramLibAccessFailed function. In order
  *
  * For example, the following input:
  * ```
@@ -507,10 +750,10 @@ asynStatus getAxisParam(sinqAxis *axis, const char *indexName,
  * expands into the following code:
  * ```
  * {
- * int indexValue = axis->pController()->motorStatusProblem_();
- * asynStatus status = axis->pController()->getIntegerParam(axis->axisNo(),
+ * int indexValue = controller->motorStatusProblem_();
+ * asynStatus status = controller->getIntegerParam(axis->axisNo(),
  * indexValue, readValue); if (status != asynSuccess) { return
- * axis->pController()->paramLibAccessFailed( status, "motorStatusProblem_",
+ * controller->paramLibAccessFailed( status, "motorStatusProblem_",
  * axis->axisNo(), __PRETTY_FUNCTION__,
  *         __LINE__);
  * }
@@ -520,15 +763,17 @@ asynStatus getAxisParam(sinqAxis *axis, const char *indexName,
  * =============================================================================
  */
 #define getAxisParamChecked(axis, indexGetterFunction, readValue)              \
-    {                                                                          \
-        asynStatus getStatus = getAxisParam(                                   \
-            axis, #indexGetterFunction,                                        \
-            &std::remove_pointer<                                              \
-                decltype(axis->pController())>::type::indexGetterFunction,     \
-            readValue, __PRETTY_FUNCTION__, __LINE__);                         \
-        if (getStatus != asynSuccess) {                                        \
+    do {                                                                       \
+        auto *ctrlPtr = (axis)->pController();                                 \
+        using ControllerType =                                                 \
+            typename std::remove_pointer<decltype(ctrlPtr)>::type;             \
+        asynStatus getStatus =                                                 \
+            getAxisParam(axis, ctrlPtr, #indexGetterFunction,                  \
+                         static_cast<int (ControllerType::*)()>(               \
+                             &ControllerType::indexGetterFunction),            \
+                         readValue, __PRETTY_FUNCTION__, __LINE__);            \
+        if (getStatus != asynSuccess)                                          \
             return getStatus;                                                  \
-        }                                                                      \
-    }
+    } while (0)
 
-#endif
+#endif

src/sinqController.h

@@ -380,9 +380,17 @@ class epicsShareClass sinqController : public asynMotorController {
      */
     int outstandingForcedFastPolls();
 
-    // Maximum error message buffer size. This is an empirical value which must
-    // be large enough to avoid overflows for all commands to the device /
-    // responses from it.
+    /**
+     * @brief Return the maximum error message buffer size
+     *
+     * This is an empirical value which must be large enough to avoid overflows
+     * for all commands to the device / responses from it.
+     *
+     * @return uint32_t
+     */
+    uint32_t msgSize() { return MAXBUF_; }
+
+    // Maximum message size
     static const uint32_t MAXBUF_ = 200;
 
     // =========================================================================