From a94ca36d90a59b0130f222c55a9cb77dc8c66edf Mon Sep 17 00:00:00 2001
From: Douglas Araujo <douglas.araujo@ess.eu>
Date: Mon, 16 Sep 2024 13:12:45 +0200
Subject: [PATCH] Refactor writeInt32 method

---
 ADOrcaApp/src/orca.cpp | 524 ++++++++++++-----------------------------
 1 file changed, 156 insertions(+), 368 deletions(-)

diff --git a/ADOrcaApp/src/orca.cpp b/ADOrcaApp/src/orca.cpp
index 8dca6cc..4a2229d 100644
--- a/ADOrcaApp/src/orca.cpp
+++ b/ADOrcaApp/src/orca.cpp
@@ -45,12 +45,12 @@ Orca::Orca(const char* portName, int maxBuffers, size_t maxMemory, int priority,
                1,             /* autoConnect=1 */
                priority, stackSize),
       m_hdcam(NULL) {
-  const char* functionName = "orcaDetector::orcaDetector";
+  const char* functionName = "orcaDetector";
   stopThread = 0;
 
   startEvent_ = epicsEventCreate(epicsEventEmpty);
   if (!startEvent_) {
-    FLOW("epicsEventCreate failure for acquire start event");
+    ERR("epicsEventCreate failure for acquire start event");
     return;
   }
 
@@ -819,8 +819,7 @@ int Orca::readParameter(int propertyID, bool processPV) {
   if (failed(m_err)) {
     char text[256] = {'\0'};
     dcamprop_getname(m_hdcam, propertyID, text, sizeof(text));
-    printError(m_hdcam, m_err, "+dcamprop_getvalue()",
-               "IDPROP:0x%08x, VALUE:%s\n", propertyID, text);
+    ERR_ARGS("DCAMERR: 0x%08X [%s: %s]", m_err, "dcamprop_getvalue", text);
   }
 
   if (processPV) status = callParamCallbacks();
@@ -1034,29 +1033,22 @@ void Orca::imageTask() {
 //============================================================================
 void Orca::temperatureTask() {
   static const char* functionName = "tempTask";
-  asynStatus status = asynSuccess;
   double dvalue = 0;
 
   while (!stopThread) {
     m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SENSORTEMPERATURE, &dvalue);
     if (failed(m_err)) {
-      printError(m_hdcam, m_err, "dcamprop_SensorTemperature()", " VALUE:%f\n",
-                 dvalue);
-    }
-    status = setDoubleParam(hSensorTemperature, dvalue);
+      ERR_ARGS("DCAMERR: 0x%08X [%s: %s]", m_err, "dcamprop_getvalue",
+               "DCAM_IDPROP_SENSORTEMPERATURE");
+    } else
+      setDoubleParam(hSensorTemperature, dvalue);
 
     m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SENSORCOOLERSTATUS, &dvalue);
     if (failed(m_err)) {
-      printError(m_hdcam, m_err, "dcamprop_SensorCoolerStatus()", "VALUE:%f\n",
-                 dvalue);
-    }
-    status = setIntegerParam(hSensorCoolerStatus, dvalue);
-
-    if (status) {
-      asynPrint(pasynUserSelf, ASYN_TRACE_ERROR,
-                "%s:%s: temperature read error = %d\n", driverName,
-                functionName, m_err);
-    }
+      ERR_ARGS("DCAMERR: 0x%08X [%s: %s]", m_err, "dcamprop_getvalue",
+               "DCAM_IDPROP_SENSORCOOLERSTATUS");
+    } else
+      setIntegerParam(hSensorCoolerStatus, dvalue);
 
     callParamCallbacks();
     epicsThreadSleep(1.0);
@@ -1065,28 +1057,32 @@ void Orca::temperatureTask() {
 
 //============================================================================
 asynStatus Orca::writeInt32(asynUser* pasynUser, epicsInt32 value) {
-  asynStatus status = asynSuccess;
+  int status = asynSuccess;
   const char* functionName = "writeInt32";
   const char* paramName;
 
   int index = pasynUser->reason;
   int adstatus;
-  // the setget function required double parameter
-  double dvalue = double(value);
+  double dvalue = static_cast<double>(value);
 
   getParamName(index, &paramName);
-
-  /* Ensure that ADStatus is set correctly before we set ADAcquire.*/
-  getIntegerParam(ADStatus, &adstatus);
-
-  status = setIntegerParam(index, value);
+  // Helper lambda for error logging
+  auto checkAndLogError = [&](DCAMERR err, const char* msg, int idx,
+                              double val) {
+    if (failed(err)) {
+      char text[256];
+      dcamprop_getname(m_hdcam, idx, text, sizeof(text));
+      ERR_ARGS("IDPROP:0x%08x - Name:%s -> Value:%f", idx, text, val);
+    }
+  };
 
   if (index == ADAcquire) {
+    getIntegerParam(ADStatus, &adstatus);
     if (value && adstatus != ADStatusAcquire) {
       double readoutTime, acquirePeriod, acquireTime;
-      status = getDoubleParam(hTimingReadoutTime, &readoutTime);
-      status = getDoubleParam(ADAcquireTime, &acquireTime);
-      status = getDoubleParam(ADAcquirePeriod, &acquirePeriod);
+      status |= getDoubleParam(hTimingReadoutTime, &readoutTime);
+      status |= getDoubleParam(ADAcquireTime, &acquireTime);
+      status |= getDoubleParam(ADAcquirePeriod, &acquirePeriod);
 
       if (acquirePeriod < (readoutTime + acquireTime)) {
         setStringParam(
@@ -1108,375 +1104,167 @@ asynStatus Orca::writeInt32(asynUser* pasynUser, epicsInt32 value) {
       setStringParam(ADStatusMessage, "Acquisition aborted by user");
       stopAcquire();
     }
-  } else if (index == ADMinX) {
-    int minH = 0, sizeH = 0;
-    double dFrameBytes = 0;
-    getIntegerParam(ADMinX, &minH);
-    getIntegerParam(ADSizeX, &sizeH);
-
-    if (sizeH > (MAX_H_SENSOR_SIZE - minH)) {
-      sizeH = MAX_H_SENSOR_SIZE - minH;
-      double dsizeH = sizeH;
-      double dminH = minH;
-      m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHSIZE, &dsizeH);
-      m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHPOS, &dminH);
-      setIntegerParam(ADSizeX, sizeH);
-      dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &dFrameBytes);
-      status = setIntegerParam(hImageFramebytes, dFrameBytes);
-    } else {
-      double dsizeH = sizeH;
-      double dminH = minH;
-      m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHSIZE, &dsizeH);
-      m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHPOS, &dminH);
-      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES,
-                                &dFrameBytes);
-      status = setIntegerParam(hImageFramebytes, dFrameBytes);
-    }
-    readParameter(DCAM_IDPROP_TIMING_READOUTTIME, false);
-  } else if (index == ADMinY) {
-    int minV = 0, sizeV = 0;
+  }
+  // Handle ADMinX and ADMinY
+  else if (index == ADMinX || index == ADMinY) {
+    int size;
     double dFrameBytes = 0;
-    status = getIntegerParam(ADMinY, &minV);
-    getIntegerParam(ADSizeY, &sizeV);
-
-    if (sizeV > (MAX_V_SENSOR_SIZE - minV)) {
-      sizeV = MAX_V_SENSOR_SIZE - minV;
-      double dsizeV = sizeV;
-      double dminV = minV;
-      m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVSIZE, &dsizeV);
-      m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVPOS, &dminV);
-      setIntegerParam(ADSizeY, sizeV);
-      dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &dFrameBytes);
-      status = setIntegerParam(hImageFramebytes, dFrameBytes);
+
+    if (index == ADMinX) {
+      getIntegerParam(ADSizeX, &size);
     } else {
-      double dsizeV = sizeV;
-      double dminV = minV;
-      m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVSIZE, &dsizeV);
-      m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVPOS, &dminV);
-      dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &dFrameBytes);
-      status = setIntegerParam(hImageFramebytes, dFrameBytes);
+      getIntegerParam(ADSizeY, &size);
     }
