Add methods for getting string for disable and restore limits

LeandroMartinsdS · LeandroMartinsdS · commit 921f41a1060a · 2025-10-24T14:36:42.000+01:00
diff --git a/pmacApp/src/pmacAxis.cpp b/pmacApp/src/pmacAxis.cpp
@@ -75,6 +75,7 @@ pmacAxis::pmacAxis(pmacController *pC, int axisNo)
   highLimit_ = 0.0;
   lowLimit_ = 0.0;
   limitsDisabled_ = 0;
+  limitsEnabled_ = true;
   stepSize_ = 1; //Don't need?
   deferredPosition_ = 0.0;
   cachedPosition_ = 0.0;
@@ -92,6 +93,7 @@ pmacAxis::pmacAxis(pmacController *pC, int axisNo)
   fatal_following_ = 0;
   encoder_axis_ = 0;
   limitsCheckDisable_ = 0;
+  limitsEnableAddr_ = "";
   nowTimeSecs_ = 0.0;
   lastTimeSecs_ = 0.0;
   printNextError_ = false;
@@ -330,13 +332,12 @@ asynStatus pmacAxis::move(double position, int relative, double min_velocity, do
     }
 
   #ifdef REMOVE_LIMITS_ON_HOME
-    if (limitsDisabled_) {
+    if (!limitsEnabled_) {
       char buffer[PMAC_MAXBUF] = {0};
       /* Re-enable limits */
-      // LMDS
-      sprintf(buffer, "i%d24=i%d24&$FDFFFF", axisNo_, axisNo_);
+      strncat(buffer, pC_->pHardware_->getRestoreAxisLimitsCmd(axisNo_, limitsEnableAddr_).c_str(), PMAC_MAXBUF - 1);
       strncat(command, buffer, PMAC_MAXBUF - 1);
-      limitsDisabled_ = 0;
+      limitsEnabled_ = true;
     }
   #endif
     debug(DEBUG_TRACE, functionName, "Axis Move command", command);
@@ -394,57 +395,22 @@ pmacAxis::home(double min_velocity, double max_velocity, double acceleration, in
     double home_velocity = 0.0;
     char buffer[PMAC_MAXBUF] = {0};
 
-    // /* Discover type of controller */
-    // strncpy(buffer, "cid", PMAC_MAXBUF);
-    // status = pC_->lowLevelWriteRead(buffer, response);
-    // if (status != asynSuccess) {
-    //   asynPrint(pC_->pasynUserSelf, ASYN_TRACE_ERROR,
-    //             "Controller %s Addr %d. %s: ERROR Reading Controller Type.\n", pC_->portName, axisNo_,
-    //             functionName);
-    //   return asynError;
-    // }
-    // nvals = sscanf(response, "%d", &controller_type);
-
-    // if (controller_type == pC_->PMAC_CID_GEOBRICK_ || controller_type == pC_->PMAC_CID_CLIPPER_) {
-    //   asynPrint(pC_->pasynUserSelf, ASYN_TRACE_FLOW,
-    //             "Controller %s Addr %d. %s: This is a Geobrick LV.\n", pC_->portName, axisNo_,
-    //             functionName);
-    // } else if (controller_type == pC_->PMAC_CID_PMAC_) {
-    //   asynPrint(pC_->pasynUserSelf, ASYN_TRACE_FLOW,
-    //             "Controller %s Addr %d. %s: This is a Turbo PMAC 2 Ultralite.\n", pC_->portName,
-    //             axisNo_, functionName);
-    // } else if (controller_type == pC_->PMAC_CID_POWER_) {
-    //   asynPrint(pC_->pasynUserSelf, ASYN_TRACE_FLOW,
-    //             "Controller %s Addr %d. %s: This is a Power Brick.\n", pC_->portName,
-    //             axisNo_, functionName);
-    // } else {
-    //   asynPrint(pC_->pasynUserSelf, ASYN_TRACE_ERROR,
-    //             "Controller %s Addr %d. %s: ERROR Unknown controller type = %d.\n", pC_->portName,
-    //             axisNo_, functionName, controller_type);
-    //   return asynError;
-    // }
-
-
-
     controller_type = pC_->cid_;
     if ( controller_type == pC_->PMAC_CID_POWER_) {
         /* Read home flags and home direction from PowerBrick LV */
         // ixx23 and ixx26 are just valid up to Motor[49], so to avoid execptions the Motor[x] structure was used instead
         // ixx24 has a different purpose on PowerPMAC, so Motor[x].pLimits was used instead
         // 'Gate3' was used instead of the alias 'PowerBrick' to reduce the number of characters
 
-        // int gateIndex = (axisNo_ < 5) ? 0 : 1;
-        // int chanIndex = (axisNo_ < 5) ? axisNo_ - 1 : axisNo_ - 5;
-        // char limitsAddress[PMAC_MAXBUF] = {0};
-        // // Gets limits pointer
-        // sprintf(buffer, "Motor[%d].pLimits", axisNo_);
-        // status = pC_->lowLevelWriteRead(buffer, response);
+        int gateIndex = (axisNo_ < 5) ? 0 : 1;
+        int chanIndex = (axisNo_ < 5) ? axisNo_ - 1 : axisNo_ - 5;
+        char limitsAddress[PMAC_MAXBUF] = {0};
         // strncpy(limitsAddress, response, PMAC_MAXBUF);
-        // sprintf(buffer, "Gate3[%d].Chan[%d].CaptCtrl Gate3[%d].Chan[%d].CaptFlag %s Motor[%d].HomeVel Motor[%d].HomeOffset",
-        //           gateIndex, chanIndex, gateIndex, chanIndex, limitsAddress, axisNo_, axisNo_);
-        // status = pC_->lowLevelWriteRead(buffer, response);
-        // nvals = sscanf(response, "%d %d $%x %lf %d", &home_type, &home_flag, &flag_mode, &home_velocity,
-        //               &home_offset);
+        sprintf(buffer, "Gate3[%d].Chan[%d].CaptCtrl Gate3[%d].Chan[%d].CaptFlagSel Motor[%d].pLimits Motor[%d].HomeVel Motor[%d].HomeOffset",
+                  gateIndex, chanIndex, gateIndex, chanIndex, axisNo_, axisNo_, axisNo_);
+        status = (pC_->lowLevelWriteRead(buffer, response));
+        nvals = sscanf(response, "%d %d %s %lf %d", &home_type, &home_flag, limitsAddress, &home_velocity,
+                      &home_offset);
     }
     // TODO: store flag_mode for re-enabling the limits correctly
     if (controller_type == pC_->PMAC_CID_GEOBRICK_
@@ -489,12 +455,12 @@ pmacAxis::home(double min_velocity, double max_velocity, double acceleration, in
 
     if ((home_type <= 15) &&
         (home_type % 4 >= 2) &&
-        !(flag_mode & 0x20000) && // are the limits disabled?
+        limitsEnabled_ &&
         ((home_velocity > 0 && home_flag == 1 && home_offset <= 0) ||
         (home_velocity < 0 && home_flag == 2 && home_offset >= 0))) {
-      sprintf(buffer, " i%d24=i%d24|$20000", axisNo_, axisNo_);   // Disable limits
-      strncat(command, buffer, PMAC_MAXBUF - 1);
-      limitsDisabled_ = 1;
+      // Concatenate string to disable limits to command
+      strncat(command, pC_->pHardware_->getDisableAxisLimitsCmd(axisNo_).c_str(), PMAC_MAXBUF - 1);
+      limitsEnabled_ = false;
       asynPrint(pC_->pasynUserSelf, ASYN_TRACE_FLOW,
                 "%s. Disabling limits whilst homing PMAC controller %s, axis %d, type:%d, flag:$%x, vel:%f\n",
                 functionName, pC_->portName, axisNo_, home_type, home_flag, home_velocity);
@@ -540,12 +506,12 @@ asynStatus pmacAxis::moveVelocity(double min_velocity, double max_velocity, doub
     sprintf(command, "%s%s#%d %s", vel_buff, acc_buff, axisNo_, (max_velocity < 0 ? "J-" : "J+"));
 
   #ifdef REMOVE_LIMITS_ON_HOME
-    if (limitsDisabled_) {
+    if (!limitsEnabled_) {
       char buffer[PMAC_MAXBUF];
       /* Re-enable limits */
-      sprintf(buffer, " i%d24=i%d24&$FDFFFF", axisNo_, axisNo_);
+      strncat(buffer, pC_->pHardware_->getRestoreAxisLimitsCmd(axisNo_, limitsEnableAddr_).c_str(), PMAC_MAXBUF - 1);
       strncat(command, buffer, PMAC_MAXBUF - 1);
-      limitsDisabled_ = 0;
+      limitsEnabled_ = true;
     }
   #endif
     debug(DEBUG_TRACE, functionName, "Axis MoveVelocity command", command);
@@ -701,7 +667,6 @@ asynStatus pmacAxis::getAxisStatus(pmacCommandStore *sPtr) {
     double enc_position = 0;
     int nvals = 0;
     int axisProblemFlag = 0;
-    int limitsStatus = 0;
     bool printErrors = true;
     char key[16];
     std::string value = "";
@@ -863,18 +828,16 @@ asynStatus pmacAxis::getAxisStatus(pmacCommandStore *sPtr) {
             // flag, which the user can set to disable this feature.*/
             if (!limitsCheckDisable_) {
                 // Check we haven't intentially disabled limits for homing.
-                if (!limitsDisabled_) {
-                    // Parse ixx24
-                    retStatus = pC_->pHardware_->parseAxisLimitsCmd(axisNo_, sPtr, &limitsStatus);
-                    if (!(limitsStatus)) {
-                        axisProblemFlag = 1;
-                        if (printErrors) {
-                            asynPrint(pC_->pasynUserSelf, ASYN_TRACE_ERROR,
-                                      "*** WARNING *** Limits are disabled on controller %s, axis %d\n",
-                                      pC_->portName, axisNo_);
-                            printNextError_ = false;
-                        }
-                    }
+                // Parse ixx24 or Motor[x].pLimits
+                retStatus = pC_->pHardware_->parseAxisLimitsCmd(axisNo_, sPtr, &limitsEnabled_, limitsEnableAddr_);
+                if (!(limitsEnabled_)) {
+                  axisProblemFlag = 1;
+                  if (printErrors) {
+                    asynPrint(pC_->pasynUserSelf, ASYN_TRACE_ERROR,
+                              "*** WARNING *** Limits are disabled on controller %s, axis %d\n",
+                              pC_->portName, axisNo_);
+                    printNextError_ = false;
+                  }
                 }
             }
             setIntegerParam(pC_->motorStatusProblem_, axisProblemFlag);
@@ -886,12 +849,12 @@ asynStatus pmacAxis::getAxisStatus(pmacCommandStore *sPtr) {
         }
 
 #ifdef REMOVE_LIMITS_ON_HOME
-        if (limitsDisabled_ && (axStatus.status24Bit2_ & pC_->PMAC_STATUS2_HOME_COMPLETE) &&
+        if (!limitsEnabled_ && (axStatus.status24Bit2_ & pC_->PMAC_STATUS2_HOME_COMPLETE) &&
             (axStatus.status24Bit1_ & pC_->PMAC_STATUS1_DESIRED_VELOCITY_ZERO)) {
             // Re-enable limits
-            sprintf(command, "i%d24=i%d24&$FDFFFF", axisNo_, axisNo_);
+            strncat(command, pC_->pHardware_->getRestoreAxisLimitsCmd(axisNo_, limitsEnableAddr_).c_str(), PMAC_MAXBUF - 1);
             cmdStatus = pC_->lowLevelWriteRead(command, response);
-            limitsDisabled_ = (cmdStatus != 0);
+            limitsEnabled_ = (cmdStatus == 0);
         }
 #endif
         // Set amplifier enabled bit.
diff --git a/pmacApp/src/pmacAxis.h b/pmacApp/src/pmacAxis.h
@@ -1,12 +1,12 @@
 /********************************************
  *  pmacAxis.cpp
- * 
- *  PMAC Asyn motor based on the 
+ *
+ *  PMAC Asyn motor based on the
  *  asynMotorAxis class.
- * 
+ *
  *  Matthew Pearson
  *  23 May 2012
- * 
+ *
  ********************************************/
 
 #ifndef pmacAxis_H
@@ -101,6 +101,7 @@ class pmacAxis : public asynMotorAxis, pmacCallbackInterface, public pmacDebugge
     double highLimit_;
     double lowLimit_;
     int limitsDisabled_;
+    bool limitsEnabled_;
     double stepSize_;
     double deferredPosition_;
     double cachedPosition_;
@@ -118,12 +119,14 @@ class pmacAxis : public asynMotorAxis, pmacCallbackInterface, public pmacDebugge
     int fatal_following_;
     int encoder_axis_;
     int limitsCheckDisable_;
+    std::string limitsEnableAddr_;
     epicsTimeStamp nowTime_;
     epicsFloat64 nowTimeSecs_;
     epicsFloat64 lastTimeSecs_;
     bool printNextError_;
     bool moving_; // only valid within poll time - used as a hint for validating deferred coordinated moves
     axisStatus status_;
+    bool limitsStatus_;
 
     bool connected_; // Current connection status of the hardware
     bool initialised_; // We need to keep a record of this in case the software starts up without a connection
diff --git a/pmacApp/src/pmacHardwareInterface.h b/pmacApp/src/pmacHardwareInterface.h
@@ -74,10 +74,11 @@ class pmacHardwareInterface {
 
     virtual std::string getAxisLimitsCmd(int axis) = 0;
 
-    virtual asynStatus parseAxisLimitsCmd(int axis, pmacCommandStore *sPtr, int *limitStatus) = 0;
+    virtual std::string getDisableAxisLimitsCmd(int axis) = 0;
 
-    // virtual asynStatus disableLimitsCmd(int axis, pmacCommandStore *sPtr, int *savedStatus) = 0;
-    // virtual asynStatus restoreLimitsCmd(int axis, pmacCommandStore *sPtr, int *savedStatus) = 0;
+    virtual std::string getRestoreAxisLimitsCmd(int axis, const std::string savedStatus) = 0;
+
+    virtual asynStatus parseAxisLimitsCmd(int axis, pmacCommandStore *sPtr, bool *limitsEnabled, std::string &pLimitsString) = 0;
 
     virtual asynStatus setupCSStatus(int csNo) = 0;
 
diff --git a/pmacApp/src/pmacHardwarePower.cpp b/pmacApp/src/pmacHardwarePower.cpp
@@ -232,13 +232,39 @@ static inline std::string trim(const std::string& s) {
     return (start == std::string::npos) ? "" : s.substr(start, end - start + 1);
 }
 
-asynStatus pmacHardwarePower::parseAxisLimitsCmd(int axis, pmacCommandStore *sPtr, int *limitStatus) {
-  asynStatus status = asynSuccess;
-  int nvals = 0;
-  std::string pLimitsString = "";
+std::string pmacHardwarePower::getDisableAxisLimitsCmd(int axis) {
+  char cmd[32];
+  static const char *functionName = "getDisableAxisLimitsCmd";
+  char savedStatus[32];
+
+  debug(DEBUG_TRACE, functionName, "Axis", axis);
+  sprintf(cmd, this->getAxisLimitsCmd(axis).c_str());
+  printf("DEBUG: savedStatus= '%s'\n", savedStatus);
+  sprintf(cmd, "Motor[%d].pLimits=0", axis);
+  printf("DEBUG: DisableAxisLimitsCmd= '%s'\n", cmd);
+
+  return std::string(cmd);
+}
+
+std::string pmacHardwarePower::getRestoreAxisLimitsCmd(int axis, const std::string savedStatus) {
+  char cmd[128];
+  static const char *functionName = "getRestoreAxisLimitsCmd";
 
+  debug(DEBUG_TRACE, functionName, "Axis", axis);
+
+  // Re-enable limits
+  snprintf(cmd, sizeof(cmd), "Motor[%d].pLimits = %s", axis, savedStatus.c_str());
+  return std::string(cmd);
+}
+
+// asynStatus pmacHardwarePower::parseAxisLimitsCmd(int axis, pmacCommandStore *sPtr, bool *limitsEnabled, std::string &/*pLimitsString*/) {
+asynStatus pmacHardwarePower::parseAxisLimitsCmd(int axis, pmacCommandStore *sPtr, bool *limitsEnabled, std::string &pLimitsString) {
+  asynStatus status = asynSuccess;
+  // std::string pLimitsString = ""; // TODO move it to argument to store status
   static const char *functionName = "parseAxisLimitsCmd";
 
+  debug(DEBUG_TRACE, functionName, "Axis", axis);
+
   // Get the symbolic pointer string
   pLimitsString = trim(sPtr->readValue(this->getAxisLimitsCmd(axis))); // e.g., "Gate3[0].Chan[0].Status.a" or "0"
   debug(DEBUG_VARIABLE, functionName, "pLimit string", pLimitsString);
@@ -252,10 +278,10 @@ asynStatus pmacHardwarePower::parseAxisLimitsCmd(int axis, pmacCommandStore *sPt
     //  - Case 2
     //    - it must begin with: "Sys.pushm", or "Sys.piom"
     //    - it might contain "+$"
-    *limitStatus = 1;
+    *limitsEnabled = true;
   } else {
     // Disabled
-    *limitStatus = 0;
+    *limitsEnabled = false;
   }
 
   return status;
diff --git a/pmacApp/src/pmacHardwarePower.h b/pmacApp/src/pmacHardwarePower.h
@@ -31,9 +31,11 @@ class pmacHardwarePower : public pmacHardwareInterface, pmacDebugger {
 
     std::string getAxisLimitsCmd(int axis);
 
-    asynStatus parseAxisLimitsCmd(int axis, pmacCommandStore *sPtr, int *limitStatus);
+    std::string getDisableAxisLimitsCmd(int axis);
 
-    // asynStatus disableAxisLimits(int axis, int *addr);
+    std::string getRestoreAxisLimitsCmd(int axis, const std::string savedStatus);
+
+    asynStatus parseAxisLimitsCmd(int axis, pmacCommandStore *sPtr, bool *limitsEnabled, std::string &pLimitsString);
 
     asynStatus setupCSStatus(int csNo);
 
diff --git a/pmacApp/src/pmacHardwareTurbo.cpp b/pmacApp/src/pmacHardwareTurbo.cpp
@@ -288,13 +288,34 @@ std::string pmacHardwareTurbo::getAxisLimitsCmd(int axis) {
   return std::string(cmd);
 }
 
-asynStatus pmacHardwareTurbo::parseAxisLimitsCmd(int axis, pmacCommandStore *sPtr, int *limitStatus) {
+std::string pmacHardwareTurbo::getDisableAxisLimitsCmd(int axis/*, const std::string savedStatus*/) {
+  char cmd[32];
+  static const char *functionName = "getDisableAxisLimitsCmd";
+
+  debug(DEBUG_TRACE, functionName, "Axis", axis);
+  sprintf(cmd, " i%d24=i%d24|$20000", axis, axis);   // Disable limits
+
+  return(cmd);
+}
+
+std::string pmacHardwareTurbo::getRestoreAxisLimitsCmd(int axis, const std::string) {
+  char cmd[32];
+  static const char *functionName = "getRestoreAxisLimitsCmd";
+
+  debug(DEBUG_TRACE, functionName, "Axis", axis);
+  sprintf(cmd, " i%d24=i%d24&$FDFFFF", axis, axis);   // Re-enable limits
+  return(cmd);
+}
+
+
+asynStatus pmacHardwareTurbo::parseAxisLimitsCmd(int axis, pmacCommandStore *sPtr, bool *limitsEnabled, std::string&) {
   asynStatus status = asynSuccess;
   int nvals = 0;
   int limitsBits = 0;
   std::string pLimitsString = "";
   static const char *functionName = "parseAxisLimitsCmd";
 
+  debug(DEBUG_TRACE, functionName, "Axis", axis);
   pLimitsString = sPtr->readValue(this->getAxisLimitsCmd(axis));
 
   // Response parsed for PowerPMAC
@@ -306,7 +327,7 @@ asynStatus pmacHardwareTurbo::parseAxisLimitsCmd(int axis, pmacCommandStore *sPt
     debug(DEBUG_ERROR, functionName, "    response", pLimitsString);
     status = asynError;
   }
-  *limitStatus = ~((0x20000 & limitsBits) >> 17);
+  *limitsEnabled = ~((0x20000 & limitsBits) >> 17);
 
   return status;
 }
diff --git a/pmacApp/src/pmacHardwareTurbo.h b/pmacApp/src/pmacHardwareTurbo.h
@@ -31,7 +31,11 @@ class pmacHardwareTurbo : public pmacHardwareInterface, pmacDebugger {
 
     std::string getAxisLimitsCmd(int axis);
 
-    asynStatus parseAxisLimitsCmd(int axis, pmacCommandStore *sPtr, int *limitStatus);
+    std::string getDisableAxisLimitsCmd(int axis);
+
+    std::string getRestoreAxisLimitsCmd(int axis, const std::string savedStatus);
+
+    asynStatus parseAxisLimitsCmd(int axis, pmacCommandStore *sPtr, bool *limitsEnabled, std::string &pLimitsString);
 
     asynStatus setupCSStatus(int csNo);
 
