Ignore limit switch errors when the motor is homing or has been homed

Integrated a readout function for the position deadband. Also read from
the controller if the axis has dynamic limits and only poll the limits
repeatedly if that is the case. Lastly, added support for the velocity
mode (untested!).

.gitignore

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

Makefile

@@ -9,6 +9,8 @@ ARCH_FILTER=RHEL%
 # Specify the version of asynMotor we want to build against
 motorBase_VERSION=7.2.2
 
+LIBVERSION=homeerror
+
 # These headers allow to depend on this library for derived drivers.
 HEADERS += src/masterMacsAxis.h
 HEADERS += src/masterMacsController.h
@@ -30,7 +32,8 @@ DBDS += sinqMotor/src/sinqMotor.dbd
 DBDS += src/masterMacs.dbd
 
 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 -Wall -Wextra -Weffc++ -Wunused-result -Wextra
+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,6 +89,8 @@ 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.

db/masterMacs.db

@@ -5,3 +5,13 @@ record(longout, "$(INSTR)$(M):NodeReset") {
     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

@@ -23,6 +23,7 @@ struct masterMacsAxisImpl {
     time_t timeAtHandshake;
     bool needInit = true;
     bool targetReachedUninitialized;
+    bool dynamicLimits;
 };
 
 /*
@@ -92,6 +93,7 @@ masterMacsAxis::masterMacsAxis(masterMacsController *pC, int axisNo)
           .waitForHandshake = false,
           .timeAtHandshake = 0,
           .targetReachedUninitialized = true,
+          .dynamicLimits = false,
       })) {
 
     asynStatus status = asynSuccess;
@@ -179,14 +181,18 @@ 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 motMode = 0;
+    int dynamicLimits = 0;
+    int motCanSetMode = 0;
 
     // =========================================================================
 
@@ -195,9 +201,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 "
@@ -206,83 +212,145 @@ 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(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 the current motor mode
+    status = pC_->read(axisNo_, 07, response);
+    if (status != asynSuccess) {
+        return status;
+    }
+    nvals = sscanf(response, "%d", &motMode);
+    if (nvals != 1) {
+        return pC_->couldNotParseResponse("R07", response, axisNo_,
+                                          __PRETTY_FUNCTION__, __LINE__);
     }
 
-    pl_status = readEncoderType();
+    // If the readback value from the controller is 3, it is in velocity mode,
-    if (pl_status != asynSuccess) {
+    // which sinqMotor encodes as a 1. Otherwise, it is in position mode.
-        return pl_status;
+    setAxisParamChecked(this, motorMode, motMode == 3);
+
+    // Check if the motor can switch its mode
+    status = pC_->read(axisNo_, 31, response);
+    if (status != asynSuccess) {
+        return status;
+    }
+    nvals = sscanf(response, "%d", &motCanSetMode);
+    if (nvals != 1) {
+        return pC_->couldNotParseResponse("R31", response, axisNo_,
+                                          __PRETTY_FUNCTION__, __LINE__);
+    }
+
+    // If the readback value from the controller is 3, the motor supports both
+    // velocity and position mode, otherwise just one of them (the one read out
+    // with motMode).
+    setAxisParamChecked(this, motorCanSetMode, motCanSetMode == 3);
+
+    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
@@ -290,14 +358,71 @@ 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;
+
+    setAxisParamChecked(this, motorHighLimitFromDriver, highLimit);
+    setAxisParamChecked(this, motorLowLimitFromDriver, lowLimit);
+
+    return status;
 }
 
 // Perform the actual poll
@@ -320,16 +445,14 @@ 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()) {
-	// Perform the rest of the poll, but remember if sth. failed in the init.
+        // Perform the rest of the poll, but remember if sth. failed in the
+        // init.
         poll_status = init();
     }
 
@@ -505,6 +628,14 @@ asynStatus masterMacsAxis::doPoll(bool *moving) {
             poll_status = asynError;
         }
 
+        /*
+        If the motor is homing or has been homed, ignore limit switch errors.
+         */
+        int homing = 0;
+        int homed = 0;
+        getAxisParamChecked(this, motorStatusHome, &homing);
+        getAxisParamChecked(this, motorStatusHomed, &homed);
+        if (homing || homed) {
             /*
             Either the software limits or the end switches of the controller
             have been hit. Since the EPICS limits are derived from the software
@@ -543,6 +674,7 @@ asynStatus masterMacsAxis::doPoll(bool *moving) {
 
                 poll_status = asynError;
             }
+        }
 
         if (overCurrent()) {
             appendErrorMessage(shellMessage, sizeof(shellMessage),
@@ -609,48 +741,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)) {
+        rw_status = readLimits();
         if (rw_status != asynSuccess) {
             return rw_status;
         }
-        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
@@ -681,19 +778,74 @@ asynStatus masterMacsAxis::doPoll(bool *moving) {
     return poll_status;
 }
 
+asynStatus masterMacsAxis::doMoveVelocity(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;
+
+    // =========================================================================
+
+    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.
+    return pC_->write(axisNo_, 00, "3", timeout);
+}
+
 asynStatus masterMacsAxis::doMove(double position, int relative,
                                   double minVelocity, double maxVelocity,
                                   double acceleration) {
 
     // Suppress unused variable warning
     (void)minVelocity;
-    (void)maxVelocity;
     (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;
@@ -736,8 +888,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;
@@ -751,14 +903,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) {
@@ -916,7 +1068,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)
      */
@@ -953,9 +1105,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 "
@@ -1037,6 +1187,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; }
 
 /**

src/masterMacsAxis.h

@@ -51,6 +51,19 @@ class HIDDEN masterMacsAxis : public sinqAxis {
      */
     asynStatus doPoll(bool *moving);
 
+    /**
+     * @brief Implementation of the `doMoveVelocity` function from sinqAxis. The
+     * parameters are described in the documentation of
+     * `sinqAxis::doMoveVelocity`.
+     *
+     * @param minVelocity
+     * @param maxVelocity
+     * @param acceleration
+     * @return asynStatus
+     */
+    asynStatus doMoveVelocity(double minVelocity, double maxVelocity,
+                              double acceleration);
+
     /**
      * @brief Implementation of the `doMove` function from sinqAxis. The
      * parameters are described in the documentation of `sinqAxis::doMove`.
@@ -117,6 +130,15 @@ class HIDDEN masterMacsAxis : public sinqAxis {
      */
     asynStatus enable(bool on);
 
+    /**
+     * @brief Write the new operation mode (position or velocity) to the
+     * 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.
@@ -148,163 +170,197 @@ class HIDDEN masterMacsAxis : public sinqAxis {
 
     /**
      * @brief Read the Master MACS status with the xR10 command and store
-     * the 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();
 
     // 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
+     * @brief Read the Master MACS error with the xR10 command and store
-     * the 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

@@ -429,8 +429,6 @@ asynStatus masterMacsController::parseResponse(
         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;
@@ -572,7 +570,7 @@ asynStatus masterMacsController::readInt32(asynUser *pasynUser,
         *value = 1;
         return asynSuccess;
     } else {
-        return asynMotorController::readInt32(pasynUser, value);
+        return sinqController::readInt32(pasynUser, value);
     }
 }
 

src/masterMacsController.h

@@ -75,7 +75,8 @@ class HIDDEN masterMacsController : public sinqController {
     /**
      * @brief Overloaded function of sinqController
      *
-     * The function is overloaded to allow resetting the node
+     * 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

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.
-        """)
-