+
+    int maxSize = (index == ADMinX) ? MAX_H_SENSOR_SIZE : MAX_V_SENSOR_SIZE;
+    if (size > (maxSize - value)) size = maxSize - value;
+
+    double dSize = static_cast<double>(size);
+    double dMin = static_cast<double>(value);
+    int subArraySize = (index == ADMinX) ? DCAM_IDPROP_SUBARRAYHSIZE
+                                         : DCAM_IDPROP_SUBARRAYVSIZE;
+    int subArrayPos =
+        (index == ADMinX) ? DCAM_IDPROP_SUBARRAYHPOS : DCAM_IDPROP_SUBARRAYVPOS;
+
+    m_err = dcamprop_setgetvalue(m_hdcam, subArraySize, &dSize);
+    m_err = dcamprop_setgetvalue(m_hdcam, subArrayPos, &dMin);
+    dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &dFrameBytes);
+
+    if (index == ADMinX)
+      setIntegerParam(ADSizeX, size);
+    else
+      setIntegerParam(ADSizeY, size);
+
+    status |= setIntegerParam(hImageFramebytes, dFrameBytes);
     readParameter(DCAM_IDPROP_TIMING_READOUTTIME, false);
   }
-
-  else if (index == ADSizeX) {
-    int minX = 0, sizeX = 0;
+  // Handle ADSizeX and ADSizeY
+  else if (index == ADSizeX || index == ADSizeY) {
+    int min;
     double dFrameBytes = 0;
-    getIntegerParam(ADMinX, &minX);
-    getIntegerParam(ADSizeX, &sizeX);
-
-    if (sizeX < MAX_H_SENSOR_SIZE - minX) {
-      double dsizeX = roundToNearestMultipleOfFour(sizeX);
-      m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHSIZE, &dsizeX);
-      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES,
-                                &dFrameBytes);
-      status = setIntegerParam(hImageFramebytes, dFrameBytes);
-      value = (int)dsizeX;
+
+    if (index == ADSizeX) {
+      getIntegerParam(ADMinX, &min);
     } else {
-      double dsizeX = MAX_H_SENSOR_SIZE - minX;
-      m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHSIZE, &dsizeX);
-      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES,
-                                &dFrameBytes);
-      status = setIntegerParam(hImageFramebytes, dFrameBytes);
-      value = (int)dsizeX;
+      getIntegerParam(ADMinY, &min);
     }
