Fixed scaling of the written motorVelocity value

commit d90869cbca
Author: smathis <stefan.mathis@psi.ch>
Date:   Tue Feb 10 13:18:43 2026 +0100

    Added reminder comment

commit eadce0f594
Author: smathis <stefan.mathis@psi.ch>
Date:   Tue Feb 10 12:31:01 2026 +0100

    Draft velocity mode

    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.

commit 0e1f95a94b
Author: smathis <stefan.mathis@psi.ch>
Date:   Tue Feb 10 09:04:04 2026 +0100

    Updated sinqMotor and use setLimits

commit b01f398533
Author: smathis <stefan.mathis@psi.ch>
Date:   Tue Feb 10 09:00:58 2026 +0100

    Set move flag correctly in velocity / jog mode

commit 56d9d20c3a
Author: smathis <stefan.mathis@psi.ch>
Date:   Tue Feb 3 17:57:00 2026 +0100

    Simplified handling of velocity mode using standard EPICS motor record fields

commit 4634609891
Author: smathis <stefan.mathis@psi.ch>
Date:   Tue Feb 3 13:35:24 2026 +0100

    Rolled back to sinqMotor 1.5.7

Makefile

@@ -7,7 +7,7 @@ EPICS_VERSIONS=7.0.7
 ARCH_FILTER=RHEL%
 
 # Specify the version of asynMotor we want to build against
