Added reminder comment

See TODO in src/masterMacsAxis.cpp, line 552. The velocity readback is
the only thing that doesn't work properly, everything else does work.
Once a solution has been found here, this can be a new minor release.

.gitignore

@@ -0,0 +1,4 @@
+O.*
+.cvsignore
+.vscode
+utils/__pycache__

Makefile

@@ -23,9 +23,15 @@ 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
+USR_CFLAGS += -Wall -Wextra -Wunused-result -Wextra -Werror
+USR_CXXFLAGS += -Wall -Wextra -Wunused-result
+
+# 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

@@ -17,23 +17,50 @@ The folder "utils" contains utility scripts for working with masterMacs motor co
 - decodeError.py: Take the return message of a R11 (read error) command and print it in human-readable form.
 - writeRead.py: Send messages to the controller and receive answers.
 
-## Developer guide
+These scripts can be run from anywhere. On Linux, the shebang (#!) automatically
+calls the system Python 3 executable:
 
-### Usage in IOC shell
+```bash
+# To show the help, use either flag -h or --help (works on all scripts)
+/path/to/mastermacs_repo/utils/decodeStatus.py -h 
+/path/to/mastermacs_repo/utils/decodeError.py --help
+/path/to/mastermacs_repo/utils/writeRead.py -h
 
-masterMacs exposes the following IOC shell functions (all in masterMacsController.cpp):
+# To run in non-interactive mode, give the value as an argument
+/path/to/mastermacs_repo/utils/decodeStatus.py 1234
+/path/to/mastermacs_repo/utils/decodeError.py 5678
+/path/to/mastermacs_repo/utils/writeRead.py "R11"
+
+# To run in interactive mode, don't give any argument. This only works on Linux
+/path/to/mastermacs_repo/utils/decodeStatus.py
+/path/to/mastermacs_repo/utils/decodeError.py
+/path/to/mastermacs_repo/utils/writeRead.py
+```
+
+To use these scripts on Windows, prefix the Python 3 executable:
+```bash
+C:/path/to/python3.exe C:/path/to/mastermacs_repo/utils/decodeStatus.py 1234
+```
+
+### IOC startup script
+
+masterMacs exposes the following IOC shell functions:
 - `masterMacsController`: Create a new controller object.
 - `masterMacsAxis`: Create a new axis object.
 
-The full mcu.cmd file looks like this:
+The full masterMacsX.cmd file looks like this:
 
-```
+```bash
 # Define the name of the controller and the corresponding port
 epicsEnvSet("NAME","mcu")
 epicsEnvSet("ASYN_PORT","p$(NAME)")
 
-# Create the TCP/IP socket used to talk with the controller. The socket can be adressed from within the IOC shell via the port name
+# Create the TCP/IP socket used to talk with the controller. The socket can be
-drvAsynIPPortConfigure("$(ASYN_PORT)","172.28.101.24:1025")
+# adressed from within the IOC shell via the port name
+# We do not use the standard asyn port driver here, but a PMAC-specific one
+# which enables the usage of StreamDevices for
+# communicating with the controller directly.
+masterMacsAsynIPPortConfigure("$(ASYN_PORT)","172.28.101.24:1025")
 
 # Create the controller object with the defined name and connect it to the socket via the port name.
 # The other parameters are as follows:
@@ -62,10 +89,38 @@ dbLoadTemplate("$(TOP)/$(NAME).substitutions", "INSTR=$(INSTR)$(NAME):,CONTROLLE
 dbLoadRecords("$(masterMacs_DB)/asynRecord.db","P=$(INSTR)$(NAME),PORT=$(ASYN_PORT)")
 ```
 
+## Developer guide
+
 ### 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,17 @@
+# 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")
+}
+
+# Overrides the default value for the "Connected" record provided by sinqMotor.
+record(longin, "$(INSTR)$(M):Connected")
+{
+    field(DTYP, "asynInt32")
+    field(INP,  "@asyn($(CONTROLLER),$(AXIS)) MOTOR_CONNECTED")
+    field(SCAN, "I/O Intr")
+    field(PINI, "NO")
+    field(VAL, "0")
+}

src/masterMacsAxis.cpp

@@ -11,6 +11,11 @@
 #include <string.h>
 #include <unistd.h>
 
+enum moveMode {
+    positionMode,
+    velocityMode,
+};
+
 struct masterMacsAxisImpl {
     /*
     The axis status and axis error of MasterMACS are given as an integer from
@@ -23,6 +28,10 @@ struct masterMacsAxisImpl {
     time_t timeAtHandshake;
     bool needInit = true;
     bool targetReachedUninitialized;
+    bool dynamicLimits;
+    bool canPositionMove;
+    bool canVelocityMove;
+    moveMode lastMoveCommand;
 };
 
 /*
@@ -85,7 +94,18 @@ void appendErrorMessage(char *fullMessage, size_t capacityFullMessage,
 }
 
 masterMacsAxis::masterMacsAxis(masterMacsController *pC, int axisNo)
-    : sinqAxis(pC, axisNo), pC_(pC) {
+    : sinqAxis(pC, axisNo), pC_(pC),
+      pMasterMacsA_(std::make_unique<masterMacsAxisImpl>((masterMacsAxisImpl){
+          .axisStatus = std::bitset<16>(0),
+          .axisError = std::bitset<16>(0),
+          .waitForHandshake = false,
+          .timeAtHandshake = 0,
+          .targetReachedUninitialized = true,
+          .dynamicLimits = false,
+          .canPositionMove = true,
+          .canVelocityMove = false,
+          .lastMoveCommand = positionMode,
+      })) {
 
     asynStatus status = asynSuccess;
 
@@ -118,14 +138,6 @@ masterMacsAxis::masterMacsAxis(masterMacsController *pC, int axisNo)
     // Collect all axes into this list which will be used in the hook function
     axes.push_back(this);
 
-    pMasterMacsA_ = std::make_unique<masterMacsAxisImpl>((masterMacsAxisImpl){
-        .axisStatus = std::bitset<16>(0),
-        .axisError = std::bitset<16>(0),
-        .waitForHandshake = false,
-        .timeAtHandshake = 0,
-        .targetReachedUninitialized = true,
-    });
-
     // masterMacs motors can always be disabled
     status = pC_->setIntegerParam(axisNo_, pC_->motorCanDisable(), 1);
     if (status != asynSuccess) {
@@ -180,14 +192,17 @@ Read out the following values:
 asynStatus masterMacsAxis::init() {
 
     // Local variable declaration
-    asynStatus pl_status = asynSuccess;
+    asynStatus status = asynSuccess;
     char response[pC_->MAXBUF_] = {0};
     int nvals = 0;
-    double motorRecResolution = 0.0;
+    double motRecResolution = 0.0;
-    double motorPosition = 0.0;
+    double motPosition = 0.0;
-    double motorVelocity = 0.0;
+    double motPositionDeadband = 0.0;
-    double motorVmax = 0.0;
+    double motVelocity = 0.0;
-    double motorAccel = 0.0;
+    double motVmax = 0.0;
+    double motAccel = 0.0;
+    int dynamicLimits = 0;
+    int possibleModes = 0;
 
     // =========================================================================
 
@@ -196,9 +211,9 @@ asynStatus masterMacsAxis::init() {
     time_t now = time(NULL);
     time_t maxInitTime = 60;
     while (1) {
-        pl_status = pC_->getDoubleParam(axisNo_, pC_->motorRecResolution(),
+        status = pC_->getDoubleParam(axisNo_, pC_->motorRecResolution(),
-                                        &motorRecResolution);
+                                     &motRecResolution);
-        if (pl_status == asynParamUndefined) {
+        if (status == asynParamUndefined) {
             if (now + maxInitTime < time(NULL)) {
                 asynPrint(pC_->pasynUser(), ASYN_TRACE_ERROR,
                           "Controller \"%s\", axis %d  => %s, line "
@@ -207,83 +222,147 @@ asynStatus masterMacsAxis::init() {
                           __LINE__);
                 return asynError;
             }
-        } else if (pl_status == asynSuccess) {
+        } else if (status == asynSuccess) {
             break;
-        } else if (pl_status != asynSuccess) {
+        } else if (status != asynSuccess) {
-            return pC_->paramLibAccessFailed(pl_status, "motorRecResolution_",
+            return pC_->paramLibAccessFailed(status, "motorRecResolution_",
                                              axisNo_, __PRETTY_FUNCTION__,
                                              __LINE__);
         }
     }
 
+    // Initially assume that the axis is disconnected. It will be set to
+    // connected after the first communication attempted succeeded.
+    setAxisParamChecked(this, motorConnected, false);
+
     // Read out the current position
-    pl_status = pC_->read(axisNo_, 12, response);
+    status = pC_->read(axisNo_, 12, response);
-    if (pl_status != asynSuccess) {
+    if (status != asynSuccess) {
-        return pl_status;
+        return status;
     }
-    nvals = sscanf(response, "%lf", &motorPosition);
+    nvals = sscanf(response, "%lf", &motPosition);
     if (nvals != 1) {
         return pC_->couldNotParseResponse("R12", response, axisNo_,
                                           __PRETTY_FUNCTION__, __LINE__);
     }
+    status = setMotorPosition(motPosition);
+    if (status != asynSuccess) {
+        return status;
+    }
 
     // Read out the current velocity
-    pl_status = pC_->read(axisNo_, 05, response);
+    status = pC_->read(axisNo_, 05, response);
-    if (pl_status != asynSuccess) {
+    if (status != asynSuccess) {
-        return pl_status;
+        return status;
     }
-    nvals = sscanf(response, "%lf", &motorVelocity);
+    nvals = sscanf(response, "%lf", &motVelocity);
     if (nvals != 1) {
         return pC_->couldNotParseResponse("R05", response, axisNo_,
                                           __PRETTY_FUNCTION__, __LINE__);
     }
 
     // Read out the maximum velocity
-    pl_status = pC_->read(axisNo_, 26, response);
+    status = pC_->read(axisNo_, 26, response);
-    if (pl_status != asynSuccess) {
+    if (status != asynSuccess) {
-        return pl_status;
+        return status;
     }
-    nvals = sscanf(response, "%lf", &motorVmax);
+    nvals = sscanf(response, "%lf", &motVmax);
     if (nvals != 1) {
         return pC_->couldNotParseResponse("R26", response, axisNo_,
                                           __PRETTY_FUNCTION__, __LINE__);
     }
 
-    // Read out the acceleration
+    status = setVeloFields(abs(motVelocity), 0.0, motVmax);
-    pl_status = pC_->read(axisNo_, 06, response);
+    if (status != asynSuccess) {
-    if (pl_status != asynSuccess) {
+        return status;
-        return pl_status;
     }
-    nvals = sscanf(response, "%lf", &motorAccel);
+
+    // Read out the acceleration
+    status = pC_->read(axisNo_, 06, response);
+    if (status != asynSuccess) {
+        return status;
+    }
+    nvals = sscanf(response, "%lf", &motAccel);
     if (nvals != 1) {
         return pC_->couldNotParseResponse("R06", response, axisNo_,
                                           __PRETTY_FUNCTION__, __LINE__);
     }
-
+    status = setAcclField(motAccel);
-    // Store the motor position in the parameter library
+    if (status != asynSuccess) {
-    pl_status = setMotorPosition(motorPosition);
+        return status;
-    if (pl_status != asynSuccess) {
-        return pl_status;
     }
 
-    // Write to the motor record fields
+    // Read out the motor position deadband
-    pl_status = setVeloFields(motorVelocity, 0.0, motorVmax);
+    status = pC_->read(axisNo_, 13, response);
-    if (pl_status != asynSuccess) {
+    if (status != asynSuccess) {
-        return pl_status;
+        return status;
     }
-    pl_status = setAcclField(motorAccel);
+    nvals = sscanf(response, "%lf", &motPositionDeadband);
-    if (pl_status != asynSuccess) {
+    if (nvals != 1) {
-        return pl_status;
+        return pC_->couldNotParseResponse("R13", response, axisNo_,
+                                          __PRETTY_FUNCTION__, __LINE__);
+    }
+    setAxisParamChecked(this, motorPositionDeadband, motPositionDeadband);
+
+    // Check if the motor has dynamic limits
+    status = pC_->read(axisNo_, 32, response);
+    if (status != asynSuccess) {
+        return status;
+    }
+    nvals = sscanf(response, "%d", &dynamicLimits);
+    if (nvals != 1) {
+        return pC_->couldNotParseResponse("R32", response, axisNo_,
+                                          __PRETTY_FUNCTION__, __LINE__);
+    }
+    pMasterMacsA_->dynamicLimits = bool(dynamicLimits);
+
+    // Check if the motor can switch its mode
+    status = pC_->read(axisNo_, 31, response);
+    if (status != asynSuccess) {
+        return status;
+    }
+    nvals = sscanf(response, "%d", &possibleModes);
+    if (nvals != 1) {
+        return pC_->couldNotParseResponse("R31", response, axisNo_,
+                                          __PRETTY_FUNCTION__, __LINE__);
     }
 
-    pl_status = readEncoderType();
+    switch (possibleModes) {
-    if (pl_status != asynSuccess) {
+    case 1:
-        return pl_status;
+        pMasterMacsA_->canPositionMove = true;
+        pMasterMacsA_->canVelocityMove = false;
+        break;
+    case 2:
+        pMasterMacsA_->canPositionMove = false;
+        pMasterMacsA_->canVelocityMove = true;
+        break;
+    case 3:
+        pMasterMacsA_->canPositionMove = true;
+        pMasterMacsA_->canVelocityMove = true;
+        break;
+    default:
+        asynPrint(pC_->pasynUser(), ASYN_TRACE_ERROR,
+                  "Controller \"%s\", axis %d => %s, line "
+                  "%d:\nunexpected answer %d for R31 (possible operation "
+                  "modes). Expected one of 1, 2 or 3.\n",
+                  pC_->portName, axisNo_, __PRETTY_FUNCTION__, __LINE__,
+                  possibleModes);
+    }
+
+    status = readEncoderType();
+    if (status != asynSuccess) {
+        return status;
+    }
+
+    // Read the axis limits
+    status = readLimits();
+    if (status != asynSuccess) {
+        return status;
     }
 
     // Update the parameter library immediately
-    pl_status = callParamCallbacks();
+    status = callParamCallbacks();
-    if (pl_status != asynSuccess) {
+    if (status != asynSuccess) {
         // If we can't communicate with the parameter library, it doesn't
         // make sense to try and upstream this to the user -> Just log the
         // error
@@ -291,14 +370,68 @@ asynStatus masterMacsAxis::init() {
                   "Controller \"%s\", axis %d => %s, line "
                   "%d:\ncallParamCallbacks failed with %s.\n",
                   pC_->portName, axisNo_, __PRETTY_FUNCTION__, __LINE__,
-                  pC_->stringifyAsynStatus(pl_status));
+                  pC_->stringifyAsynStatus(status));
-        return pl_status;
+        return status;
     }
 
     // Axis is fully initialized
     setNeedInit(false);
 
-    return pl_status;
+    return status;
+}
+
+asynStatus masterMacsAxis::readLimits() {
+
+    asynStatus status = asynSuccess;
+
+    char response[pC_->MAXBUF_] = {0};
+    int nvals = 0;
+
+    double highLimit = 0.0;
+    double lowLimit = 0.0;
+    double limitsOffset = 0.0;
+
+    // =========================================================================
+
+    status = pC_->read(axisNo_, 34, response);
+    if (status != asynSuccess) {
+        return status;
+    }
+    nvals = sscanf(response, "%lf", &lowLimit);
+    if (nvals != 1) {
+        return pC_->couldNotParseResponse("R34", response, axisNo_,
+                                          __PRETTY_FUNCTION__, __LINE__);
+    }
+
+    status = pC_->read(axisNo_, 33, response);
+    if (status != asynSuccess) {
+        return status;
+    }
+    nvals = sscanf(response, "%lf", &highLimit);
+    if (nvals != 1) {
+        return pC_->couldNotParseResponse("R33", response, axisNo_,
+                                          __PRETTY_FUNCTION__, __LINE__);
+    }
+
+    /*
+    The axis limits are set as: ({[]})
+    where [] are the positive and negative limits set in EPICS/NICOS, {} are
+    the software limits set on the MCU and () are the hardware limit
+    switches. In other words, the EPICS/NICOS limits must be stricter than
+    the software limits on the MCU which in turn should be stricter than the
+    hardware limit switches. For example, if the hardware limit switches are
+    at [-10, 10], the software limits could be at [-9, 9] and the EPICS /
+    NICOS limits could be at
+    [-8, 8]. Therefore, we cannot use the software limits read from the MCU
+    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.
+    */
+    getAxisParamChecked(this, motorLimitsOffset, &limitsOffset);
+
+    highLimit = highLimit - limitsOffset;
+    lowLimit = lowLimit + limitsOffset;
+
+    return setLimits(highLimit, lowLimit);
 }
 
 // Perform the actual poll
@@ -308,10 +441,10 @@ asynStatus masterMacsAxis::doPoll(bool *moving) {
     asynStatus poll_status = asynSuccess;
 
     // Status of read-write-operations of ASCII commands to the controller
-    asynStatus rw_status = asynSuccess;
+    asynStatus rwStatus = asynSuccess;
 
     // Status of parameter library operations
-    asynStatus pl_status = asynSuccess;
+    asynStatus plStatus = asynSuccess;
 
     char response[pC_->MAXBUF_] = {0};
     int nvals = 0;
@@ -321,19 +454,15 @@ asynStatus masterMacsAxis::doPoll(bool *moving) {
     double currentPosition = 0.0;
     double previousPosition = 0.0;
     double motorRecResolution = 0.0;
-    double highLimit = 0.0;
-    double lowLimit = 0.0;
-    double limitsOffset = 0.0;
     double handshakePerformed = 0;
 
     // =========================================================================
 
-    // Does the axis need to be intialized?
+    // Does the axis need to be initialized?
     if (needInit()) {
-        rw_status = init();
+        // Perform the rest of the poll, but remember if sth. failed in the
-        if (rw_status != asynSuccess) {
+        // init.
-            return rw_status;
+        poll_status = init();
-        }
     }
 
     // Are we currently waiting for a handshake?
@@ -357,12 +486,15 @@ asynStatus masterMacsAxis::doPoll(bool *moving) {
 
         if (timedOut) {
             setAxisParamChecked(this, motorMessageText,
-                                "Timed out while waiting for a handshake");
+                                "Timed out while waiting for a handshake. "
+                                "Please call the support.");
+
+            poll_status = asynError;
         }
 
         pC_->read(axisNo_, 86, response);
-        if (rw_status != asynSuccess) {
+        if (rwStatus != asynSuccess) {
-            return rw_status;
+            return rwStatus;
         }
 
         nvals = sscanf(response, "%lf", &handshakePerformed);
@@ -377,14 +509,10 @@ 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;
-
             setAxisParamChecked(this, motorStatusMoving, *moving);
             setAxisParamChecked(this, motorStatusDone, !(*moving));
-
+            return poll_status;
-            return asynSuccess;
         }
     }
 
@@ -392,17 +520,60 @@ asynStatus masterMacsAxis::doPoll(bool *moving) {
     getAxisParamChecked(this, motorRecResolution, &motorRecResolution);
 
     // Read the previous motor position
-    pl_status = motorPosition(&previousPosition);
+    plStatus = motorPosition(&previousPosition);
-    if (pl_status != asynSuccess) {
+    if (plStatus != asynSuccess) {
-        return pl_status;
+        return plStatus;
     }
 
     // Update the axis status
-    rw_status = readAxisStatus();
+    rwStatus = readAxisStatus();
-    if (rw_status != asynSuccess) {
+    if (rwStatus != asynSuccess) {
-        return rw_status;
+        return rwStatus;
     }
 
+    rwStatus = pC_->read(axisNo_, 12, response);
+    if (rwStatus != asynSuccess) {
+        return rwStatus;
+    }
+    nvals = sscanf(response, "%lf", &currentPosition);
+    if (nvals != 1) {
+        return pC_->couldNotParseResponse("R12", response, axisNo_,
+                                          __PRETTY_FUNCTION__, __LINE__);
+    }
+
+    plStatus = setMotorPosition(currentPosition);
+    if (plStatus != asynSuccess) {
+        return plStatus;
+    }
+    setAxisParamChecked(this, motorEncoderPosition, currentPosition);
+
+    if (pMasterMacsA_->lastMoveCommand == velocityMode && !speedEqualZero()) {
+
+        // TODO: Not sure whether the RVEL field of the motor record does not
+        // work - has to be clarified
+        double actualVelocity = 0.0;
+
+        rwStatus = pC_->read(axisNo_, 14, response);
+        if (rwStatus != asynSuccess) {
+            return rwStatus;
+        }
+        nvals = sscanf(response, "%lf", &actualVelocity);
+        if (nvals != 1) {
+            return pC_->couldNotParseResponse("R14", response, axisNo_,
+                                              __PRETTY_FUNCTION__, __LINE__);
+        }
+
+        // Write the actual velocity to the paramLib (TODO: does it though?)
+        setAxisParamChecked(this, motorVelocity, actualVelocity);
+
+        // Motor is moving in velocity mode
+        *moving = true;
+
+    } else {
+
+        // 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 {
@@ -416,24 +587,14 @@ asynStatus masterMacsAxis::doPoll(bool *moving) {
         if (targetReached()) {
             pMasterMacsA_->targetReachedUninitialized = false;
         }
-
-    // Read the current position
-    rw_status = pC_->read(axisNo_, 12, response);
-    if (rw_status != asynSuccess) {
-        return rw_status;
-    }
-    nvals = sscanf(response, "%lf", &currentPosition);
-    if (nvals != 1) {
-        return pC_->couldNotParseResponse("R12", response, axisNo_,
-                                          __PRETTY_FUNCTION__, __LINE__);
     }
 
     /*
-    Read out the error if either a fault condition status flag has been set or
+    Read out the error if either a fault condition status flag has been set
-    if a movement has just ended.
+    or if a movement has just ended.
      */
     if (faultConditionSet() || !(*moving)) {
-        rw_status = readAxisError();
+        rwStatus = readAxisError();
     }
 
     msgPrintControlKey keyError = msgPrintControlKey(
@@ -610,48 +771,13 @@ asynStatus masterMacsAxis::doPoll(bool *moving) {
         pC_->getMsgPrintControl().resetCount(keyError, pC_->pasynUser());
     }
 
-    // Read out the limits, if the motor is not moving
+    // Read out the limits, if the motor is not moving and if the limits are
-    if (!(*moving)) {
+    // dynamic
-        rw_status = pC_->read(axisNo_, 34, response);
+    if (pMasterMacsA_->dynamicLimits && !(*moving)) {
-        if (rw_status != asynSuccess) {
+        rwStatus = readLimits();
-            return rw_status;
+        if (rwStatus != asynSuccess) {
+            return rwStatus;
         }
-        nvals = sscanf(response, "%lf", &lowLimit);
-        if (nvals != 1) {
-            return pC_->couldNotParseResponse("R34", response, axisNo_,
-                                              __PRETTY_FUNCTION__, __LINE__);
-        }
-
-        rw_status = pC_->read(axisNo_, 33, response);
-        if (rw_status != asynSuccess) {
-            return rw_status;
-        }
-        nvals = sscanf(response, "%lf", &highLimit);
-        if (nvals != 1) {
-            return pC_->couldNotParseResponse("R33", response, axisNo_,
-                                              __PRETTY_FUNCTION__, __LINE__);
-        }
-
-        /*
-        The axis limits are set as: ({[]})
-        where [] are the positive and negative limits set in EPICS/NICOS, {} are
-        the software limits set on the MCU and () are the hardware limit
-        switches. In other words, the EPICS/NICOS limits must be stricter than
-        the software limits on the MCU which in turn should be stricter than the
-        hardware limit switches. For example, if the hardware limit switches are
-        at [-10, 10], the software limits could be at [-9, 9] and the EPICS /
-        NICOS limits could be at
-        [-8, 8]. Therefore, we cannot use the software limits read from the MCU
-        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.
-        */
-        getAxisParamChecked(this, motorLimitsOffset, &limitsOffset);
-
-        highLimit = highLimit - limitsOffset;
-        lowLimit = lowLimit + limitsOffset;
-
-        setAxisParamChecked(this, motorHighLimitFromDriver, highLimit);
-        setAxisParamChecked(this, motorLowLimitFromDriver, lowLimit);
     }
 
     // Update the enable PV
@@ -675,22 +801,95 @@ asynStatus masterMacsAxis::doPoll(bool *moving) {
     setAxisParamChecked(this, motorStatusDone, !(*moving));
     setAxisParamChecked(this, motorStatusDirection, direction);
 
-    pl_status = setMotorPosition(currentPosition);
+    return poll_status;
-    if (pl_status != asynSuccess) {
-        return pl_status;
 }
 
-    return poll_status;
+asynStatus masterMacsAxis::moveVelocity(double minVelocity, double maxVelocity,
+                                        double acceleration) {
+    // Suppress unused variable warning
+    (void)minVelocity;
+    (void)acceleration;
+
+    // Status of read-write-operations of ASCII commands to the controller
+    asynStatus status = asynSuccess;
+
+    char command[pC_->MAXBUF_];
+
+    double motorRecResolution = 0.0;
+    double motorVelocity = 0.0;
+    int enabled = 0;
+
+    // =========================================================================
+
+    // Can the motor be operated in velocity mode?
+    if (!pMasterMacsA_->canVelocityMove) {
+        asynPrint(pC_->pasynUser(), ASYN_TRACE_ERROR,
+                  "Controller \"%s\", axis %d => %s, line %d:\nAxis cannot "
+                  "operate in velocity mode.\n",
+                  pC_->portName, axisNo_, __PRETTY_FUNCTION__, __LINE__);
+        setAxisParamChecked(this, motorStatusProblem, true);
+        setAxisParamChecked(this, motorMessageText,
+                            "cannot operate in velocity mode");
+        return asynError;
+    }
+
+    getAxisParamChecked(this, motorEnableRBV, &enabled);
+    getAxisParamChecked(this, motorRecResolution, &motorRecResolution);
+
+    if (enabled == 0) {
+        asynPrint(pC_->pasynUser(), ASYN_TRACE_ERROR,
+                  "Controller \"%s\", axis %d => %s, line %d:\nAxis is "
+                  "disabled.\n",
+                  pC_->portName, axisNo_, __PRETTY_FUNCTION__, __LINE__);
+        return asynSuccess;
+    }
+
+    // Convert from EPICS to user / motor units
+    motorVelocity = maxVelocity * motorRecResolution;
+
+    snprintf(command, sizeof(command), "%lf", motorVelocity);
+    status = pC_->write(axisNo_, 05, command);
+    if (status != asynSuccess) {
+        setAxisParamChecked(this, motorStatusProblem, true);
+        return status;
+    }
+
+    asynPrint(pC_->pasynUser(), ASYN_TRACE_FLOW,
+              "Controller \"%s\", axis %d => %s, line %d:\nSetting speed "
+              "to %lf.\n",
+              pC_->portName, axisNo_, __PRETTY_FUNCTION__, __LINE__,
+              motorVelocity);
+
+    double timeout = pC_->comTimeout();
+    if (pMasterMacsA_->targetReachedUninitialized &&
+        timeout < PowerCycleTimeout) {
+        timeout = PowerCycleTimeout;
+    }
+
+    // Start the move. We do not use the MovTimeout watchdog here, because the
+    // motor can move for any time in velocity mode.
+    status = pC_->write(axisNo_, 00, "3", timeout);
+    if (status != asynSuccess) {
+        return status;
+    }
+
+    // Cache the information that the current movement is in velocity mode
+    pMasterMacsA_->lastMoveCommand = velocityMode;
+    return status;
 }
 
 asynStatus masterMacsAxis::doMove(double position, int relative,
                                   double minVelocity, double maxVelocity,
                                   double acceleration) {
 
+    // Suppress unused variable warning
+    (void)minVelocity;
+    (void)acceleration;
+
     // Status of read-write-operations of ASCII commands to the controller
     asynStatus status = asynSuccess;
 
-    char value[pC_->MAXBUF_];
+    char command[pC_->MAXBUF_];
     double motorCoordinatesPosition = 0.0;
     double motorRecResolution = 0.0;
     double motorVelocity = 0.0;
@@ -699,6 +898,18 @@ asynStatus masterMacsAxis::doMove(double position, int relative,
 
     // =========================================================================
 
+    // Can the motor be operated in position mode?
+    if (!pMasterMacsA_->canPositionMove) {
+        asynPrint(pC_->pasynUser(), ASYN_TRACE_ERROR,
+                  "Controller \"%s\", axis %d => %s, line %d:\nAxis cannot "
+                  "operate in position mode.\n",
+                  pC_->portName, axisNo_, __PRETTY_FUNCTION__, __LINE__);
+        setAxisParamChecked(this, motorStatusProblem, true);
+        setAxisParamChecked(this, motorMessageText,
+                            "cannot operate in position mode");
+        return asynError;
+    }
+
     getAxisParamChecked(this, motorEnableRBV, &enabled);
     getAxisParamChecked(this, motorRecResolution, &motorRecResolution);
 
@@ -733,8 +944,8 @@ asynStatus masterMacsAxis::doMove(double position, int relative,
     // motor speed changed since the last move command.
     if (motorCanSetSpeed != 0) {
 
-        snprintf(value, sizeof(value), "%lf", motorVelocity);
+        snprintf(command, sizeof(command), "%lf", motorVelocity);
-        status = pC_->write(axisNo_, 05, value);
+        status = pC_->write(axisNo_, 05, command);
         if (status != asynSuccess) {
             setAxisParamChecked(this, motorStatusProblem, true);
             return status;
@@ -748,14 +959,14 @@ asynStatus masterMacsAxis::doMove(double position, int relative,
     }
 
     // Set the target position
-    snprintf(value, sizeof(value), "%lf", motorCoordinatesPosition);
+    snprintf(command, sizeof(command), "%lf", motorCoordinatesPosition);
-    status = pC_->write(axisNo_, 02, value);
+    status = pC_->write(axisNo_, 02, command);
     if (status != asynSuccess) {
         setAxisParamChecked(this, motorStatusProblem, true);
         return status;
     }
 
-    // If the motor has just been enabled, use Enable
+    // If the motor has just been enabled, use a longer timeout for starting
     double timeout = pC_->comTimeout();
     if (pMasterMacsA_->targetReachedUninitialized &&
         timeout < PowerCycleTimeout) {
@@ -784,11 +995,16 @@ asynStatus masterMacsAxis::doMove(double position, int relative,
         return asynError;
     }
 
+    // Cache the information that the current movement is in position mode
+    pMasterMacsA_->lastMoveCommand = positionMode;
     return status;
 }
 
 asynStatus masterMacsAxis::stop(double acceleration) {
 
+    // Suppress unused variable warning
+    (void)acceleration;
+
     asynStatus status = pC_->write(axisNo_, 00, "8");
     if (status != asynSuccess) {
         setAxisParamChecked(this, motorStatusProblem, true);
@@ -805,15 +1021,26 @@ asynStatus masterMacsAxis::doReset() {
 
     asynStatus status = asynSuccess;
 
-    // Reset the controller ("node reset")
+    // Reset any errors
-    status = pC_->write(axisNo_, 16, "");
+    status = pC_->write(axisNo_, 17, "");
     if (status != asynSuccess) {
         setAxisParamChecked(this, motorStatusProblem, true);
     }
 
-    // Reset any errors in the controller. Since the node reset results in a
+    // Move out of the handshake wait loop, if we're currently inside it.
+    pMasterMacsA_->waitForHandshake = false;
+
+    // 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_, 17, "", PowerCycleTimeout);
+    status = pC_->write(axisNo_, 16, "", PowerCycleTimeout);
     if (status != asynSuccess) {
         setAxisParamChecked(this, motorStatusProblem, true);
     }
@@ -833,13 +1060,19 @@ asynStatus masterMacsAxis::doReset() {
 /*
 Home the axis. On absolute encoder systems, this is a no-op
 */
-asynStatus masterMacsAxis::doHome(double min_velocity, double max_velocity,
+asynStatus masterMacsAxis::doHome(double minVelocity, double maxVelocity,
                                   double acceleration, int forwards) {
 
     char response[pC_->MAXBUF_] = {0};
 
     // =========================================================================
 
+    // Suppress unused variable warning
+    (void)minVelocity;
+    (void)maxVelocity;
+    (void)acceleration;
+    (void)forwards;
+
     getAxisParamChecked(this, encoderType, &response);
 
     // Only send the home command if the axis has an incremental encoder
@@ -893,7 +1126,7 @@ asynStatus masterMacsAxis::readEncoderType() {
 
     /*
     Defined encoder IDs:
-    0=INC (Incremental)
+    0=INC (Incremental or no encoder)
     1=SSI (Absolute encoder with SSI interface)
     2=SSI (Absolute encoder with BiSS interface)
      */
@@ -930,9 +1163,7 @@ asynStatus masterMacsAxis::enable(bool on) {
     doPoll(&moving);
 
     // If the axis is currently moving, it cannot be disabled. Ignore the
-    // command and inform the user. We check the last known status of the
+    // command and inform the user.
-    // axis instead of "moving", since status -6 is also moving, but the
-    // motor can actually be disabled in this state!
     if (moving) {
         asynPrint(pC_->pasynUser(), ASYN_TRACE_ERROR,
                   "Controller \"%s\", axis %d => %s, line %d:\nAxis is not "
@@ -1014,6 +1245,28 @@ asynStatus masterMacsAxis::enable(bool on) {
     return asynError;
 }
 
+asynStatus masterMacsAxis::setMode(int mode) {
+
+    char command[pC_->MAXBUF_] = {0};
+
+    // Map the EPICS value to MasterMACS values (see
+    // MasterMACS_manual.pdf).
+    int adjustedMode = 0;
+    if (mode == 0) {
+        adjustedMode = 1;
+    } else if (mode == 1) {
+        adjustedMode = 3;
+    } else {
+        // This branch is unreachable, as it is is already checked
+        // within sinqController::writeInt32 that value is either 0
+        // or 1.
+        return asynError;
+    }
+
+    snprintf(command, sizeof(command), "%d", adjustedMode);
+    return pC_->write(axisNo(), 07, command);
+}
+
 bool masterMacsAxis::needInit() { return pMasterMacsA_->needInit; }
 
 /**
@@ -1044,8 +1297,8 @@ asynStatus masterMacsAxis::readAxisStatus() {
 
     // =========================================================================
 
-    asynStatus rw_status = pC_->read(axisNo_, 10, response);
+    asynStatus rwStatus = pC_->read(axisNo_, 10, response);
-    if (rw_status == asynSuccess) {
+    if (rwStatus == asynSuccess) {
 
         float axisStatus = 0;
         int nvals = sscanf(response, "%f", &axisStatus);
@@ -1057,7 +1310,7 @@ asynStatus masterMacsAxis::readAxisStatus() {
         pMasterMacsA_->axisStatus = toBitset(axisStatus);
     }
 
-    return rw_status;
+    return rwStatus;
 }
 
 asynStatus masterMacsAxis::readAxisError() {
@@ -1065,8 +1318,8 @@ asynStatus masterMacsAxis::readAxisError() {
 
     // =========================================================================
 
-    asynStatus rw_status = pC_->read(axisNo_, 11, response);
+    asynStatus rwStatus = pC_->read(axisNo_, 11, response);
-    if (rw_status == asynSuccess) {
+    if (rwStatus == asynSuccess) {
 
         float axisError = 0;
         int nvals = sscanf(response, "%f", &axisError);
@@ -1076,7 +1329,7 @@ asynStatus masterMacsAxis::readAxisError() {
         }
         pMasterMacsA_->axisError = toBitset(axisError);
     }
-    return rw_status;
+    return rwStatus;
 }
 
 bool masterMacsAxis::readyToBeSwitchedOn() {
@@ -1103,6 +1356,8 @@ bool masterMacsAxis::remoteMode() { return pMasterMacsA_->axisStatus[9]; }
 
 bool masterMacsAxis::targetReached() { return pMasterMacsA_->axisStatus[10]; }
 
+bool masterMacsAxis::speedEqualZero() { return pMasterMacsA_->axisStatus[12]; }
+
 bool masterMacsAxis::internalLimitActive() {
     return pMasterMacsA_->axisStatus[11];
 }
@@ -1234,8 +1489,9 @@ static const iocshArg CreateAxisArg0 = {"Controller name (e.g. mmacs1)",
 static const iocshArg CreateAxisArg1 = {"Axis number", iocshArgInt};
 static const iocshArg *const CreateAxisArgs[] = {&CreateAxisArg0,
                                                  &CreateAxisArg1};
-static const iocshFuncDef configMasterMacsCreateAxis = {"masterMacsAxis", 2,
+static const iocshFuncDef configMasterMacsCreateAxis = {
-                                                        CreateAxisArgs};
+    "masterMacsAxis", 2, CreateAxisArgs,
+    "Create a new instance of a MasterMACS axis."};
 static void configMasterMacsCreateAxisCallFunc(const iocshArgBuf *args) {
     masterMacsCreateAxis(args[0].sval, args[1].ival);
 }

src/masterMacsAxis.h

@@ -16,6 +16,13 @@ class HIDDEN masterMacsAxis : public sinqAxis {
      */
     masterMacsAxis(masterMacsController *pController, int axisNo);
 
+    /**
+     * @brief Delete the copy and copy assignment constructors, because this
+     * class should not be copied (it is tied to hardware!)
+     */
+    masterMacsAxis(const masterMacsAxis &) = delete;
+    masterMacsAxis &operator=(const masterMacsAxis &) = delete;
+
     /**
      * @brief Destroy the masterMacsAxis
      *
@@ -44,19 +51,30 @@ class HIDDEN masterMacsAxis : public sinqAxis {
      */
     asynStatus doPoll(bool *moving);
 
+    /**
+     * @brief TODO
+     *
+     * @param minVelocity
+     * @param maxVelocity
+     * @param acceleration
+     * @return asynStatus
+     */
+    asynStatus moveVelocity(double minVelocity, double maxVelocity,
+                            double acceleration);
+
     /**
      * @brief Implementation of the `doMove` function from sinqAxis. The
      * parameters are described in the documentation of `sinqAxis::doMove`.
      *
      * @param position
      * @param relative
-     * @param min_velocity
+     * @param minVelocity
-     * @param max_velocity
+     * @param maxVelocity
      * @param acceleration
      * @return asynStatus
      */
-    asynStatus doMove(double position, int relative, double min_velocity,
+    asynStatus doMove(double position, int relative, double minVelocity,
-                      double max_velocity, double acceleration);
+                      double maxVelocity, double acceleration);
 
     /**
      * @brief Implementation of the `stop` function from asynMotorAxis
@@ -75,12 +93,27 @@ class HIDDEN 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
+     * - Read out the motor status, motor position, velocity and
-     * from the MCU and store this information in the parameter library.
+     * 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
@@ -96,8 +129,17 @@ class HIDDEN masterMacsAxis : public sinqAxis {
     asynStatus enable(bool on);
 
     /**
-     * @brief Read the encoder type (incremental or absolute) for this axis from
+     * @brief Write the new operation mode (position or velocity) to the
-     * the MCU and store the information in the PV ENCODER_TYPE.
+     * MasterMACS controller.
+     *
+     * @param mode
+     * @return asynStatus
+     */
+    asynStatus setMode(int mode);
+
+    /**
+     * @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
      */
@@ -112,7 +154,8 @@ class HIDDEN 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
      */
@@ -124,164 +167,204 @@ class HIDDEN masterMacsAxis : public sinqAxis {
     virtual masterMacsController *pController() override { return pC_; };
 
     /**
-     * @brief Read the Master MACS status with the xR10 command and store the
+     * @brief Read the Master MACS status with the xR10 command and store
-     * result in axisStatus_
+     * the result in axisStatus (see masterMacsAxisImpl redefinition in
+     * masterMacsAxis.cpp)
      *
      */
     asynStatus readAxisStatus();
 
+    /**
+     * @brief Read the upper and lower limits and store them in the parameter
+     * library.
+     */
+    asynStatus readLimits();
+
     /*
-    The functions below read the specified status bit from the axisStatus
+    The functions below read the specified status bit from the axisStatus (see
-    bitset. Since a bit can either be 0 or 1, the return value is given as a
+    masterMacsAxisImpl redefinition in masterMacsAxis.cpp) bitset. Since a bit
-    boolean.
+    can either be 0 or 1, the return value is given as a boolean.
     */
 
     /**
-     * @brief Read the property from axisStatus_
+     * @brief Read the property from axisStatus (see masterMacsAxisImpl
+     * redefinition in masterMacsAxis.cpp)
      */
     bool readyToBeSwitchedOn();
 
     /**
-     * @brief Read the property from axisStatus_
+     * @brief Read the property from axisStatus (see masterMacsAxisImpl
+     * redefinition in masterMacsAxis.cpp)
      */
     bool switchedOn();
 
     // Bit 2 is unused
 
     /**
-     * @brief Read the property from axisStatus_
+     * @brief Read the property from axisStatus (see masterMacsAxisImpl
+     * redefinition in masterMacsAxis.cpp)
      */
     bool faultConditionSet();
 
     /**
-     * @brief Read the property from axisStatus_
+     * @brief Read the property from axisStatus (see masterMacsAxisImpl
+     * redefinition in masterMacsAxis.cpp)
      */
     bool voltagePresent();
 
     /**
-     * @brief Read the property from axisStatus_
+     * @brief Read the property from axisStatus (see masterMacsAxisImpl
+     * redefinition in masterMacsAxis.cpp)
      */
     bool quickStopping();
 
     /**
-     * @brief Read the property from axisStatus_
+     * @brief Read the property from axisStatus (see masterMacsAxisImpl
+     * redefinition in masterMacsAxis.cpp)
      */
     bool switchOnDisabled();
 
     /**
-     * @brief Read the property from axisStatus_
+     * @brief Read the property from axisStatus (see masterMacsAxisImpl
+     * redefinition in masterMacsAxis.cpp)
      */
     bool warning();
 
     // Bit 8 is unused
 
     /**
-     * @brief Read the property from axisStatus_
+     * @brief Read the property from axisStatus (see masterMacsAxisImpl
+     * redefinition in masterMacsAxis.cpp)
      */
     bool remoteMode();
 
     /**
-     * @brief Read the property from axisStatus_
+     * @brief Read the property from axisStatus (see masterMacsAxisImpl
+     * redefinition in masterMacsAxis.cpp)
      */
     bool targetReached();
 
     /**
-     * @brief Read the property from axisStatus_
+     * @brief Read the property from axisStatus (see masterMacsAxisImpl
+     * redefinition in masterMacsAxis.cpp)
      */
     bool internalLimitActive();
 
+    /**
+     * @brief Read the property from axisStatus (see masterMacsAxisImpl
+     * redefinition in masterMacsAxis.cpp)
+     */
+    bool speedEqualZero();
+
     // Bits 12 and 13 are unused
 
     /**
-     * @brief Read the property from axisStatus_
+     * @brief Read the property from axisStatus (see masterMacsAxisImpl
+     * redefinition in masterMacsAxis.cpp)
      */
     bool setEventHasOcurred();
 
     /**
-     * @brief Read the property from axisStatus_
+     * @brief Read the property from axisStatus (see masterMacsAxisImpl
+     * redefinition in masterMacsAxis.cpp)
      */
     bool powerEnabled();
 
     /**
-     * @brief Read the Master MACS status with the xR10 command and store the
+     * @brief Read the Master MACS error with the xR10 command and store
-     * result in axisStatus_
+     * the result in axisError (see masterMacsAxisImpl redefinition in
+     * masterMacsAxis.cpp)
      *
      */
     asynStatus readAxisError();
 
     /*
-    The functions below read the specified error bit from the axisError_
+    The functions below read the specified error bit from the axisError (see
-    bitset. Since a bit can either be 0 or 1, the return value is given as a
+    masterMacsAxisImpl redefinition in masterMacsAxis.cpp) bitset. Since a bit
-    boolean.
+    can either be 0 or 1, the return value is given as a boolean.
     */
 
     /**
-     * @brief Read the property from axisError_
+     * @brief Read the property from axisError (see masterMacsAxisImpl
+     * redefinition in masterMacsAxis.cpp)
      */
     bool shortCircuit();
 
     /**
-     * @brief Read the property from axisError_
+     * @brief Read the property from axisError (see masterMacsAxisImpl
+     * redefinition in masterMacsAxis.cpp)
      */
     bool encoderError();
 
     /**
-     * @brief Read the property from axisError_
+     * @brief Read the property from axisError (see masterMacsAxisImpl
+     * redefinition in masterMacsAxis.cpp)
      */
     bool followingError();
 
     /**
-     * @brief Read the property from axisError_
+     * @brief Read the property from axisError (see masterMacsAxisImpl
+     * redefinition in masterMacsAxis.cpp)
      */
     bool communicationError();
 
     /**
-     * @brief Read the property from axisError_
+     * @brief Read the property from axisError (see masterMacsAxisImpl
+     * redefinition in masterMacsAxis.cpp)
      */
     bool feedbackError();
 
     /**
-     * @brief Read the property from axisError_
+     * @brief Read the property from axisError (see masterMacsAxisImpl
+     * redefinition in masterMacsAxis.cpp)
      */
     bool positiveLimitSwitch();
 
     /**
-     * @brief Read the property from axisError_
+     * @brief Read the property from axisError (see masterMacsAxisImpl
+     * redefinition in masterMacsAxis.cpp)
      */
     bool negativeLimitSwitch();
 
     /**
-     * @brief Read the property from axisError_
+     * @brief Read the property from axisError (see masterMacsAxisImpl
+     * redefinition in masterMacsAxis.cpp)
      */
     bool positiveSoftwareLimit();
 
     /**
-     * @brief Read the property from axisError_
+     * @brief Read the property from axisError (see masterMacsAxisImpl
+     * redefinition in masterMacsAxis.cpp)
      */
     bool negativeSoftwareLimit();
 
     /**
-     * @brief Read the property from axisError_
+     * @brief Read the property from axisError (see masterMacsAxisImpl
+     * redefinition in masterMacsAxis.cpp)
      */
     bool overCurrent();
 
     /**
-     * @brief Read the property from axisError_
+     * @brief Read the property from axisError (see masterMacsAxisImpl
+     * redefinition in masterMacsAxis.cpp)
      */
     bool overTemperature();
 
     /**
-     * @brief Read the property from axisError_
+     * @brief Read the property from axisError (see masterMacsAxisImpl
+     * redefinition in masterMacsAxis.cpp)
      */
     bool overVoltage();
 
     /**
-     * @brief Read the property from axisError_
+     * @brief Read the property from axisError (see masterMacsAxisImpl
+     * redefinition in masterMacsAxis.cpp)
      */
     bool underVoltage();
 
     /**
-     * @brief Read the property from axisError_
+     * @brief Read the property from axisError (see masterMacsAxisImpl
+     * redefinition in masterMacsAxis.cpp)
      */
     bool stoFault();
 

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;
 };
 
 /**
@@ -56,17 +81,32 @@ masterMacsController::masterMacsController(const char *portName,
     : sinqController(portName, ipPortConfigName, numAxes, movingPollPeriod,
                      idlePollPeriod,
                      // No additional parameter library entries
-                     0)
+                     0),
+      pMasterMacsC_(
+          std::make_unique<masterMacsControllerImpl>((masterMacsControllerImpl){
+              .comTimeout = comTimeout,
+              .nodeReset = 0, // Overwritten later
+          }))
 
 {
 
     // Initialization of local variables
     asynStatus status = asynSuccess;
+    char response[MAXBUF_] = {0};
 
-    pMasterMacsC_ =
+    // =========================================================================
-        std::make_unique<masterMacsControllerImpl>((masterMacsControllerImpl){
+    // Create additional parameter library entries
-            .comTimeout = comTimeout,
+
-        });
+    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,8 +214,24 @@ 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) {
+                                      double /*comTimeout*/) {
     return writeRead(axisNo, tcpCmd, NULL, response);
 }
 
@@ -166,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);
@@ -253,17 +357,23 @@ asynStatus masterMacsController::writeRead(int axisNo, int tcpCmd,
     }
 
     // Log the overall status (communication successfull or not)
+    if (axisNo != 0) {
+        masterMacsAxis *axis = getMasterMacsAxis(axisNo);
+        if (axis == nullptr) {
+            // We already did the error logging directly in getAxis
+            return asynError;
+        }
+
         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
+            cannot be sure that the information read out in the init method of
-        axis is still up-to-date the next time we get a connection. Therefore,
+            the axis is still up-to-date the next time we get a connection.
-        an info flag is set which the axis object can use at the start of its
+            Therefore, an info flag is set which the axis object can use at the
-        poll method to try to initialize itself.
+            start of its poll method to try to initialize itself.
             */
             axis->setNeedInit(true);
 
@@ -281,6 +391,7 @@ asynStatus masterMacsController::writeRead(int axisNo, int tcpCmd,
                 setAxisParamChecked(axis, motorStatusCommsError, false);
             }
         }
+    }
 
     return status;
 }
@@ -301,7 +412,7 @@ 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};
 
@@ -309,15 +420,15 @@ asynStatus masterMacsController::parseResponse(
         msgPrintControlKey(portName, axisNo, __PRETTY_FUNCTION__, __LINE__);
 
     masterMacsAxis *axis = getMasterMacsAxis(axisNo);
-    if (axis == nullptr) {
+    if (axisNo != 0 && axis == nullptr) {
         return asynError;
     }
 
     // Was the motor previously connected?
+    if (axis != nullptr) {
         getAxisParamChecked(axis, motorConnected, &prevConnected);
+    }
 
-    // We don't use strlen here since the C string terminator 0x00
-    // occurs in the middle of the char array.
     for (uint32_t i = 0; i < MAXBUF_; i++) {
         if (fullResponse[i] == '\x19') {
             responseStart = i;
@@ -338,16 +449,19 @@ asynStatus masterMacsController::parseResponse(
                           "connected.\n",
                           portName, axisNo, __PRETTY_FUNCTION__, __LINE__);
 
+                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__);
+                                  portName, axisNo, __PRETTY_FUNCTION__,
+                                  __LINE__);
                         return status;
                     }
                 }
+            }
 
             break;
         } else if (fullResponse[i] == '\x15') {
@@ -366,16 +480,19 @@ asynStatus masterMacsController::parseResponse(
                           "disconnected.\n",
                           portName, axisNo, __PRETTY_FUNCTION__, __LINE__);
 
+                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__);
+                                  portName, axisNo, __PRETTY_FUNCTION__,
+                                  __LINE__);
                         return status;
                     }
                 }
+            }
             break;
         } else if (fullResponse[i] == '\x18') {
             // CAN
@@ -453,12 +570,14 @@ asynStatus masterMacsController::readInt32(asynUser *pasynUser,
         *value = 1;
         return asynSuccess;
     } else {
-        return asynMotorController::readInt32(pasynUser, value);
+        return sinqController::readInt32(pasynUser, value);
     }
 }
 
 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 */
@@ -518,7 +637,8 @@ static const iocshArg *const CreateControllerArgs[] = {
     &CreateControllerArg0, &CreateControllerArg1, &CreateControllerArg2,
     &CreateControllerArg3, &CreateControllerArg4, &CreateControllerArg5};
 static const iocshFuncDef configMasterMacsCreateController = {
-    "masterMacsController", 6, CreateControllerArgs};
+    "masterMacsController", 6, CreateControllerArgs,
+    "Create a new instance of a MasterMACS controller."};
 static void configMasterMacsCreateControllerCallFunc(const iocshArgBuf *args) {
     masterMacsCreateController(args[0].sval, args[1].sval, args[2].ival,
                                args[3].dval, args[4].dval, args[5].dval);

src/masterMacsController.h

@@ -38,6 +38,13 @@ class HIDDEN masterMacsController : public sinqController {
                          int numAxes, double movingPollPeriod,
                          double idlePollPeriod, double comTimeout);
 
+    /**
+     * @brief Delete the copy and copy assignment constructors, because this
+     * class should not be copied (it is tied to hardware!)
+     */
+    masterMacsController(const masterMacsController &) = delete;
+    masterMacsController &operator=(const masterMacsController &) = delete;
+
     /**
      * @brief Overloaded version of the sinqController version
      *
@@ -65,6 +72,18 @@ class HIDDEN masterMacsController : public sinqController {
      */
     masterMacsAxis *getMasterMacsAxis(int axisNo);
 
+    /**
+     * @brief Overloaded function of sinqController
+     *
+     * The function is overloaded to allow resetting the node and changing the
+     * operation mode.
+     *
+     * @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)
      *
@@ -141,6 +160,9 @@ class HIDDEN masterMacsController : public sinqController {
      */
     double comTimeout();
 
+    // Accessors for additional PVs
+    int nodeReset();
+
   private:
     std::unique_ptr<masterMacsControllerImpl> pMasterMacsC_;
 };

utils/decodeError.py

@@ -9,6 +9,8 @@ To read the manual, simply run this script without any arguments.
 Stefan Mathis, January 2025
 """
 
+import platform
+
 from decodeCommon import interactive, decode, print_decoded
 
 # List of tuples which encodes the states given in the file description.
@@ -32,20 +34,7 @@ interpretation = [
     ("Ok", "STO fault (STO input is on disable state)"),  # Bit 15
 ]
 
-if __name__ == "__main__":
+help = """
-    from sys import argv
-
-    if len(argv) == 1:
-        # Start interactive mode
-        interactive()
-    else:
-
-        number = None
-        try:
-            number = int(float(argv[1]))
-
-        except:
-            print("""
 Decode R11 message of MasterMACs
 ------------------
     
@@ -63,19 +52,39 @@ if __name__ == "__main__":
 'value' is the return value of a R11 command. This value is interpreted
 bit-wise and the result is printed out.
 
-            Option 2: CLI Mode
+Option 2: CLI Mode (Linux-only)
-            ------------------       
+-------------------------------
 
 Usage: decodeError.py
 
+ONLY AVAILABLE ON LINUX!
+
 A prompt will be opened. Type in the return value of a R11 command, hit
 enter and the interpretation will be printed in the prompt. After that,
 the next value can be typed in. Type 'quit' to close the prompt.
-            """)
+"""
 
+if __name__ == "__main__":
+    from sys import argv
 
+    if "-h" or "--help" in argv:
+        print(help)
+
+    if len(argv) == 1:
+        # Start interactive mode
+        if platform.system() == "Linux":
+            interactive()
+        else:
+            print(help)
+    else:
+
+        number = None
+        try:
+            number = int(float(argv[1]))
+        except:
+            print(help)
         if number is not None:
             print("Motor error")
-            print("============")
+            print("===========")
             (bit_list, interpreted) = decode(number, interpretation)
             print_decoded(bit_list, interpreted)

utils/decodeStatus.py

@@ -9,6 +9,8 @@ To read the manual, simply run this script without any arguments.
 Stefan Mathis, December 2024
 """
 
+import platform
+
 from decodeCommon import interactive, decode, print_decoded
 
 # List of tuples which encodes the states given in the file description.
@@ -23,7 +25,8 @@ interpretation = [
     ("Switch on enabled", "Switch on disabled"),  # Bit 6
     ("Ok", "Warning: Movement function was called while motor is still moving. The function call is ignored"),  # Bit 7
     ("Not specified", "Not specified"),  # Bit 8
-    ("Motor does not execute command messages (local mode)", "Motor does execute command messages (remote mode)"), # Bit 9
+    ("Motor does not execute command messages (local mode)",
+     "Motor does execute command messages (remote mode)"),  # Bit 9
     ("Target not reached", "Target reached"),  # Bit 10
     ("Ok", "Internal limit active (current, voltage, velocity or position)"),  # Bit 11
     ("Not specified", "Not specified"),  # Bit 12
@@ -32,20 +35,7 @@ interpretation = [
     ("Not specified", "Not specified"),  # Bit 15
 ]
 
-if __name__ == "__main__":
+help = """
-    from sys import argv
-
-    if len(argv) == 1:
-        # Start interactive mode
-        interactive()
-    else:
-
-        number = None
-        try:
-            number = int(float(argv[1]))
-
-        except:
-            print("""
 Decode R10 message of MasterMACs
 ------------------
     
@@ -63,17 +53,37 @@ if __name__ == "__main__":
 'value' is the return value of a R10 command. This value is interpreted
 bit-wise and the result is printed out.
 
-            Option 2: CLI Mode
+Option 2: CLI Mode (Linux-only)
-            ------------------       
+-------------------------------
 
 Usage: decodeStatus.py
 
+ONLY AVAILABLE ON LINUX!
+
 A prompt will be opened. Type in the return value of a R10 command, hit
 enter and the interpretation will be printed in the prompt. After that,
 the next value can be typed in. Type 'quit' to close the prompt.
-            """)
+"""
 
+if __name__ == "__main__":
+    from sys import argv
 
+    if "-h" or "--help" in argv:
+        print(help)
+
+    if len(argv) == 1:
+        # Start interactive mode
+        if platform.system() == "Linux":
+            interactive()
+        else:
+            print(help)
+    else:
+
+        number = None
+        try:
+            number = int(float(argv[1]))
+        except:
+            print(help)
         if number is not None:
             print("Motor status")
             print("============")

utils/writeRead.py

@@ -6,9 +6,32 @@ To read the manual, simply run this script without any arguments.
 Stefan Mathis, April 2025
 """
 
+import platform
+
 import struct
 import socket
-import curses
+
+help = """
+Send commands to and receive replies from MasterMACS controllers
+
+Option 1: Single Command
+------------------------
+
+Usage: writeRead.py pmachost:port command
+This then returns the response for command. 
+
+Option 2: CLI Mode (Linux-only)
+-------------------------------
+
+Usage: writeRead.py pmachost:port
+
+ONLY AVAILABLE ON LINUX!
+
+You can then type in a command, hit enter, and the response will see
+the reponse, before being prompted to again enter a command. Type
+'quit' to close prompt.
+"""
+
 
 def packMasterMacsCommand(command):
     # 0x0D = Carriage return
@@ -16,6 +39,7 @@ def packMasterMacsCommand(command):
     buf = bytes(command, 'utf-8') + buf
     return bytes(command, 'utf-8')
 
+
 def readMasterMacsReply(input):
     msg = bytearray()
     expectAck = True
@@ -33,24 +57,21 @@ def readMasterMacsReply(input):
             else:
                 msg.append(bint)
 
+
 if __name__ == "__main__":
     from sys import argv
 
-    try:
+    if "-h" or "--help" in argv:
-
+        print(help)
+    else:
         addr = argv[1].split(':')
         s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         s.connect((addr[0], int(addr[1])))
 
-        if len(argv) == 3:
+        if len(argv) == 2:
-            buf = packMasterMacsCommand(argv[2])
-            s.send(buf)
-            reply = readMasterMacsReply(s)
-            print(reply.decode('utf-8') + '\n')
 
-        else:
+            if platform.system() == "Linux":
-
+                import curses
-            try:
 
                 stdscr = curses.initscr()
                 curses.noecho()
@@ -125,7 +146,8 @@ if __name__ == "__main__":
                             if len(history[ptr]) == 0:
                                 continue
                             (y, x) = stdscr.getyx()
-                            history[ptr] = history[ptr][0:x-4] + history[ptr][x-3:]
+                            history[ptr] = history[ptr][0:x-4] + \
+                                history[ptr][x-3:]
                             stdscr.addch("\r")
                             stdscr.clrtoeol()
                             stdscr.addstr(">> " + history[ptr])
@@ -134,38 +156,24 @@ if __name__ == "__main__":
 
                         else:
                             (y, x) = stdscr.getyx()
-                            history[ptr] = history[ptr][0:x-3] + chr(c) + history[ptr][x-3:]
+                            history[ptr] = history[ptr][0:x-3] + \
+                                chr(c) + history[ptr][x-3:]
                             stdscr.addch("\r")
                             stdscr.clrtoeol()
                             stdscr.addstr(">> " + history[ptr])
                             stdscr.move(y, x+1)
                             stdscr.refresh()
-
-            finally:
-
                     # to quit
                     curses.nocbreak()
                     stdscr.keypad(False)
                     curses.echo()
                     curses.endwin()
-
+            else:
-    except:
+                print(help)
-        print("""
+        elif len(argv) == 3:
-        Invalid Arguments
+            buf = packMasterMacsCommand(argv[2])
-
+            s.send(buf)
-        Option 1: Single Command
+            reply = readMasterMacsReply(s)
-        ------------------------
+            print(reply.decode('utf-8') + '\n')
-
+        else:
-        Usage: writeRead.py pmachost:port command
+            print(help)
-        This then returns the response for command. 
-
-        Option 2: CLI Mode
-        ------------------
-
-        Usage: writeRead.py pmachost:port
-
-        You can then type in a command, hit enter, and the response will see
-        the reponse, before being prompted to again enter a command. Type
-        'quit' to close prompt.
-        """)
-