-    readParameter(DCAM_IDPROP_TIMING_READOUTTIME, false);
-  }
 
-  else if (index == ADSizeY) {
-    int minY = 0, sizeY = 0;
-    double dFrameBytes = 0;
-    getIntegerParam(ADMinY, &minY);
-    getIntegerParam(ADSizeY, &sizeY);
-    if (sizeY < MAX_V_SENSOR_SIZE - minY) {
-      double dsizeY = roundToNearestMultipleOfFour(sizeY);
-      m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVSIZE, &dsizeY);
-      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES,
-                                &dFrameBytes);
-      value = (int)dsizeY;
-      status = setIntegerParam(hImageFramebytes, dFrameBytes);
+    int maxSize = (index == ADSizeX) ? MAX_H_SENSOR_SIZE : MAX_V_SENSOR_SIZE;
+    if (value > maxSize - min) value = maxSize - min;
+
+    double dSize = roundToNearestMultipleOfFour(value);
+
+    DCAMIDPROP subArraySize = (index == ADSizeX) ? DCAM_IDPROP_SUBARRAYHSIZE
+                                                 : DCAM_IDPROP_SUBARRAYVSIZE;
+
+    m_err = dcamprop_setgetvalue(m_hdcam, subArraySize, &dSize);
+    dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &dFrameBytes);
+
+    if (index == ADSizeX) {
+      setIntegerParam(ADSizeX, static_cast<int>(dSize));
     } else {
-      double dsizeY = 0;
-      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVSIZE, &dsizeY);
-      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES,
-                                &dFrameBytes);
-      status = setIntegerParam(hImageFramebytes, dFrameBytes);
-      value = (int)dsizeY;
+      setIntegerParam(ADSizeY, static_cast<int>(dSize));
     }
-    readParameter(DCAM_IDPROP_TIMING_READOUTTIME, false);
-  } else if (index == hSensorMode) {
-    m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SENSORMODE, &dvalue);
-    if (failed(m_err))
-      printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
-                 "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
-    readParameter(DCAM_IDPROP_TIMING_READOUTTIME, false);
-  }
 
-  else if (index == hReadoutSpeed) {
-    m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_READOUTSPEED, &dvalue);
-    if (failed(m_err))
-      printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
-                 "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
+    status |= setIntegerParam(hImageFramebytes, dFrameBytes);
     readParameter(DCAM_IDPROP_TIMING_READOUTTIME, false);
   }
 