-motorBase_VERSION=7.2.2
+motorBase_VERSION=7.3.2
 
 # These headers allow to depend on this library for derived drivers.
 HEADERS += src/masterMacsAxis.h

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,8 @@ struct masterMacsAxisImpl {
     time_t timeAtHandshake;
     bool needInit = true;
     bool targetReachedUninitialized;
+    bool dynamicLimits;
+    moveMode lastMoveCommand;
 };
 
 /*
@@ -92,6 +99,8 @@ masterMacsAxis::masterMacsAxis(masterMacsController *pC, int axisNo)
           .waitForHandshake = false,
           .timeAtHandshake = 0,
           .targetReachedUninitialized = true,
+          .dynamicLimits = false,
+          .lastMoveCommand = positionMode,
       })) {
 
     asynStatus status = asynSuccess;
@@ -179,14 +188,16 @@ 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;
 
     // =========================================================================
 
@@ -195,9 +206,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,10 +217,10 @@ 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__);
         }
@@ -220,73 +231,100 @@ asynStatus masterMacsAxis::init() {
     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);
+
+    status = readEncoderType();
+    if (status != asynSuccess) {
+        return status;
     }
 
-    pl_status = readEncoderType();
+    // Read the axis limits
-    if (pl_status != asynSuccess) {
+    status = readLimits();
-        return pl_status;
+    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
@@ -294,14 +332,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
@@ -311,10 +403,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;
@@ -324,9 +416,6 @@ 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;
 
     // =========================================================================
@@ -366,8 +455,8 @@ asynStatus masterMacsAxis::doPoll(bool *moving) {
         }
 
         pC_->read(axisNo_, 86, response);
-        if (rw_status != asynSuccess) {
+        if (rwStatus != asynSuccess) {
-            return rw_status;
+            return rwStatus;
         }
 
         nvals = sscanf(response, "%lf", &handshakePerformed);
@@ -393,17 +482,56 @@ 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()) {
+        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__);
+        }
+
+        // Writes the actual speed in steps per second to the paramLib. This
+        // value is then returned by the RVEL field of the motor record.
+        setAxisParamChecked(this, motorVelocity,
+                            actualVelocity / motorRecResolution);
+
+        // 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.
@@ -420,24 +548,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(
@@ -510,12 +628,52 @@ 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);
+
+        /*
+        Ignore limit switch errors when homing / motor has been homed or when
+        the motor is moving.
+
+        Background:
+        MasterMACS controllers move the motor outside the allowed range defined
+        by the "software limits" defined within the controllers because they
+        need to hit the physical end switch to determine the motor position. The
+        motor then rests close to the end switch, which might be outside the
+        controller-side software limits. This leads to this error, which is then
+        forwarded to the user even though nothing went wrong. The three checks
+        are here to prevent this:
+        - "homing": Is set at the start of a homing maneuver and removed once
+        the motor does not move anymore => Prevents the error from showing up
+        during the homing procedure
+        - "homed": Is set after a homing maneuver has been finished => Prevents
+        the error from showing up while the motor is resting idle outside the
+        software limits.
+        - "moving": Prevents the error from showing up when moving out of the
+        homing position.
+
+        If the motor hits the limits during normal operation, it is stopped by
+        the controller. Once stopped, moving is false and then the error is
+        shown to the user (because "homed" is not set).
+
+        Note: strictly speaking, it is not necessary to check homing because
+        moving would be set to true anyway. The check is here for clarity /
+        being explicit.
+        */
+        if (!homing && !homed && !(*moving)) {
             /*
             Either the software limits or the end switches of the controller
             have been hit. Since the EPICS limits are derived from the software
             limits and are a little bit smaller, these error cases can only
             happen if either the axis has an incremental encoder which is not
-        properly homed or if a bug occured.
+            properly homed or if the motor moved outside the limits while homing
+            (but in that case, the error is not shown, see previous
+            if-statement).
             */
             if (positiveLimitSwitch() || negativeLimitSwitch() ||
                 positiveSoftwareLimit() || negativeSoftwareLimit()) {
@@ -548,6 +706,7 @@ asynStatus masterMacsAxis::doPoll(bool *moving) {
 
                 poll_status = asynError;
             }
+        }
 
         if (overCurrent()) {
             appendErrorMessage(shellMessage, sizeof(shellMessage),
@@ -614,48 +773,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
@@ -679,13 +803,71 @@ asynStatus masterMacsAxis::doPoll(bool *moving) {
     setAxisParamChecked(this, motorStatusDone, !(*moving));
     setAxisParamChecked(this, motorStatusDirection, direction);
 
-    pl_status = setMotorPosition(currentPosition);
-    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;
+
+    // =========================================================================
+
+    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) {
@@ -697,7 +879,7 @@ asynStatus masterMacsAxis::doMove(double position, int relative,
     // 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;
@@ -740,8 +922,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;
@@ -755,14 +937,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) {
@@ -791,6 +973,8 @@ 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;
 }
 
@@ -1039,6 +1223,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; }
 
 /**
@@ -1069,8 +1275,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);
@@ -1082,7 +1288,7 @@ asynStatus masterMacsAxis::readAxisStatus() {
         pMasterMacsA_->axisStatus = toBitset(axisStatus);
     }
 
-    return rw_status;
+    return rwStatus;
 }
 
 asynStatus masterMacsAxis::readAxisError() {
@@ -1090,8 +1296,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);
@@ -1101,7 +1307,7 @@ asynStatus masterMacsAxis::readAxisError() {
         }
         pMasterMacsA_->axisError = toBitset(axisError);
     }
-    return rw_status;
+    return rwStatus;
 }
 
 bool masterMacsAxis::readyToBeSwitchedOn() {
@@ -1128,6 +1334,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];
 }

src/masterMacsAxis.h

@@ -51,6 +51,17 @@ 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`.
@@ -117,6 +128,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.
@@ -154,6 +174,12 @@ class HIDDEN masterMacsAxis : public sinqAxis {
      */
     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 (see
     masterMacsAxisImpl redefinition in masterMacsAxis.cpp) bitset. Since a bit
@@ -224,6 +250,12 @@ class HIDDEN masterMacsAxis : public sinqAxis {
      */
     bool internalLimitActive();
 
+    /**
+     * @brief Read the property from axisStatus (see masterMacsAxisImpl
+     * redefinition in masterMacsAxis.cpp)
+     */
+    bool speedEqualZero();
+
     // Bits 12 and 13 are unused
 
     /**

src/masterMacsController.cpp

@@ -570,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