Moved version definition in Makefile

The expected version can now be set in the Makefile via USR_CXXFLAGS.
Additionally, the README.md has received documentation regarding the
version check. Lastly, the version check can now be disabled by omitting
the flags or setting one of them to a negative value.

.gitea/workflows/action.yaml

@@ -0,0 +1,24 @@
+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
+          echo -e "\nIGNORE_SUBMODULES += sinqmotor" >> Makefile
+          make install

.gitlab-ci.yml

@@ -1,48 +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 --suppress=cert-STR07-C --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:
-    - export SINQMOTOR_VERSION="$(grep 'sinqMotor_VERSION=' Makefile | cut -d= -f2)"
-    - git clone --depth 1 --branch "${SINQMOTOR_VERSION}" https://gitlab-ci-token:${CI_JOB_TOKEN}@git.psi.ch/sinq-epics-modules/sinqmotor.git
-    - pushd sinqmotor
-    - sed -i 's/ARCH_FILTER=.*/ARCH_FILTER=linux%/' Makefile
-    - echo "LIBVERSION=${SINQMOTOR_VERSION}" >> Makefile
-    - make install
-    - popd
-    - sed -i 's/ARCH_FILTER=.*/ARCH_FILTER=linux%/' Makefile
-    - echo "LIBVERSION=${CI_COMMIT_TAG:-0.0.1}" >> Makefile
-    - make install
-    - cp -rT "/ioc/modules/masterMacs/$(ls -U /ioc/modules/masterMacs/ | head -1)" "./masterMacs-${CI_COMMIT_TAG:-$CI_COMMIT_SHORT_SHA}"
-  artifacts:
-    name: "masterMacs-${CI_COMMIT_TAG:-$CI_COMMIT_SHORT_SHA}"
-    paths:
-      - "masterMacs-${CI_COMMIT_TAG:-$CI_COMMIT_SHORT_SHA}/*"
-    expire_in: 1 week
-  when: always
-  tags:
-    - sinq

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
@@ -23,9 +23,14 @@ SOURCES += src/masterMacsController.cpp
 # Store the record files
 TEMPLATES += sinqMotor/db/asynRecord.db
 TEMPLATES += sinqMotor/db/sinqMotor.db
+TEMPLATES += db/masterMacs.db
 
 # This file registers the motor-specific functions in the IOC shell.
 DBDS += sinqMotor/src/sinqMotor.dbd
 DBDS += src/masterMacs.dbd
 
 USR_CFLAGS += -Wall -Wextra -Weffc++ -Wunused-result -Wextra -Werror
+
+# These flags define the expected firmware version. See README.md, section
+# "Firmware version checking" for details.
+USR_CXXFLAGS += -DFIRMWARE_MAJOR_VERSION=2 -DFIRMWARE_MINOR_VERSION=2

README.md

@@ -55,17 +55,43 @@ setMaxSubsequentTimeouts("$(NAME)", 20);
 setThresholdComTimeout("$(NAME)", 100, 1);
 
 # Parametrize the EPICS record database with the substitution file named after the MCU.
-epicsEnvSet("SINQDBPATH","$(sinqMotor_DB)/sinqMotor.db")
+epicsEnvSet("SINQDBPATH","$(masterMacs_DB)/sinqMotor.db")
 dbLoadTemplate("$(TOP)/$(NAME).substitutions", "INSTR=$(INSTR)$(NAME):,CONTROLLER=$(NAME)")
 epicsEnvSet("SINQDBPATH","$(masterMacs_DB)/masterMacs.db")
 dbLoadTemplate("$(TOP)/$(NAME).substitutions", "INSTR=$(INSTR)$(NAME):,CONTROLLER=$(NAME)")