-  else if (index == hReadoutDirection) {
-    m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_READOUT_DIRECTION,
-                                 &dvalue, 0);
-    if (failed(m_err)) {
-      printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
-                 "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
-    }
-  }
-  //-- Trigger
-  else if (index == hTriggerSource) {
-    m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TRIGGERSOURCE, &dvalue);
-    if (failed(m_err)) {
-      printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
-                 "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
-    }
-  } else if (index == hTriggerMode) {
-    m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TRIGGER_MODE, &dvalue);
-    if (failed(m_err)) {
-      printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
-                 "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
-    }
-  } else if (index == hTriggerActive) {
-    m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TRIGGERACTIVE, &dvalue);
-    if (failed(m_err)) {
-      printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
-                 "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
-    }
-  } else if (index == hTriggerGlobalExposure) {
-    m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TRIGGER_GLOBALEXPOSURE,
-                                 &dvalue);
-    if (failed(m_err)) {
-      printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
-                 "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
-    }
-  } else if (index == hTriggerPolarity) {
-    m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TRIGGERPOLARITY, &dvalue);
-    if (failed(m_err)) {
-      printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
-                 "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
-    }
-  } else if (index == hTriggerConnector) {
-    m_err =
-        dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TRIGGER_CONNECTOR, &dvalue);
-    if (failed(m_err)) {
-      printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
-                 "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
-    }
-  } else if (index == hTriggerTimes) {
-    m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TRIGGERTIMES, &dvalue);
-    if (failed(m_err)) {
-      printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
-                 "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
-    }
-  } else if (index == hInternalTriggerHandling) {
-    m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_INTERNALTRIGGER_HANDLING,
-                                 &dvalue);
-    if (failed(m_err)) {
-      printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
-                 "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
-    }
+  //-- Output trigger
+  else if (index >= hOutputTriggerSource0 && index <= hOutputTriggerSource2) {
+    int offset = (index - hOutputTriggerSource0) / hOutputTriggerSource0;
+    int prop = DCAM_IDPROP_OUTPUTTRIGGER_SOURCE + offset * 0x100;
+    m_err = dcamprop_setgetvalue(m_hdcam, prop, &dvalue);
+    checkAndLogError(m_err, "dcamprop_setgetvalue()", index, dvalue);
   }
 
-  //-- binning and ROI
+  //-- binning
   else if (index == hBinning) {
-    int binning = 0;
     double dFrameBytes = 0;
-
-    getIntegerParam(hBinning, &binning);
-    double dbinning = binning;
-    m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_BINNING, &dbinning);
+    m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_BINNING, &dvalue);
     if (failed(m_err))
-      printError(m_hdcam, m_err, "dcamprop_Binning()", " VALUE:%f\n", dbinning);
+      printError(m_hdcam, m_err, "dcamprop_Binning()", " VALUE:%f\n", dvalue);
 
     m_err =
         dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &dFrameBytes);
     status = setIntegerParam(hImageFramebytes, dFrameBytes);
-
-    status = setIntegerParam(hBinning, dbinning);
-  } else if (index == hSubarrayMode) {
-    m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYMODE, &dvalue);
-    if (failed(m_err)) {
-      printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
-                 "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
-    }
-  }
-
-  //-- ALU
-  else if (index == hDefectCorrectMode) {
-    m_err =
-        dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_DEFECTCORRECT_MODE, &dvalue);
-    if (failed(m_err)) {
-      printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
-                 "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
-    }
-  } else if (index == hHotPixelCorrectLevel) {
-    m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_HOTPIXELCORRECT_LEVEL,
-                                 &dvalue);
-    if (failed(m_err)) {
-      printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
-                 "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
-    }
-  } else if (index == hIntensityLutMode) {
-    m_err =
-        dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_INTENSITYLUT_MODE, &dvalue);
-    if (failed(m_err)) {
-      printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
-                 "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
-    }
   }
 