-dbLoadRecords("$(sinqMotor_DB)/asynRecord.db","P=$(INSTR)$(NAME),PORT=$(ASYN_PORT)")
+dbLoadRecords("$(masterMacs_DB)/asynRecord.db","P=$(INSTR)$(NAME),PORT=$(ASYN_PORT)")
 ```
 
 ### Versioning
 
 Please see the documentation for the module sinqMotor: https://git.psi.ch/sinq-epics-modules/sinqmotor/-/blob/main/README.md.
 
+### Firmware version checking
+
+This driver expects a certain version of the firmware running on the controller itself.
+This is checked at IOC startup by reading the version directly from the hardware.
+If the firmware version is incompatible to the driver, the IOC will be shut down.
+If the firmware version cannot be read (e.g. because the variable used to do so
+does not exist yet on old firmware versions), the firmware is assumed to be compatible
+to the driver.
+
+The version check is separated into a check of the major and the minor firmware
+version against expected values. The firmware is seen as compatible if the following conditions hold:
+- Read-out major version == Expected major version
+- Read-out read major version >= Expected minor version
+
+The expected versions are defined via compiler flags in `Makefile`:
+
+```
+USR_CXXFLAGS += -DFIRMWARE_MAJOR_VERSION=1 -DFIRMWARE_MINOR_VERSION=0
+```
+Be aware that these flags are only used to compile C++-files (.cpp, .cxx) and not
+C-files (.c). For C-files, the Makefile variable `USR_CFLAGS` must be used.
+
+In order to disable the checks, the flags can be set to -1 or just be removed
+entirely. If one of the flags is not given, both the major and the minor version 
+checks are deactivated.
+
 ### How to build it
 
 Please see the documentation for the module sinqMotor: https://git.psi.ch/sinq-epics-modules/sinqmotor/-/blob/main/README.md.

db/masterMacs.db

@@ -0,0 +1,7 @@
+# Call the nodeReset function of the corresponding masterMacsAxis.
+# This record is coupled to the parameter library via nodeReset_ -> NODE_RESET.
+record(longout, "$(INSTR)$(M):NodeReset") {
+    field(DTYP, "asynInt32")
+    field(OUT, "@asyn($(CONTROLLER),$(AXIS),1) NODE_RESET")
+    field(PINI, "NO")
+}

src/masterMacsAxis.cpp

@@ -19,7 +19,6 @@ struct masterMacsAxisImpl {
     std::bitset<16> axisStatus;
     std::bitset<16> axisError;
 
-    double lastSetSpeed;
     bool waitForHandshake;
     time_t timeAtHandshake;
     bool needInit = true;
@@ -122,7 +121,6 @@ masterMacsAxis::masterMacsAxis(masterMacsController *pC, int axisNo)
     pMasterMacsA_ = std::make_unique<masterMacsAxisImpl>((masterMacsAxisImpl){
         .axisStatus = std::bitset<16>(0),
         .axisError = std::bitset<16>(0),
-        .lastSetSpeed = 0.0,
         .waitForHandshake = false,
         .timeAtHandshake = 0,
         .targetReachedUninitialized = true,
@@ -262,11 +260,6 @@ asynStatus masterMacsAxis::init() {
                                           __PRETTY_FUNCTION__, __LINE__);
     }
 
-    // Cache the motor speed. If this value differs from the one in the motor
-    // record at the start of a movement, the motor record value is sent to
-    // MasterMACS.
-    pMasterMacsA_->lastSetSpeed = motorVelocity;
-
     // Store the motor position in the parameter library
     pl_status = setMotorPosition(motorPosition);
     if (pl_status != asynSuccess) {
@@ -363,14 +356,11 @@ asynStatus masterMacsAxis::doPoll(bool *moving) {
         }
 
         if (timedOut) {
-            pl_status =
-                setStringParam(pC_->motorMessageText(),
-                               "Timed out while waiting for a handshake");
-            if (pl_status != asynSuccess) {
-                return pC_->paramLibAccessFailed(pl_status, "motorMessageText_",
-                                                 axisNo_, __PRETTY_FUNCTION__,
-                                                 __LINE__);
-            }
+            setAxisParamChecked(this, motorMessageText,
+                                "Timed out while waiting for a handshake. "
+                                "Please call the support.");
+
+            poll_status = asynError;
         }
 
         pC_->read(axisNo_, 86, response);
@@ -390,36 +380,15 @@ asynStatus masterMacsAxis::doPoll(bool *moving) {
             pMasterMacsA_->waitForHandshake = false;
             pMasterMacsA_->targetReachedUninitialized = false;
         } else {
-            // Still waiting for the handshake - try again in the next busy
-            // poll. This is already part of the movement procedure.
             *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__);
-            }
-
-            return asynSuccess;
+            setAxisParamChecked(this, motorStatusMoving, *moving);
+            setAxisParamChecked(this, motorStatusDone, !(*moving));
+            return poll_status;
         }
     }
 
     // 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);
@@ -433,6 +402,9 @@ asynStatus masterMacsAxis::doPoll(bool *moving) {
         return rw_status;
     }
 
+    // If we wait for a handshake, but the motor was moving in its last poll
+    // cycle and has reached its target, it is not moving. Otherwise it is
+    // considered moving, even if we're still waiting for the handshake.
     if (pMasterMacsA_->targetReachedUninitialized) {
         *moving = false;
     } else {
@@ -462,195 +434,181 @@ asynStatus masterMacsAxis::doPoll(bool *moving) {
     Read out the error if either a fault condition status flag has been set or
     if a movement has just ended.
      */
+    if (faultConditionSet() || !(*moving)) {
+        rw_status = readAxisError();
+    }
+
     msgPrintControlKey keyError = msgPrintControlKey(
         pC_->portName, axisNo_, __PRETTY_FUNCTION__, __LINE__);
 
-    if (faultConditionSet() || !(*moving)) {
-        rw_status = readAxisError();
+    /*
+    A communication error is a special case. If a communication between
+    controller and axis error occurred, all subsequent errors are ignored,
+    since this information is not reliable.
+     */
+    if (communicationError()) {
+        if (pC_->getMsgPrintControl().shouldBePrinted(keyError, true,
+                                                      pC_->pasynUser())) {
+            asynPrint(pC_->pasynUser(), ASYN_TRACE_ERROR,
+                      "Controller \"%s\", axis %d  => %s, line "
+                      "%d\nCommunication error.%s\n",
+                      pC_->portName, axisNo_, __PRETTY_FUNCTION__, __LINE__,
+                      pC_->getMsgPrintControl().getSuffix());
+        }
+
+        setAxisParamChecked(this, motorMessageText,
+                            "Communication error between PC and motor "
+                            "controller. Please call the support.");
+
+        poll_status = asynError;
+    } else {
+
+        // This buffer must be initialized to zero because we build the
+        // error message by appending strings.
+        char errorMessage[pC_->MAXBUF_] = {0};
+        char shellMessage[pC_->MAXBUF_] = {0};
+
+        // Concatenate all other errors
+        if (shortCircuit()) {
+            appendErrorMessage(shellMessage, sizeof(shellMessage),
+                               "Short circuit fault.");
+            appendErrorMessage(errorMessage, sizeof(errorMessage),
+                               "Short circuit error. Please call the support.");
+
+            poll_status = asynError;
+        }
+
+        if (encoderError()) {
+            appendErrorMessage(shellMessage, sizeof(shellMessage),
+                               "Encoder error.");
+            appendErrorMessage(errorMessage, sizeof(errorMessage),
+                               "Encoder error. Please call the support.");
+
+            poll_status = asynError;
+        }
+
+        if (followingError()) {
+            appendErrorMessage(shellMessage, sizeof(shellMessage),
+                               "Maximum callowed following error exceeded.");
+            appendErrorMessage(
+                errorMessage, sizeof(errorMessage),
+                "Maximum allowed following error exceeded.Check if "
+                "movement range is blocked. Otherwise please call the "
+                "support.");
+
+            poll_status = asynError;
+        }
+
+        if (feedbackError()) {
+            appendErrorMessage(shellMessage, sizeof(shellMessage),
+                               "Feedback error.");
+            appendErrorMessage(errorMessage, sizeof(errorMessage),
+                               "Feedback error. Please call the support.");
+
+            poll_status = asynError;
+        }
 
         /*
-        A communication error is a special case. If a communication between
-        controller and axis error occurred, all subsequent errors are ignored,
-        since this information is not reliable.
-         */
-        if (communicationError()) {
+        Either the software limits or the end switches of the controller
+        have been hit. Since the EPICS limits are derived from the software
+        limits and are a little bit smaller, these error cases can only
+        happen if either the axis has an incremental encoder which is not
+        properly homed or if a bug occured.
+        */
+        if (positiveLimitSwitch() || negativeLimitSwitch() ||
+            positiveSoftwareLimit() || negativeSoftwareLimit()) {
+
+            // Distinction for developers
+            if (positiveLimitSwitch()) {
+                appendErrorMessage(shellMessage, sizeof(shellMessage),
+                                   "Positive limit switch.");
+            }
+            if (negativeLimitSwitch()) {
+                appendErrorMessage(shellMessage, sizeof(shellMessage),
+                                   "Negative limit switch.");
+            }
+            if (positiveSoftwareLimit()) {
+                appendErrorMessage(shellMessage, sizeof(shellMessage),
+                                   "Positive software limit.");
+            }
+            if (negativeSoftwareLimit()) {
+                appendErrorMessage(shellMessage, sizeof(shellMessage),
+                                   "Negative software limit.");
+            }
+
+            // Generic error message for user
+            appendErrorMessage(
+                errorMessage, sizeof(errorMessage),
+                "Software limits or end switch hit. Try homing the motor, "
+                "moving in the opposite direction or check the SPS for "
+                "errors (if available). Otherwise please call the "
+                "support.");
+
+            poll_status = asynError;
+        }
+
+        if (overCurrent()) {
+            appendErrorMessage(shellMessage, sizeof(shellMessage),
+                               "Overcurrent error.");
+            appendErrorMessage(errorMessage, sizeof(errorMessage),
+                               "Overcurrent error. Please call the support.");
+
+            poll_status = asynError;
+        }
+
+        if (overTemperature()) {
+            appendErrorMessage(shellMessage, sizeof(shellMessage),
+                               "Overtemperature error.");
+            appendErrorMessage(
+                errorMessage, sizeof(errorMessage),
+                "Overtemperature error. Please call the support.");
+
+            poll_status = asynError;
+        }
+
+        if (overVoltage()) {
+            appendErrorMessage(shellMessage, sizeof(shellMessage),
+                               "Overvoltage error.");
+            appendErrorMessage(errorMessage, sizeof(errorMessage),
+                               "Overvoltage error. Please call the support.");
+
+            poll_status = asynError;
+        }
+
+        if (underVoltage()) {
+            appendErrorMessage(shellMessage, sizeof(shellMessage),
+                               "Undervoltage error.");
+            appendErrorMessage(errorMessage, sizeof(errorMessage),
+                               "Undervoltage error. Please call the support.");
+
+            poll_status = asynError;
+        }
+
+        if (stoFault()) {
+            appendErrorMessage(shellMessage, sizeof(shellMessage),
+                               "STO input is on disable state.");
+            appendErrorMessage(errorMessage, sizeof(errorMessage),
+                               "STO fault. Please call the support.");
+
+            poll_status = asynError;
+        }
+
+        if (strlen(shellMessage) > 0) {
             if (pC_->getMsgPrintControl().shouldBePrinted(keyError, true,
                                                           pC_->pasynUser())) {
                 asynPrint(pC_->pasynUser(), ASYN_TRACE_ERROR,
                           "Controller \"%s\", axis %d  => %s, line "
-                          "%d\nCommunication error.%s\n",
+                          "%d\n%s%s\n",
                           pC_->portName, axisNo_, __PRETTY_FUNCTION__, __LINE__,
-                          pC_->getMsgPrintControl().getSuffix());
-            }
-
-            pl_status =
-                setStringParam(pC_->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 {
-
-            // This buffer must be initialized to zero because we build the
-            // error message by appending strings.
-            char errorMessage[pC_->MAXBUF_] = {0};
-            char shellMessage[pC_->MAXBUF_] = {0};
-
-            // Concatenate all other errors
-            if (shortCircuit()) {
-                appendErrorMessage(shellMessage, sizeof(shellMessage),
-                                   "Short circuit fault.");
-                appendErrorMessage(
-                    errorMessage, sizeof(errorMessage),
-                    "Short circuit error. Please call the support.");
-
-                poll_status = asynError;
-            }
-
-            if (encoderError()) {
-                appendErrorMessage(shellMessage, sizeof(shellMessage),
-                                   "Encoder error.");
-                appendErrorMessage(errorMessage, sizeof(errorMessage),
-                                   "Encoder error. Please call the support.");
-
-                poll_status = asynError;
-            }
-
-            if (followingError()) {
-                appendErrorMessage(
-                    shellMessage, sizeof(shellMessage),
-                    "Maximum callowed following error exceeded.");
-                appendErrorMessage(
-                    errorMessage, sizeof(errorMessage),
-                    "Maximum allowed following error exceeded.Check if "
-                    "movement range is blocked. Otherwise please call the "
-                    "support.");
-
-                poll_status = asynError;
-            }
-
-            if (feedbackError()) {
-                appendErrorMessage(shellMessage, sizeof(shellMessage),
-                                   "Feedback error.");
-                appendErrorMessage(errorMessage, sizeof(errorMessage),
-                                   "Feedback error. Please call the support.");
-
-                poll_status = asynError;
-            }
-
-            /*
-            Either the software limits or the end switches of the controller
-            have been hit. Since the EPICS limits are derived from the software
-            limits and are a little bit smaller, these error cases can only
-            happen if either the axis has an incremental encoder which is not
-            properly homed or if a bug occured.
-            */
-            if (positiveLimitSwitch() || negativeLimitSwitch() ||
-                positiveSoftwareLimit() || negativeSoftwareLimit()) {
-
-                // Distinction for developers
-                if (positiveLimitSwitch()) {
-                    appendErrorMessage(shellMessage, sizeof(shellMessage),
-                                       "Positive limit switch.");
-                }
-                if (negativeLimitSwitch()) {
-                    appendErrorMessage(shellMessage, sizeof(shellMessage),
-                                       "Negative limit switch.");
-                }
-                if (positiveSoftwareLimit()) {
-                    appendErrorMessage(shellMessage, sizeof(shellMessage),
-                                       "Positive software limit.");
-                }
-                if (negativeSoftwareLimit()) {
-                    appendErrorMessage(shellMessage, sizeof(shellMessage),
-                                       "Negative software limit.");
-                }
-
-                // Generic error message for user
-                appendErrorMessage(
-                    errorMessage, sizeof(errorMessage),
-                    "Software limits or end switch hit. Try homing the motor, "
-                    "moving in the opposite direction or check the SPS for "
-                    "errors (if available). Otherwise please call the "
-                    "support.");
-
-                poll_status = asynError;
-            }
-
-            if (overCurrent()) {
-                appendErrorMessage(shellMessage, sizeof(shellMessage),
-                                   "Overcurrent error.");
-                appendErrorMessage(
-                    errorMessage, sizeof(errorMessage),
-                    "Overcurrent error. Please call the support.");
-
-                poll_status = asynError;
-            }
-
-            if (overTemperature()) {
-                appendErrorMessage(shellMessage, sizeof(shellMessage),
-                                   "Overtemperature error.");
-                appendErrorMessage(
-                    errorMessage, sizeof(errorMessage),
-                    "Overtemperature error. Please call the support.");
-
-                poll_status = asynError;
-            }
-
-            if (overVoltage()) {
-                appendErrorMessage(shellMessage, sizeof(shellMessage),
-                                   "Overvoltage error.");
-                appendErrorMessage(
-                    errorMessage, sizeof(errorMessage),
-                    "Overvoltage error. Please call the support.");
-
-                poll_status = asynError;
-            }
-
-            if (underVoltage()) {
-                appendErrorMessage(shellMessage, sizeof(shellMessage),
-                                   "Undervoltage error.");
-                appendErrorMessage(
-                    errorMessage, sizeof(errorMessage),
-                    "Undervoltage error. Please call the support.");
-
-                poll_status = asynError;
-            }
-
-            if (stoFault()) {
-                appendErrorMessage(shellMessage, sizeof(shellMessage),
-                                   "STO input is on disable state.");
-                appendErrorMessage(errorMessage, sizeof(errorMessage),
-                                   "STO fault. Please call the support.");
-
-                poll_status = asynError;
-            }
-
-            if (strlen(shellMessage) > 0) {
-                if (pC_->getMsgPrintControl().shouldBePrinted(
-                        keyError, true, pC_->pasynUser())) {
-                    asynPrint(pC_->pasynUser(), ASYN_TRACE_ERROR,
-                              "Controller \"%s\", axis %d  => %s, line "
-                              "%d\n%s%s\n",
-                              pC_->portName, axisNo_, __PRETTY_FUNCTION__,
-                              __LINE__, shellMessage,
-                              pC_->getMsgPrintControl().getSuffix());
-                }
-            }
-
-            pl_status = setStringParam(pC_->motorMessageText(), errorMessage);
-            if (pl_status != asynSuccess) {
-                return pC_->paramLibAccessFailed(pl_status, "motorMessageText_",
-                                                 axisNo_, __PRETTY_FUNCTION__,
-                                                 __LINE__);
+                          shellMessage, pC_->getMsgPrintControl().getSuffix());
             }
         }
-    } else {
+
+        setAxisParamChecked(this, motorMessageText, errorMessage);
+    }
+
+    // No error has been detected -> Reset the error count
+    if (poll_status == asynSuccess) {
         pC_->getMsgPrintControl().resetCount(keyError, pC_->pasynUser());
     }
 
@@ -689,40 +647,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(),
-                                readyToBeSwitchedOn() && switchedOn());
-    if (pl_status != asynSuccess) {
-        return pC_->paramLibAccessFailed(pl_status, "motorEnableRBV_", axisNo_,
-                                         __PRETTY_FUNCTION__, __LINE__);
-    }
+    setAxisParamChecked(this, motorEnableRBV,
+                        readyToBeSwitchedOn() && switchedOn());
 
     if (*moving) {
         // If the axis is moving, evaluate the movement direction
@@ -735,38 +671,16 @@ 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) {
         return pl_status;
     }
-
     return poll_status;
 }
 
@@ -775,10 +689,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 +700,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,42 +721,24 @@ 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
     // motor speed changed since the last move command.
-    if (motorCanSetSpeed != 0 && pMasterMacsA_->lastSetSpeed != motorVelocity) {
-
-        pMasterMacsA_->lastSetSpeed = motorVelocity;
+    if (motorCanSetSpeed != 0) {
 
         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 +750,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 +765,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 +785,61 @@ 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;
+    asynStatus 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__);
-        }
+    // Reset any errors
+    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.
+    // Move out of the handshake wait loop, if we're currently inside it.
     pMasterMacsA_->waitForHandshake = false;
 
-    return rw_status;
+    // Disable the axis
+    return enable(false);
+}
+
+asynStatus masterMacsAxis::nodeReset() {
+
+    asynStatus status = asynSuccess;
+
+    // Reset the controller ("node reset"). Since the node reset results in a
+    // power cycle, we use the corresponding timeout.
+    status = pC_->write(axisNo_, 16, "", PowerCycleTimeout);
+    if (status != asynSuccess) {
+        setAxisParamChecked(this, motorStatusProblem, true);
+    }
+
+    // Move out of the handshake wait loop, if we're currently inside it.
+    pMasterMacsA_->waitForHandshake = false;
+
+    // Reinitialize the axis
+    status = masterMacsAxis::init();
+    if (status != asynSuccess) {
+        return status;
+    }
+    bool moving = false;
+    return forcedPoll(&moving);
 }
 
 /*
@@ -975,41 +848,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 +884,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 +892,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 +910,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 +951,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(),
-                           "Axis cannot be disabled while it is moving.");
-        if (pl_status != asynSuccess) {
-            return pC_->paramLibAccessFailed(pl_status, "motorMessageText_",
-                                             axisNo_, __PRETTY_FUNCTION__,
-                                             __LINE__);
-        }
+        setAxisParamChecked(this, motorMessageText,
+                            "Axis cannot be disabled while it is moving.");
 
         return asynError;
     }
@@ -1135,7 +970,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 +985,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,15 +997,15 @@ 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) {
             bool moving = false;
             // Perform a poll to update the parameter library
-            poll(&moving);
+            forcedPoll(&moving);
             return asynSuccess;
         }
     }
@@ -1184,14 +1019,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,16 +1,12 @@
 #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 HIDDEN masterMacsAxisImpl;
 
-struct masterMacsAxisImpl;
-
-class masterMacsAxis : public sinqAxis {
+class HIDDEN masterMacsAxis : public sinqAxis {
   public:
     /**
      * @brief Construct a new masterMacsAxis
@@ -79,12 +75,27 @@ class masterMacsAxis : public sinqAxis {
      */
     asynStatus doReset();
 
+    /**
+     * @brief Performs a "node reset" on the axis as defined in the CANopen
+     * standard
+     *
+     * A "node reset" is a factory reset on the axis which completely deletes
+     * all configured information (e.g. limits or speed) from the axis. The
+     * MasterMACS controller then reapplies the initial configuration to this
+     * axis. It can therefore be seen as a "hard" version of the normal error
+     * reset performed by the `doReset` method.
+     *
+     * @return asynStatus
+     */
+    asynStatus nodeReset();
+
     /**
      * @brief Readout of some values from the controller at IOC startup
      *
      * The following steps are performed:
-     * - Read out the motor status, motor position, velocity and acceleration
-     * from the MCU and store this information in the parameter library.
+     * - Read out the motor status, motor position, velocity and
+     * acceleration from the MCU and store this information in the parameter
+     * library.
      * - Set the enable PV accordint to the initial status of the axis.
      *
      * @return asynStatus
@@ -100,8 +111,8 @@ class masterMacsAxis : public sinqAxis {
     asynStatus enable(bool on);
 
     /**
-     * @brief Read the encoder type (incremental or absolute) for this axis from
-     * the MCU and store the information in the PV ENCODER_TYPE.
+     * @brief Read the encoder type (incremental or absolute) for this axis
+     * from the MCU and store the information in the PV ENCODER_TYPE.
      *
      * @return asynStatus
      */
@@ -116,17 +127,21 @@ class masterMacsAxis : public sinqAxis {
     bool needInit();
 
     /**
-     * @brief Instruct the axis to run its init() function during the next poll
+     * @brief Instruct the axis to run its init() function during the next
+     * poll
      *
      * @param needInit
      */
     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
-     * result in axisStatus_
+     * @brief Read the Master MACS status with the xR10 command and store
+     * the result in axisStatus_
      *
      */
     asynStatus readAxisStatus();
@@ -204,8 +219,8 @@ class masterMacsAxis : public sinqAxis {
     bool powerEnabled();
 
     /**
-     * @brief Read the Master MACS status with the xR10 command and store the
-     * result in axisStatus_
+     * @brief Read the Master MACS status with the xR10 command and store
+     * the result in axisStatus_
      *
      */
     asynStatus readAxisError();

src/masterMacsController.cpp

@@ -12,8 +12,33 @@
 #include <string>
 #include <unistd.h>
 
+/*
+These functions are used to read out the compiler flags defining the major and
+minor versions. See README.md, section "Firmware version checking" for
+details. If these flags are not given, a default value of -1 is used, which
+disables the version checks (it suffices to have one of these at -1 to disable
+both major and minor version check)
+ */
+constexpr int firmware_major_version() {
+#ifdef FIRMWARE_MAJOR_VERSION
+    return FIRMWARE_MAJOR_VERSION;
+#else
+    return -1;
+#endif
+}
+constexpr int firmware_minor_version() {
+#ifdef FIRMWARE_MINOR_VERSION
+    return FIRMWARE_MINOR_VERSION;
+#else
+    return -1;
+#endif
+}
+
 struct masterMacsControllerImpl {
     double comTimeout;
+
+    // Indices of additional ParamLib entries
+    int nodeReset;
 };
 
 /**
@@ -62,12 +87,27 @@ masterMacsController::masterMacsController(const char *portName,
 
     // Initialization of local variables
     asynStatus status = asynSuccess;
+    char response[MAXBUF_] = {0};
 
     pMasterMacsC_ =
         std::make_unique<masterMacsControllerImpl>((masterMacsControllerImpl){
             .comTimeout = comTimeout,
         });
 
+    // =========================================================================
+    // Create additional parameter library entries
+
+    status =
+        createParam("NODE_RESET", asynParamInt32, &pMasterMacsC_->nodeReset);
+    if (status != asynSuccess) {
+        asynPrint(this->pasynUser(), 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);
+    }
+
     // =========================================================================
 
     /*
@@ -99,6 +139,60 @@ masterMacsController::masterMacsController(const char *portName,
         pasynOctetSyncIO->disconnect(pasynOctetSyncIOipPort());
         exit(-1);
     }
+
+    // =========================================================================
+
+    if (firmware_major_version() >= 0 && firmware_minor_version() >= 0) {
+        // Check the firmware version according to the conditions outlined in
+        // README.md
+        status = read(0, 99, response);
+
+        if (status == asynSuccess) {
+
+            // Just interpret the version if the variable already exists
+            double versionRaw = 0.0;
+            int nvals = sscanf(response, "%lf", &versionRaw);
+            if (nvals == 1 && versionRaw != 0.0) {
+                // Discard decimal part
+                long long versionInt = (long long)versionRaw;
+
+                // Extract bugfix (last 3 digits)
+                // Currently not used, just here for completions sake
+                // int bugfix = versionInt % 1000;
+                versionInt /= 1000;
+
+                // Extract minor (next 3 digits)
+                int minor = versionInt % 1000;
+                versionInt /= 1000;
+
+                // Remaining is major
+                int major = (int)versionInt;
+
+                // Compare to target values
+                if (firmware_major_version() != major ||
+                    firmware_minor_version() > minor) {
+                    asynPrint(this->pasynUser(), ASYN_TRACE_ERROR,
+                              "Controller \"%s\" => %s, line %d\nFATAL ERROR "
+                              "(Incorrect "
+                              "version number of firmware: Expected major "
+                              "version equal "
+                              "to %d, got %d. Expected minor version equal to "
+                              "or larger "
+                              "than %d, got %d).\nTerminating IOC",
+                              portName, __PRETTY_FUNCTION__, __LINE__,
+                              firmware_major_version(), major,
+                              firmware_minor_version(), minor);
+                    exit(-1);
+                }
+            }
+        } else {
+            asynPrint(
+                this->pasynUser(), ASYN_TRACE_ERROR,
+                "Controller \"%s\" => %s, line %d\nCould not read firmware "
+                "version\n",
+                portName, __PRETTY_FUNCTION__, __LINE__);
+        }
+    }
 }
 
 /*
@@ -120,6 +214,22 @@ masterMacsAxis *masterMacsController::getMasterMacsAxis(int axisNo) {
     return dynamic_cast<masterMacsAxis *>(asynAxis);
 }
 
+asynStatus masterMacsController::writeInt32(asynUser *pasynUser,
+                                            epicsInt32 value) {
+    int function = pasynUser->reason;
+
+    // =====================================================================
+
+    masterMacsAxis *axis = getMasterMacsAxis(pasynUser);
+
+    // Handle custom PVs
+    if (function == nodeReset()) {
+        return axis->nodeReset();
+    } else {
+        return sinqController::writeInt32(pasynUser, value);
+    }
+}
+
 asynStatus masterMacsController::read(int axisNo, int tcpCmd, char *response,
                                       double comTimeout) {
     return writeRead(axisNo, tcpCmd, NULL, response);
@@ -136,7 +246,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};
@@ -167,12 +276,6 @@ asynStatus masterMacsController::writeRead(int axisNo, int tcpCmd,
         comTimeout = pMasterMacsC_->comTimeout;
     }
 
-    masterMacsAxis *axis = getMasterMacsAxis(axisNo);
-    if (axis == nullptr) {
-        // We already did the error logging directly in getAxis
-        return asynError;
-    }
-
     // Build the full command depending on the inputs to this function
     if (isRead) {
         snprintf(fullCommand, MAXBUF_ - 1, "%dR%02d\x0D", axisNo, tcpCmd);
@@ -254,54 +357,38 @@ 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);
-    } else {
-
-        /*
-        Since the communication failed, there is the possibility that the
-        controller is not connected at all to the network. In that case, we
-        cannot be sure that the information read out in the init method of the
-        axis is still up-to-date the next time we get a connection. Therefore,
-        an info flag is set which the axis object can use at the start of its
-        poll method to try to initialize itself.
-        */
-        axis->setNeedInit(true);
-
-        /*
-        Check if the axis already is in an error communication mode. If
-        it is not, upstream the error. This is done to avoid "flooding"
-        the user with different error messages if more than one error
-        ocurred before an error-free communication
-        */
-        pl_status =
-            getIntegerParam(axisNo, motorStatusProblem_, &motorStatusProblem);
-        if (pl_status != asynSuccess) {
-            return paramLibAccessFailed(pl_status, "motorStatusProblem", axisNo,
-                                        __PRETTY_FUNCTION__, __LINE__);
+    if (axisNo != 0) {
+        masterMacsAxis *axis = getMasterMacsAxis(axisNo);
+        if (axis == nullptr) {
+            // We already did the error logging directly in getAxis
+            return asynError;
         }
 
-        if (motorStatusProblem == 0) {
-            pl_status =
-                axis->setStringParam(motorMessageText(), drvMessageText);
-            if (pl_status != asynSuccess) {
-                return paramLibAccessFailed(pl_status, "motorMessageText",
-                                            axisNo, __PRETTY_FUNCTION__,
-                                            __LINE__);
-            }
+        if (status == asynSuccess) {
+            setAxisParamChecked(axis, motorStatusCommsError, false);
+        } else {
+            /*
+            Since the communication failed, there is the possibility that the
+            controller is not connected at all to the network. In that case, we
+            cannot be sure that the information read out in the init method of
+            the axis is still up-to-date the next time we get a connection.
+            Therefore, an info flag is set which the axis object can use at the
+            start of its poll method to try to initialize itself.
+            */
+            axis->setNeedInit(true);
 
-            pl_status = axis->setIntegerParam(motorStatusProblem_, 1);
-            if (pl_status != asynSuccess) {
-                return paramLibAccessFailed(pl_status, "motorStatusProblem",
-                                            axisNo, __PRETTY_FUNCTION__,
-                                            __LINE__);
-            }
+            /*
+            Check if the axis already is in an error communication mode. If
+            it is not, upstream the error. This is done to avoid "flooding"
+            the user with different error messages if more than one error
+            ocurred before an error-free communication
+            */
+            getAxisParamChecked(axis, motorStatusProblem, &motorStatusProblem);
 
-            pl_status = axis->setIntegerParam(motorStatusProblem_, 1);
-            if (pl_status != asynSuccess) {
-                return paramLibAccessFailed(pl_status, "motorStatusCommsError_",
-                                            axisNo, __PRETTY_FUNCTION__,
-                                            __LINE__);
+            if (motorStatusProblem == 0) {
+                setAxisParamChecked(axis, motorMessageText, drvMessageText);
+                setAxisParamChecked(axis, motorStatusProblem, true);
+                setAxisParamChecked(axis, motorStatusCommsError, false);
             }
         }
     }
@@ -325,18 +412,21 @@ asynStatus masterMacsController::parseResponse(
     bool responseValid = false;
     int responseStart = 0;
     asynStatus status = asynSuccess;
-    int prevConnected = 0;
+    int prevConnected = 1;
     char printableCommand[MAXBUF_] = {0};
     char printableResponse[MAXBUF_] = {0};
 
     msgPrintControlKey parseKey =
         msgPrintControlKey(portName, axisNo, __PRETTY_FUNCTION__, __LINE__);
 
+    masterMacsAxis *axis = getMasterMacsAxis(axisNo);
+    if (axisNo != 0 && axis == nullptr) {
+        return asynError;
+    }
+
     // Was the motor previously connected?
-    status = getIntegerParam(axisNo, motorConnected(), &prevConnected);
-    if (status != asynSuccess) {
-        return paramLibAccessFailed(status, "motorConnected", axisNo,
-                                    __PRETTY_FUNCTION__, __LINE__);
+    if (axis != nullptr) {
+        getAxisParamChecked(axis, motorConnected, &prevConnected);
     }
 
     // We don't use strlen here since the C string terminator 0x00
@@ -361,23 +451,17 @@ 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__);
-                }
-                status = callParamCallbacks();
-                if (status != asynSuccess) {
-                    asynPrint(this->pasynUserSelf, ASYN_TRACE_ERROR,
-                              "Controller \"%s\", axis %d => %s, line "
-                              "%d:\nCould not update parameter library\n",
-                              portName, axisNo, __PRETTY_FUNCTION__, __LINE__);
-                    return status;
+                if (axis != nullptr) {
+                    setAxisParamChecked(axis, motorConnected, true);
+                    status = callParamCallbacks();
+                    if (status != asynSuccess) {
+                        asynPrint(this->pasynUserSelf, ASYN_TRACE_ERROR,
+                                  "Controller \"%s\", axis %d => %s, line "
+                                  "%d:\nCould not update parameter library\n",
+                                  portName, axisNo, __PRETTY_FUNCTION__,
+                                  __LINE__);
+                        return status;
+                    }
                 }
             }
 
@@ -398,23 +482,17 @@ 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__);
-                }
-                status = callParamCallbacks();
-                if (status != asynSuccess) {
-                    asynPrint(this->pasynUserSelf, ASYN_TRACE_ERROR,
-                              "Controller \"%s\", axis %d => %s, line "
-                              "%d:\nCould not update parameter library\n",
-                              portName, axisNo, __PRETTY_FUNCTION__, __LINE__);
-                    return status;
+                if (axis != nullptr) {
+                    setAxisParamChecked(axis, motorConnected, false);
+                    status = callParamCallbacks();
+                    if (status != asynSuccess) {
+                        asynPrint(this->pasynUserSelf, ASYN_TRACE_ERROR,
+                                  "Controller \"%s\", axis %d => %s, line "
+                                  "%d:\nCould not update parameter library\n",
+                                  portName, axisNo, __PRETTY_FUNCTION__,
+                                  __LINE__);
+                        return status;
+                    }
                 }
             }
             break;
@@ -500,6 +578,8 @@ asynStatus masterMacsController::readInt32(asynUser *pasynUser,
 
 double masterMacsController::comTimeout() { return pMasterMacsC_->comTimeout; }
 
+int masterMacsController::nodeReset() { return pMasterMacsC_->nodeReset; }
+
 /***************************************************************************/
 /** The following functions are C-wrappers, and can be called directly from
  * iocsh */

src/masterMacsController.h

@@ -8,14 +8,18 @@
 
 #ifndef masterMacsController_H
 #define masterMacsController_H
-#include "masterMacsAxis.h"
 #include "sinqAxis.h"
 #include "sinqController.h"
 #include <memory>
 
-struct masterMacsControllerImpl;
+// 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 HIDDEN masterMacsAxis;
 
-class masterMacsController : public sinqController {
+struct HIDDEN masterMacsControllerImpl;
+
+class HIDDEN masterMacsController : public sinqController {
 
   public:
     /**
@@ -61,6 +65,17 @@ class masterMacsController : public sinqController {
      */
     masterMacsAxis *getMasterMacsAxis(int axisNo);
 
+    /**
+     * @brief Overloaded function of sinqController
+     *
+     * The function is overloaded to allow resetting the node
+     *
+     * @param pasynUser           Specify the axis via the asynUser
+     * @param value               New value
+     * @return asynStatus
+     */
+    virtual asynStatus writeInt32(asynUser *pasynUser, epicsInt32 value);
+
     /**
      * @brief Send a command to the hardware (S mode)
      *
@@ -137,6 +152,9 @@ class masterMacsController : public sinqController {
      */
     double comTimeout();
 
+    // Accessors for additional PVs
+    int nodeReset();
+
   private:
     std::unique_ptr<masterMacsControllerImpl> pMasterMacsC_;
 };