-  //-- Output trigger
-  else if (index == hOutputTriggerSource0) {
-    m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_SOURCE,
-                                 &dvalue);
-    if (failed(m_err)) {
-      printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
-                 "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
-    }
-  } else if (index == hOutputTriggerSource1) {
-    m_err = dcamprop_setgetvalue(
-        m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_SOURCE + 0x100, &dvalue);
-    if (failed(m_err)) {
-      printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
-                 "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
-    }
-  } else if (index == hOutputTriggerSource2) {
-    m_err = dcamprop_setgetvalue(
-        m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_SOURCE + 0x200, &dvalue);
-    if (failed(m_err)) {
-      printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
-                 "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
-    }
-  }
-
-  else if (index == hOutputTriggerPolarity0) {
-    m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_POLARITY,
-                                 &dvalue);
-    if (failed(m_err)) {
-      printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
-                 "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
-    }
-  } else if (index == hOutputTriggerPolarity1) {
-    m_err = dcamprop_setgetvalue(
-        m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_POLARITY + 0x100, &dvalue);
-    if (failed(m_err)) {
-      printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
-                 "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
-    }
-  } else if (index == hOutputTriggerPolarity2) {
-    m_err = dcamprop_setgetvalue(
-        m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_POLARITY + 0x200, &dvalue);
-    if (failed(m_err)) {
-      printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
-                 "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
-    }
-  }
-
-  else if (index == hOutputTriggerKind0) {
-    m_err =
-        dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_KIND, &dvalue);
-    if (failed(m_err)) {
-      printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
-                 "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
-    }
-  } else if (index == hOutputTriggerKind1) {
-    m_err = dcamprop_setgetvalue(
-        m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_KIND + 0x100, &dvalue);
-    if (failed(m_err)) {
-      printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
-                 "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
-    }
-  } else if (index == hOutputTriggerKind2) {
-    m_err = dcamprop_setgetvalue(
-        m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_KIND + 0x200, &dvalue);
-    if (failed(m_err)) {
-      printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
-                 "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
-    }
-  } else if (index == hOutputTriggerBaseSensor0) {
-    m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_BASESENSOR,
-                                 &dvalue);
-    if (failed(m_err)) {
-      printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
-                 "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
-    }
-  } else if (index == hOutputTriggerBaseSensor1) {
-    m_err = dcamprop_setgetvalue(
-        m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_BASESENSOR + 0x100, &dvalue);
-    if (failed(m_err)) {
-      printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
-                 "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
-    }
-  } else if (index == hOutputTriggerBaseSensor2) {
-    m_err = dcamprop_setgetvalue(
-        m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_BASESENSOR + 0x200, &dvalue);
-    if (failed(m_err)) {
-      printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
-                 "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
-    }
-  } else if (index == hOutputTriggerPreHsyncCount) {
-    m_err = dcamprop_setgetvalue(
-        m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_PREHSYNCCOUNT, &dvalue);
-    if (failed(m_err)) {
-      printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
-                 "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
-    }
-  }
-
-  //-- Master pulse
-  else if (index == hMasterPulseMode) {
-    m_err =
-        dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_MASTERPULSE_MODE, &dvalue);
-    if (failed(m_err)) {
-      printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
-                 "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
-    }
-  } else if (index == hMasterPulseTriggerSource) {
-    m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_MASTERPULSE_TRIGGERSOURCE,
-                                 &dvalue);
-    if (failed(m_err)) {
-      printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
-                 "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
-    }
-  }
-
-  else if (index == hMasterPulseBurstTimes) {
-    m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_MASTERPULSE_BURSTTIMES,
-                                 &dvalue);
-    if (failed(m_err)) {
-      printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
-                 "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
-    }
-  }
-  //-- Synchronous timing - nothing to implement either is in writeFloat64
-  //-- System information
-  else if (index == hBitPerChannel) {
-    m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_BITSPERCHANNEL, &dvalue);
-    if (failed(m_err)) {
-      printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
-                 "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
-    }
-  }
-
-  else if (index == hImagePixelType) {
-    m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_IMAGE_PIXELTYPE, &dvalue);
-    if (failed(m_err)) {
-      printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
-                 "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
-    }
+  else if (index < FIRST_HAMA_PARAM) {
+    status = ADDriver::writeInt32(pasynUser, value);
   }
 
   else {
-    if (index < FIRST_HAMA_PARAM) {
-      status = ADDriver::writeInt32(pasynUser, value);
+    int prop = 0;
+    if (index == hSensorMode) {
+      prop = DCAM_IDPROP_SENSORMODE;
+    } else if (index == hReadoutSpeed) {
+      prop = DCAM_IDPROP_READOUTSPEED;
+    } else if (index == hReadoutDirection) {
+      prop = DCAM_IDPROP_READOUT_DIRECTION;
+    } else if (index == hTriggerSource) {
+      prop = DCAM_IDPROP_TRIGGERSOURCE;
+    } else if (index == hTriggerMode) {
+      prop = DCAM_IDPROP_TRIGGER_MODE;
+    } else if (index == hTriggerActive) {
+      prop = DCAM_IDPROP_TRIGGERACTIVE;
+    } else if (index == hTriggerGlobalExposure) {
+      prop = DCAM_IDPROP_TRIGGER_GLOBALEXPOSURE;
+    } else if (index == hTriggerPolarity) {
+      prop = DCAM_IDPROP_TRIGGERPOLARITY;
+    } else if (index == hTriggerConnector) {
+      prop = DCAM_IDPROP_TRIGGER_CONNECTOR;
+    } else if (index == hTriggerTimes) {
+      prop = DCAM_IDPROP_TRIGGERTIMES;
+    } else if (index == hInternalTriggerHandling) {
+      prop = DCAM_IDPROP_INTERNALTRIGGER_HANDLING;
+    } else if (index == hSubarrayMode) {
+      prop = DCAM_IDPROP_SUBARRAYMODE;
+    } else if (index == hDefectCorrectMode) {
+      prop = DCAM_IDPROP_DEFECTCORRECT_MODE;
+    } else if (index == hHotPixelCorrectLevel) {
+      prop = DCAM_IDPROP_HOTPIXELCORRECT_LEVEL;
+    } else if (index == hIntensityLutMode) {
+      prop = DCAM_IDPROP_INTENSITYLUT_MODE;
+    } else if (index == hOutputTriggerPolarity0) {
+      prop = DCAM_IDPROP_OUTPUTTRIGGER_POLARITY;
+    } else if (index == hOutputTriggerPolarity1) {
+      prop = DCAM_IDPROP_OUTPUTTRIGGER_POLARITY + 0x100;
+    } else if (index == hOutputTriggerPolarity2) {
+      prop = DCAM_IDPROP_OUTPUTTRIGGER_POLARITY + 0x200;
+    } else if (index == hOutputTriggerKind0) {
+      prop = DCAM_IDPROP_OUTPUTTRIGGER_KIND;
+    } else if (index == hOutputTriggerKind1) {
+      prop = DCAM_IDPROP_OUTPUTTRIGGER_KIND + 0x100;
+    } else if (index == hOutputTriggerKind2) {
+      prop = DCAM_IDPROP_OUTPUTTRIGGER_KIND + 0x200;
+    } else if (index == hOutputTriggerBaseSensor0) {
+      prop = DCAM_IDPROP_OUTPUTTRIGGER_BASESENSOR;
+    } else if (index == hOutputTriggerBaseSensor1) {
+      prop = DCAM_IDPROP_OUTPUTTRIGGER_BASESENSOR + 0x100;
+    } else if (index == hOutputTriggerBaseSensor2) {
+      prop = DCAM_IDPROP_OUTPUTTRIGGER_BASESENSOR + 0x200;
+    } else if (index == hOutputTriggerPreHsyncCount) {
+      prop = DCAM_IDPROP_OUTPUTTRIGGER_PREHSYNCCOUNT;
+    } else if (index == hMasterPulseMode) {
+      prop = DCAM_IDPROP_MASTERPULSE_MODE;
+    } else if (index == hMasterPulseTriggerSource) {
+      prop = DCAM_IDPROP_MASTERPULSE_TRIGGERSOURCE;
+    } else if (index == hMasterPulseBurstTimes) {
+      prop = DCAM_IDPROP_MASTERPULSE_BURSTTIMES;
+    } else if (index == hBitPerChannel) {
+      prop = DCAM_IDPROP_BITSPERCHANNEL;
+    } else if (index == hImagePixelType) {
+      prop = DCAM_IDPROP_IMAGE_PIXELTYPE;
+    } else {
+      return asynError;
     }
+
+    m_err = dcamprop_setgetvalue(m_hdcam, prop, &dvalue);
+    checkAndLogError(m_err, "dcamprop_setgetvalue()", prop, dvalue);
   }
 
+  status = setIntegerParam(index, value);
   /* Do callbacks so higher layers see any changes */
   status = (asynStatus)callParamCallbacks();
 
@@ -1489,7 +1277,7 @@ asynStatus Orca::writeInt32(asynUser* pasynUser, epicsInt32 value) {
               "%s:%s: function=%d, paramName=%s, value=%d\n", driverName,
               functionName, index, paramName, value);
 
-  return status;
+  return (asynStatus)status;
 }
 
 //============================================================================
-- 
GitLab