From d2c01bed013c4d24b7acbe26f7d9cf5174b6f332 Mon Sep 17 00:00:00 2001
From: IrieR <175622981+irierr@users.noreply.github.com>
Date: Thu, 29 Jan 2026 15:14:27 +0000
Subject: [PATCH 01/14] Add DDG output features (delay, enable, polarity,
 select, step enable, & width)

---
 andor3App/Db/andor3.template     |  97 ++++++++++++++++++
 andor3App/Db/andor3_settings.req |   6 ++
 andor3App/src/andor3.cpp         | 165 ++++++++++++++++++++++---------
 3 files changed, 219 insertions(+), 49 deletions(-)

diff --git a/andor3App/Db/andor3.template b/andor3App/Db/andor3.template
index 13717e45..f56f100f 100644
--- a/andor3App/Db/andor3.template
+++ b/andor3App/Db/andor3.template
@@ -343,6 +343,10 @@ record(stringin, "$(P)$(R)ControllerID")
    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_CONTROLLER_ID")
 }
 
+###############################################################################
+#  These records control the Gating (if present)                              #
+###############################################################################
+
 record(mbbo, "$(P)$(R)GateMode")
 {
    field(PINI, "YES")
@@ -406,3 +410,96 @@ record(bi, "$(P)$(R)MCPIntelligate_RBV")
    field(ONAM, "On")
 }
 
+record(ao, "$(P)$(R)DDGOutputDelay")
+{
+   field(PINI, "YES")
+   field(VAL,  "0")
+   field(DTYP, "asynInt32")
+   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_OUTPUT_DELAY")
+}
+
+record(ai, "$(P)$(R)DDGOutputDelay_RBV")
+{
+   field(DTYP, "asynInt32")
+   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_OUTPUT_DELAY")
+   field(SCAN, "I/O Intr")
+}
+
+record(bo, "$(P)$(R)DDGOutputEnable")
+{
+   field(PINI, "YES")
+   field(DTYP, "asynInt32")
+   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_OUTPUT_ENABLE")
+   field(ZNAM, "Disable")
+   field(ONAM, "Enable")
+}
+
+record(bi, "$(P)$(R)DDGOutputEnable_RBV")
+{
+   field(DTYP, "asynInt32")
+   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_OUTPUT_ENABLE")
+   field(SCAN, "I/O Intr")
+   field(ZNAM, "Disable")
+   field(ONAM, "Enable")
+}
+
+record(mbbo, "$(P)$(R)DDGOutputPolarity")
+{
+   field(PINI, "YES")
+   field(DTYP, "asynInt32")
+   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_OUTPUT_POLARITY")
+}
+
+record(mbbi, "$(P)$(R)DDGOutputPolarity_RBV")
+{
+   field(DTYP, "asynInt32")
+   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_OUTPUT_POLARITY")
+   field(SCAN, "I/O Intr")
+}
+
+record(mbbo, "$(P)$(R)DDGOutputSelect")
+{
+   field(PINI, "YES")
+   field(DTYP, "asynInt32")
+   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_OUTPUT_SELECT")
+}
+
+record(mbbi, "$(P)$(R)DDGOutputSelect_RBV")
+{
+   field(DTYP, "asynInt32")
+   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_OUTPUT_SELECT")
+   field(SCAN, "I/O Intr")
+}
+
+record(bo, "$(P)$(R)DDGOutputStepEnable")
+{
+   field(PINI, "YES")
+   field(DTYP, "asynInt32")
+   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_OUTPUT_STEP_ENABLE")
+   field(ZNAM, "Disable")
+   field(ONAM, "Enable")
+}
+
+record(bi, "$(P)$(R)DDGOutputStepEnable_RBV")
+{
+   field(DTYP, "asynInt32")
+   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_OUTPUT_STEP_ENABLE")
+   field(SCAN, "I/O Intr")
+   field(ZNAM, "Disable")
+   field(ONAM, "Enable")
+}
+
+record(ao, "$(P)$(R)DDGOutputWidth")
+{
+   field(PINI, "YES")
+   field(VAL,  "0")
+   field(DTYP, "asynInt32")
+   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_OUTPUT_WIDTH")
+}
+
+record(ai, "$(P)$(R)DDGOutputWidth_RBV")
+{
+   field(DTYP, "asynInt32")
+   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_OUTPUT_WIDTH")
+   field(SCAN, "I/O Intr")
+}
diff --git a/andor3App/Db/andor3_settings.req b/andor3App/Db/andor3_settings.req
index f315fa57..ccbbea93 100644
--- a/andor3App/Db/andor3_settings.req
+++ b/andor3App/Db/andor3_settings.req
@@ -13,4 +13,10 @@ $(P)$(R)GateMode
 $(P)$(R)InsertionDelay
 $(P)$(R)MCPIntelligate
 $(P)$(R)MCPGain
+$(P)$(R)DDGOutputDelay
+$(P)$(R)DDGOutputEnable
+$(P)$(R)DDGOutputPolarity
+$(P)$(R)DDGOutputSelect
+$(P)$(R)DDGOutputStepEnable
+$(P)$(R)DDGOutputWidth
 file "ADBase_settings.req", P=$(P), R=$(R)
diff --git a/andor3App/src/andor3.cpp b/andor3App/src/andor3.cpp
index 8a9f64c4..52ecb29e 100644
--- a/andor3App/src/andor3.cpp
+++ b/andor3App/src/andor3.cpp
@@ -119,7 +119,13 @@ class andor3 : public ADDriver {
     int Andor3InsertionDelay;
     int Andor3MCPGain;
     int Andor3MCPIntelligate;
-    #define LAST_ANDOR3_PARAM Andor3MCPIntelligate
+    int Andor3DDGOutputDelay;
+    int Andor3DDGOutputEnable;
+    int Andor3DDGOutputPolarity;
+    int Andor3DDGOutputSelect;
+    int Andor3DDGOutputStepEnable;
+    int Andor3DDGOutputWidth;
+    #define LAST_ANDOR3_PARAM Andor3DDGOutputWidth
 private:
     int registerFeature(const AT_WC *feature, Andor3FeatureType type,
                         int paramIndex);
@@ -147,30 +153,36 @@ class andor3 : public ADDriver {
 #define NUM_ANDOR3_PARAMS ((int)(&LAST_ANDOR3_PARAM - &FIRST_ANDOR3_PARAM + 1))
 
 /* Andor3 driver specific parameters */
-#define Andor3FrameRateString        "A3_FRAME_RATE"        /* asynFloat64  rw */
-#define Andor3PixelEncodingString    "A3_PIXEL_ENCODING"    /* asynInt32    rw */
-#define Andor3FullAOIControlString   "A3_FULL_AOI_CONTROL"  /* asynInt32    ro */
-#define Andor3BinningString          "A3_BINNING"           /* asynInt32    rw */
-#define Andor3ShutterModeString      "A3_SHUTTER_MODE"      /* asynInt32    rw */
-#define Andor3SoftwareTriggerString  "A3_SOFTWARE_TRIGGER"  /* asynInt32    wo */
-#define Andor3SensorCoolingString    "A3_SENSOR_COOLING"    /* asynInt32    rw */
-#define Andor3TempControlString      "A3_TEMP_CONTROL"      /* asynInt32    rw */
-#define Andor3TempStatusString       "A3_TEMP_STATUS"       /* asynInt32    ro */
-#define Andor3SerialNumberString     "A3_SERIAL_NUMBER"     /* asynOctet    ro */
-#define Andor3FirmwareVersionString  "A3_FIRMWARE_VERSION"  /* asynOctet    ro */
-#define Andor3SoftwareVersionString  "A3_SOFTWARE_VERSION"  /* asynOctet    ro */
-#define Andor3ControllerIDString     "A3_CONTROLLER_ID"     /* asynOctet    ro */
-#define Andor3OverlapString          "A3_OVERLAP"           /* asynInt32    rw */
-#define Andor3ReadoutRateString      "A3_READOUT_RATE"      /* asynInt32    rw */
-#define Andor3ReadoutTimeString      "A3_READOUT_TIME"      /* asynFloat64  rw */
-#define Andor3TransferRateString     "A3_TRANSFER_RATE"     /* asynFloat64  rw */
-#define Andor3PreAmpGainString       "A3_PREAMP_GAIN"       /* asynInt32    rw */
-#define Andor3NoiseFilterString      "A3_NOISE_FILTER"      /* asynInt32    rw */
-#define Andor3FanSpeedString         "A3_FAN_SPEED"         /* asynInt32    rw */
-#define Andor3GateModeString         "A3_GATE_MODE"         /* asynInt32    rw */
-#define Andor3InsertionDelayString   "A3_INSERTION_DELAY"   /* asynInt32    rw */
-#define Andor3MCPGainString          "A3_MCP_GAIN"          /* asynInt32    rw */
-#define Andor3MCPIntelligateString   "A3_MCP_INTELLIGATE"   /* asynInt32    rw */
+#define Andor3FrameRateString           "A3_FRAME_RATE"            /* asynFloat64  rw */
+#define Andor3PixelEncodingString       "A3_PIXEL_ENCODING"        /* asynInt32    rw */
+#define Andor3FullAOIControlString      "A3_FULL_AOI_CONTROL"      /* asynInt32    ro */
+#define Andor3BinningString             "A3_BINNING"               /* asynInt32    rw */
+#define Andor3ShutterModeString         "A3_SHUTTER_MODE"          /* asynInt32    rw */
+#define Andor3SoftwareTriggerString     "A3_SOFTWARE_TRIGGER"      /* asynInt32    wo */
+#define Andor3SensorCoolingString       "A3_SENSOR_COOLING"        /* asynInt32    rw */
+#define Andor3TempControlString         "A3_TEMP_CONTROL"          /* asynInt32    rw */
+#define Andor3TempStatusString          "A3_TEMP_STATUS"           /* asynInt32    ro */
+#define Andor3SerialNumberString        "A3_SERIAL_NUMBER"         /* asynOctet    ro */
+#define Andor3FirmwareVersionString     "A3_FIRMWARE_VERSION"      /* asynOctet    ro */
+#define Andor3SoftwareVersionString     "A3_SOFTWARE_VERSION"      /* asynOctet    ro */
+#define Andor3ControllerIDString        "A3_CONTROLLER_ID"         /* asynOctet    ro */
+#define Andor3OverlapString             "A3_OVERLAP"               /* asynInt32    rw */
+#define Andor3ReadoutRateString         "A3_READOUT_RATE"          /* asynInt32    rw */
+#define Andor3ReadoutTimeString         "A3_READOUT_TIME"          /* asynFloat64  rw */
+#define Andor3TransferRateString        "A3_TRANSFER_RATE"         /* asynFloat64  rw */
+#define Andor3PreAmpGainString          "A3_PREAMP_GAIN"           /* asynInt32    rw */
+#define Andor3NoiseFilterString         "A3_NOISE_FILTER"          /* asynInt32    rw */
+#define Andor3FanSpeedString            "A3_FAN_SPEED"             /* asynInt32    rw */
+#define Andor3GateModeString            "A3_GATE_MODE"             /* asynInt32    rw */
+#define Andor3InsertionDelayString      "A3_INSERTION_DELAY"       /* asynInt32    rw */
+#define Andor3MCPGainString             "A3_MCP_GAIN"              /* asynInt32    rw */
+#define Andor3MCPIntelligateString      "A3_MCP_INTELLIGATE"       /* asynInt32    rw */
+#define Andor3DDGOutputDelayString      "A3_DDG_OUTPUT_DELAY"      /* asynInt32    rw */
+#define Andor3DDGOutputEnableString     "A3_DDG_OUTPUT_ENABLE"     /* asynInt32    rw */
+#define Andor3DDGOutputPolarityString   "A3_DDG_OUTPUT_POLARITY"   /* asynInt32    rw */
+#define Andor3DDGOutputSelectString     "A3_DDG_OUTPUT_SELECT"     /* asynInt32    rw */
+#define Andor3DDGOutputStepEnableString "A3_DDG_OUTPUT_STEP_ENABLE"/* asynInt32    rw */
+#define Andor3DDGOutputWidthString      "A3_DDG_OUTPUT_WIDTH"      /* asynInt32    rw */
 
 static void c_shutdown(void *arg)
 {
@@ -660,6 +672,12 @@ void andor3::report(FILE *fp, int details)
     reportFeature(Andor3InsertionDelay, fp, details);
     reportFeature(Andor3MCPGain, fp, details);
     reportFeature(Andor3MCPIntelligate, fp, details);
+    reportFeature(Andor3DDGOutputDelay, fp, details);
+    reportFeature(Andor3DDGOutputEnable, fp, details);
+    reportFeature(Andor3DDGOutputPolarity, fp, details);
+    reportFeature(Andor3DDGOutputSelect, fp, details);
+    reportFeature(Andor3DDGOutputStepEnable, fp, details);
+    reportFeature(Andor3DDGOutputWidth, fp, details);
     
     ADDriver::report(fp, details);
 }    
@@ -1263,6 +1281,42 @@ asynStatus andor3::writeInt32(asynUser *pasynUser, epicsInt32 value)
             status = setFeature(Andor3MCPIntelligate);
         }
     }
+    else if(index == Andor3DDGOutputDelay) {
+        featureInfo *info = &featureInfo_[index];
+        if (info->isImplemented) {
+            status = setFeature(Andor3DDGOutputDelay);
+        }
+    }
+    else if(index == Andor3DDGOutputEnable) {
+        featureInfo *info = &featureInfo_[index];
+        if (info->isImplemented) {
+            status = setFeature(Andor3DDGOutputEnable);
+        }
+    }
+    else if(index == Andor3DDGOutputPolarity) {
+        featureInfo *info = &featureInfo_[index];
+        if (info->isImplemented) {
+            status = setFeature(Andor3DDGOutputPolarity);
+        }
+    }
+    else if(index == Andor3DDGOutputSelect) {
+        featureInfo *info = &featureInfo_[index];
+        if (info->isImplemented) {
+            status = setFeature(Andor3DDGOutputSelect);
+        }
+    }
+    else if(index == Andor3DDGOutputStepEnable) {
+        featureInfo *info = &featureInfo_[index];
+        if (info->isImplemented) {
+            status = setFeature(Andor3DDGOutputStepEnable);
+        }
+    }
+    else if(index == Andor3DDGOutputWidth) {
+        featureInfo *info = &featureInfo_[index];
+        if (info->isImplemented) {
+            status = setFeature(Andor3DDGOutputWidth);
+        }
+    }
     else {
         if(index < FIRST_ANDOR3_PARAM) {
             status = ADDriver::writeInt32(pasynUser, value);
@@ -1391,30 +1445,36 @@ andor3::andor3(const char *portName, const char *cameraSerial, int maxBuffers,
     }
     
     /* create andor specific parameters */
-    createParam(Andor3FrameRateString,        asynParamFloat64, &Andor3FrameRate);
-    createParam(Andor3PixelEncodingString,    asynParamInt32,   &Andor3PixelEncoding);
-    createParam(Andor3FullAOIControlString,   asynParamInt32,   &Andor3FullAOIControl);
-    createParam(Andor3BinningString,          asynParamInt32,   &Andor3Binning);
-    createParam(Andor3ShutterModeString,      asynParamInt32,   &Andor3ShutterMode);
-    createParam(Andor3SoftwareTriggerString,  asynParamInt32,   &Andor3SoftwareTrigger);
-    createParam(Andor3SensorCoolingString,    asynParamInt32,   &Andor3SensorCooling);
-    createParam(Andor3TempControlString,      asynParamInt32,   &Andor3TempControl);
-    createParam(Andor3TempStatusString,       asynParamInt32,   &Andor3TempStatus);
-    createParam(Andor3SerialNumberString,     asynParamOctet,   &Andor3SerialNumber);
-    createParam(Andor3FirmwareVersionString,  asynParamOctet,   &Andor3FirmwareVersion);
-    createParam(Andor3SoftwareVersionString,  asynParamOctet,   &Andor3SoftwareVersion);
-    createParam(Andor3ControllerIDString,     asynParamOctet,   &Andor3ControllerID);
-    createParam(Andor3OverlapString,          asynParamInt32,   &Andor3Overlap);
-    createParam(Andor3ReadoutRateString,      asynParamInt32,   &Andor3ReadoutRate);
-    createParam(Andor3ReadoutTimeString,      asynParamFloat64, &Andor3ReadoutTime);
-    createParam(Andor3TransferRateString,     asynParamFloat64, &Andor3TransferRate);
-    createParam(Andor3PreAmpGainString,       asynParamInt32,   &Andor3PreAmpGain);
-    createParam(Andor3NoiseFilterString,      asynParamInt32,   &Andor3NoiseFilter);
-    createParam(Andor3FanSpeedString,         asynParamInt32,   &Andor3FanSpeed);
-    createParam(Andor3GateModeString,         asynParamInt32,   &Andor3GateMode);
-    createParam(Andor3InsertionDelayString,   asynParamInt32,   &Andor3InsertionDelay);
-    createParam(Andor3MCPGainString,          asynParamInt32,   &Andor3MCPGain);
-    createParam(Andor3MCPIntelligateString,   asynParamInt32,   &Andor3MCPIntelligate);
+    createParam(Andor3FrameRateString,          asynParamFloat64, &Andor3FrameRate);
+    createParam(Andor3PixelEncodingString,      asynParamInt32,   &Andor3PixelEncoding);
+    createParam(Andor3FullAOIControlString,     asynParamInt32,   &Andor3FullAOIControl);
+    createParam(Andor3BinningString,            asynParamInt32,   &Andor3Binning);
+    createParam(Andor3ShutterModeString,        asynParamInt32,   &Andor3ShutterMode);
+    createParam(Andor3SoftwareTriggerString,    asynParamInt32,   &Andor3SoftwareTrigger);
+    createParam(Andor3SensorCoolingString,      asynParamInt32,   &Andor3SensorCooling);
+    createParam(Andor3TempControlString,        asynParamInt32,   &Andor3TempControl);
+    createParam(Andor3TempStatusString,         asynParamInt32,   &Andor3TempStatus);
+    createParam(Andor3SerialNumberString,       asynParamOctet,   &Andor3SerialNumber);
+    createParam(Andor3FirmwareVersionString,    asynParamOctet,   &Andor3FirmwareVersion);
+    createParam(Andor3SoftwareVersionString,    asynParamOctet,   &Andor3SoftwareVersion);
+    createParam(Andor3ControllerIDString,       asynParamOctet,   &Andor3ControllerID);
+    createParam(Andor3OverlapString,            asynParamInt32,   &Andor3Overlap);
+    createParam(Andor3ReadoutRateString,        asynParamInt32,   &Andor3ReadoutRate);
+    createParam(Andor3ReadoutTimeString,        asynParamFloat64, &Andor3ReadoutTime);
+    createParam(Andor3TransferRateString,       asynParamFloat64, &Andor3TransferRate);
+    createParam(Andor3PreAmpGainString,         asynParamInt32,   &Andor3PreAmpGain);
+    createParam(Andor3NoiseFilterString,        asynParamInt32,   &Andor3NoiseFilter);
+    createParam(Andor3FanSpeedString,           asynParamInt32,   &Andor3FanSpeed);
+    createParam(Andor3GateModeString,           asynParamInt32,   &Andor3GateMode);
+    createParam(Andor3InsertionDelayString,     asynParamInt32,   &Andor3InsertionDelay);
+    createParam(Andor3MCPGainString,            asynParamInt32,   &Andor3MCPGain);
+    createParam(Andor3MCPIntelligateString,     asynParamInt32,   &Andor3MCPIntelligate);
+    createParam(Andor3DDGOutputDelayString,     asynParamInt32,   &Andor3DDGOutputDelay);
+    createParam(Andor3DDGOutputEnableString,    asynParamInt32,   &Andor3DDGOutputEnable);
+    createParam(Andor3DDGOutputPolarityString,  asynParamInt32,   &Andor3DDGOutputPolarity);
+    createParam(Andor3DDGOutputSelectString,    asynParamInt32,   &Andor3DDGOutputSelect);
+    createParam(Andor3DDGOutputStepEnableString,asynParamInt32,   &Andor3DDGOutputStepEnable);
+    createParam(Andor3DDGOutputWidthString,     asynParamInt32,   &Andor3DDGOutputWidth);
 
     featureInfo_ = (featureInfo *)calloc(LAST_ANDOR3_PARAM+1, sizeof(featureInfo));
         
@@ -1496,10 +1556,17 @@ andor3::andor3(const char *portName, const char *cameraSerial, int maxBuffers,
     status |= registerFeature(L"MaxInterfaceTransferRate", ATfloat,  Andor3TransferRate);
     status |= registerFeature(L"SimplePreAmpGainControl",  ATenum,   Andor3PreAmpGain);
     status |= registerFeature(L"SpuriousNoiseFilter",      ATbool,   Andor3NoiseFilter);
+
     status |= registerFeature(L"GateMode",                 ATenum,   Andor3GateMode);
     status |= registerFeature(L"InsertionDelay",           ATenum,   Andor3InsertionDelay);
     status |= registerFeature(L"MCPGain",                  ATint,    Andor3MCPGain);
     status |= registerFeature(L"MCPIntelligate",           ATbool,   Andor3MCPIntelligate);
+    status |= registerFeature(L"DDGOutputDelay",           ATint,    Andor3DDGOutputDelay);
+    status |= registerFeature(L"DDGOutputEnable",          ATbool,   Andor3DDGOutputEnable);
+    status |= registerFeature(L"DDGOutputPolarity",        ATenum,   Andor3DDGOutputPolarity);
+    status |= registerFeature(L"DDGOutputSelector",        ATenum,   Andor3DDGOutputSelect);
+    status |= registerFeature(L"DDGOutputStepEnable",      ATbool,   Andor3DDGOutputStepEnable);
+    status |= registerFeature(L"DDGOutputWidth",           ATint,    Andor3DDGOutputPolarity);
 
     if(status != AT_SUCCESS) {
         asynPrint(pasynUserSelf, ASYN_TRACE_ERROR,

From 5e00555a51ce16befcecb2447fc64a998d1b5864 Mon Sep 17 00:00:00 2001
From: IrieR <175622981+irierr@users.noreply.github.com>
Date: Thu, 29 Jan 2026 15:14:57 +0000
Subject: [PATCH 02/14] add vs* folders to gitignore

---
 .gitignore | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.gitignore b/.gitignore
index 7df1a866..06f8d256 100644
--- a/.gitignore
+++ b/.gitignore
@@ -13,3 +13,4 @@ configure/*.local
 O.*/
 *~
 *.swp
+.vs*

From e04b501eb32d21420788eb6da03d9de4930e2d85 Mon Sep 17 00:00:00 2001
From: IrieR <175622981+irierr@users.noreply.github.com>
Date: Fri, 30 Jan 2026 10:39:03 +0000
Subject: [PATCH 03/14] change template file spacing to 4 from 3

---
 andor3App/Db/andor3.template | 506 +++++++++++++++++------------------
 1 file changed, 253 insertions(+), 253 deletions(-)

diff --git a/andor3App/Db/andor3.template b/andor3App/Db/andor3.template
index f56f100f..cf151bdd 100644
--- a/andor3App/Db/andor3.template
+++ b/andor3App/Db/andor3.template
@@ -17,83 +17,83 @@ include "ADBase.template"
 # Only unsigned 16 and 32 bit integers are supported.  Determined by PixelEncoding
 record(mbbo, "$(P)$(R)DataType")
 {
-   field(ZRST, "UInt16")
-   field(ZRVL, "3")
-   field(ONST, "UInt32")
-   field(ONVL, "5")
-   field(TWST, "")
-   field(TWVL, "")
-   field(THST, "")
-   field(THVL, "")
-   field(FRST, "")
-   field(FRVL, "")
-   field(FVST, "")
-   field(FVVL, "")
-   field(SXST, "")
-   field(SXVL, "")
-   field(SVST, "")
-   field(SVVL, "")
+    field(ZRST, "UInt16")
+    field(ZRVL, "3")
+    field(ONST, "UInt32")
+    field(ONVL, "5")
+    field(TWST, "")
+    field(TWVL, "")
+    field(THST, "")
+    field(THVL, "")
+    field(FRST, "")
+    field(FRVL, "")
+    field(FVST, "")
+    field(FVVL, "")
+    field(SXST, "")
+    field(SXVL, "")
+    field(SVST, "")
+    field(SVVL, "")
 }
 
 record(mbbi, "$(P)$(R)DataType_RBV")
 {
-   field(ZRST, "UInt16")
-   field(ZRVL, "3")
-   field(ONST, "UInt32")
-   field(ONVL, "5")
-   field(TWST, "")
-   field(TWVL, "")
-   field(THST, "")
-   field(THVL, "")
-   field(FRST, "")
-   field(FRVL, "")
-   field(FVST, "")
-   field(FVVL, "")
-   field(SXST, "")
-   field(SXVL, "")
-   field(SVST, "")
-   field(SVVL, "")
+    field(ZRST, "UInt16")
+    field(ZRVL, "3")
+    field(ONST, "UInt32")
+    field(ONVL, "5")
+    field(TWST, "")
+    field(TWVL, "")
+    field(THST, "")
+    field(THVL, "")
+    field(FRST, "")
+    field(FRVL, "")
+    field(FVST, "")
+    field(FVVL, "")
+    field(SXST, "")
+    field(SXVL, "")
+    field(SVST, "")
+    field(SVVL, "")
 }
 
 # Only Mono color mode is supported at this time
 record(mbbo, "$(P)$(R)ColorMode")
 {
-   field(ZRST, "Mono")
-   field(ZRVL, "0")
-   field(ONST, "")
-   field(ONVL, "")
-   field(TWST, "")
-   field(TWVL, "")
-   field(THST, "")
-   field(THVL, "")
-   field(FRST, "")
-   field(FRVL, "")
-   field(FVST, "")
-   field(FVVL, "")
-   field(SXST, "")
-   field(SXVL, "")
-   field(SVST, "")
-   field(SVVL, "")
+    field(ZRST, "Mono")
+    field(ZRVL, "0")
+    field(ONST, "")
+    field(ONVL, "")
+    field(TWST, "")
+    field(TWVL, "")
+    field(THST, "")
+    field(THVL, "")
+    field(FRST, "")
+    field(FRVL, "")
+    field(FVST, "")
+    field(FVVL, "")
+    field(SXST, "")
+    field(SXVL, "")
+    field(SVST, "")
+    field(SVVL, "")
 }
 
 record(mbbi, "$(P)$(R)ColorMode_RBV")
 {
-   field(ZRST, "Mono")
-   field(ZRVL, "0")
-   field(ONST, "")
-   field(ONVL, "")
-   field(TWST, "")
-   field(TWVL, "")
-   field(THST, "")
-   field(THVL, "")
-   field(FRST, "")
-   field(FRVL, "")
-   field(FVST, "")
-   field(FVVL, "")
-   field(SXST, "")
-   field(SXVL, "")
-   field(SVST, "")
-   field(SVVL, "")
+    field(ZRST, "Mono")
+    field(ZRVL, "0")
+    field(ONST, "")
+    field(ONVL, "")
+    field(TWST, "")
+    field(TWVL, "")
+    field(THST, "")
+    field(THVL, "")
+    field(FRST, "")
+    field(FRVL, "")
+    field(FVST, "")
+    field(FVVL, "")
+    field(SXST, "")
+    field(SXVL, "")
+    field(SVST, "")
+    field(SVVL, "")
 }
 
 
@@ -109,238 +109,238 @@ record(mbbi, "$(P)$(R)ColorMode_RBV")
 
 record(ao, "$(P)$(R)FrameRate")
 {
-   field(PINI, "YES")
-   field(DTYP, "asynFloat64")
-   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_FRAME_RATE")  
-   field(VAL,  "10")
+    field(PINI, "YES")
+    field(DTYP, "asynFloat64")
+    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_FRAME_RATE")  
+    field(VAL,  "10")
 }
 
 record(ai, "$(P)$(R)FrameRate_RBV")
 {
-   field(DTYP, "asynFloat64")
-   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_FRAME_RATE")
-   field(PREC, "3")
-   field(SCAN, "I/O Intr")
+    field(DTYP, "asynFloat64")
+    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_FRAME_RATE")
+    field(PREC, "3")
+    field(SCAN, "I/O Intr")
 }
 
 record(mbbo, "$(P)$(R)PreAmpGain")
 {
-   field(PINI, "YES")
-   field(DTYP, "asynInt32")
-   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_PREAMP_GAIN")
+    field(PINI, "YES")
+    field(DTYP, "asynInt32")
+    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_PREAMP_GAIN")
 }
 
 record(mbbi, "$(P)$(R)PreAmpGain_RBV")
 {
-   field(DTYP, "asynInt32")
-   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_PREAMP_GAIN")
-   field(SCAN, "I/O Intr")
+    field(DTYP, "asynInt32")
+    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_PREAMP_GAIN")
+    field(SCAN, "I/O Intr")
 }
 
 record(mbbo, "$(P)$(R)ReadoutRate")
 {
-   field(PINI, "YES")
-   field(DTYP, "asynInt32")
-   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_READOUT_RATE")
+    field(PINI, "YES")
+    field(DTYP, "asynInt32")
+    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_READOUT_RATE")
 }
 
 record(mbbi, "$(P)$(R)ReadoutRate_RBV")
 {
-   field(DTYP, "asynInt32")
-   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_READOUT_RATE")
-   field(SCAN, "I/O Intr")
+    field(DTYP, "asynInt32")
+    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_READOUT_RATE")
+    field(SCAN, "I/O Intr")
 }
 
 record(bo, "$(P)$(R)Overlap")
 {
-   field(PINI, "YES")
-   field(DTYP, "asynInt32")
-   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_OVERLAP")
-   field(ZNAM, "No")
-   field(ONAM, "Yes")
+    field(PINI, "YES")
+    field(DTYP, "asynInt32")
+    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_OVERLAP")
+    field(ZNAM, "No")
+    field(ONAM, "Yes")
 }
 
 record(bi, "$(P)$(R)Overlap_RBV")
 {
-   field(DTYP, "asynInt32")
-   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_OVERLAP")
-   field(ZNAM, "No")
-   field(ONAM, "Yes")
-   field(SCAN, "I/O Intr")
+    field(DTYP, "asynInt32")
+    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_OVERLAP")
+    field(ZNAM, "No")
+    field(ONAM, "Yes")
+    field(SCAN, "I/O Intr")
 }
 
 record(bo, "$(P)$(R)NoiseFilter")
 {
-   field(PINI, "YES")
-   field(DTYP, "asynInt32")
-   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_NOISE_FILTER")
-   field(ZNAM, "No")
-   field(ONAM, "Yes")
+    field(PINI, "YES")
+    field(DTYP, "asynInt32")
+    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_NOISE_FILTER")
+    field(ZNAM, "No")
+    field(ONAM, "Yes")
 }
 
 record(bi, "$(P)$(R)NoiseFilter_RBV")
 {
-   field(DTYP, "asynInt32")
-   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_NOISE_FILTER")
-   field(ZNAM, "No")
-   field(ONAM, "Yes")
-   field(SCAN, "I/O Intr")
+    field(DTYP, "asynInt32")
+    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_NOISE_FILTER")
+    field(ZNAM, "No")
+    field(ONAM, "Yes")
+    field(SCAN, "I/O Intr")
 }
 
 record(mbbo, "$(P)$(R)PixelEncoding")
 {
-   field(PINI, "YES")
-   field(DTYP, "asynInt32")
-   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_PIXEL_ENCODING")
+    field(PINI, "YES")
+    field(DTYP, "asynInt32")
+    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_PIXEL_ENCODING")
 }
 
 record(mbbi, "$(P)$(R)PixelEncoding_RBV")
 {
-   field(DTYP, "asynInt32")
-   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_PIXEL_ENCODING")
-   field(SCAN, "I/O Intr")
+    field(DTYP, "asynInt32")
+    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_PIXEL_ENCODING")
+    field(SCAN, "I/O Intr")
 }
 
 record(ai, "$(P)$(R)ReadoutTime")
 {
-   field(DTYP, "asynFloat64")
-   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_READOUT_TIME")
-   field(PREC, "4")
-   field(SCAN, "I/O Intr")
+    field(DTYP, "asynFloat64")
+    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_READOUT_TIME")
+    field(PREC, "4")
+    field(SCAN, "I/O Intr")
 }
 
 record(ai, "$(P)$(R)TransferRate")
 {
-   field(DTYP, "asynFloat64")
-   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_TRANSFER_RATE")
-   field(PREC, "3")
-   field(SCAN, "I/O Intr")
+    field(DTYP, "asynFloat64")
+    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_TRANSFER_RATE")
+    field(PREC, "3")
+    field(SCAN, "I/O Intr")
 }
 
 record(bi, "$(P)$(R)FullAOIControl")
 {
-   field(DTYP, "asynInt32")
-   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_FULL_AOI_CONTROL")
-   field(ZNAM, "No")
-   field(ONAM, "Yes")
-   field(SCAN, "I/O Intr")
+    field(DTYP, "asynInt32")
+    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_FULL_AOI_CONTROL")
+    field(ZNAM, "No")
+    field(ONAM, "Yes")
+    field(SCAN, "I/O Intr")
 }
 
 record(mbbo, "$(P)$(R)A3Binning")
 {
-   field(PINI, "YES")
-   field(DTYP, "asynInt32")
-   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_BINNING")
+    field(PINI, "YES")
+    field(DTYP, "asynInt32")
+    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_BINNING")
 }
 
 record(mbbi, "$(P)$(R)A3Binning_RBV")
 {
-   field(DTYP, "asynInt32")
-   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_BINNING")
-   field(SCAN, "I/O Intr")
+    field(DTYP, "asynInt32")
+    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_BINNING")
+    field(SCAN, "I/O Intr")
 }
 
 record(mbbo, "$(P)$(R)A3ShutterMode")
 {
-   field(PINI, "YES")
-   field(DTYP, "asynInt32")
-   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_SHUTTER_MODE")
+    field(PINI, "YES")
+    field(DTYP, "asynInt32")
+    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_SHUTTER_MODE")
 }
 
 record(mbbi, "$(P)$(R)A3ShutterMode_RBV")
 {
-   field(DTYP, "asynInt32")
-   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_SHUTTER_MODE")
-   field(SCAN, "I/O Intr")
+    field(DTYP, "asynInt32")
+    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_SHUTTER_MODE")
+    field(SCAN, "I/O Intr")
 }
 
 record(bo, "$(P)$(R)SoftwareTrigger")
 {
-   field(DTYP, "asynInt32")
-   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_SOFTWARE_TRIGGER")
-   field(ZNAM, "Done")
-   field(ONAM, "Trigger")
+    field(DTYP, "asynInt32")
+    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_SOFTWARE_TRIGGER")
+    field(ZNAM, "Done")
+    field(ONAM, "Trigger")
 }
 
 record(bo, "$(P)$(R)SensorCooling")
 {
-   field(PINI, "YES")
-   field(DTYP, "asynInt32")
-   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_SENSOR_COOLING")
-   field(ZNAM, "Off")
-   field(ONAM, "On")
+    field(PINI, "YES")
+    field(DTYP, "asynInt32")
+    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_SENSOR_COOLING")
+    field(ZNAM, "Off")
+    field(ONAM, "On")
 }
 
 record(bi, "$(P)$(R)SensorCooling_RBV")
 {
-   field(DTYP, "asynInt32")
-   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_SENSOR_COOLING")
-   field(SCAN, "I/O Intr")
-   field(ZNAM, "Off")
-   field(ONAM, "On")
+    field(DTYP, "asynInt32")
+    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_SENSOR_COOLING")
+    field(SCAN, "I/O Intr")
+    field(ZNAM, "Off")
+    field(ONAM, "On")
 }
 
 record(mbbo, "$(P)$(R)TempControl")
 {
-   field(PINI, "YES")
-   field(DTYP, "asynInt32")
-   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_TEMP_CONTROL")
+    field(PINI, "YES")
+    field(DTYP, "asynInt32")
+    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_TEMP_CONTROL")
 }
 
 record(mbbi, "$(P)$(R)TempControl_RBV")
 {
-   field(DTYP, "asynInt32")
-   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_TEMP_CONTROL")
-   field(SCAN, "I/O Intr")
+    field(DTYP, "asynInt32")
+    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_TEMP_CONTROL")
+    field(SCAN, "I/O Intr")
 }
 
 record(mbbi, "$(P)$(R)TempStatus_RBV")
 {
-   field(DTYP, "asynInt32")
-   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_TEMP_STATUS")
-   field(SCAN, "I/O Intr")
+    field(DTYP, "asynInt32")
+    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_TEMP_STATUS")
+    field(SCAN, "I/O Intr")
 }
 
 record(mbbo, "$(P)$(R)FanSpeed")
 {
-   field(PINI, "YES")
-   field(DTYP, "asynInt32")
-   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_FAN_SPEED")
+    field(PINI, "YES")
+    field(DTYP, "asynInt32")
+    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_FAN_SPEED")
 }
 
 record(mbbi, "$(P)$(R)FanSpeed_RBV")
 {
-   field(DTYP, "asynInt32")
-   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_FAN_SPEED")
-   field(SCAN, "I/O Intr")
+    field(DTYP, "asynInt32")
+    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_FAN_SPEED")
+    field(SCAN, "I/O Intr")
 }
 
 record(stringin, "$(P)$(R)SerialNumber")
 {
-   field(PINI, "YES")
-   field(DTYP, "asynOctetRead")
-   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_SERIAL_NUMBER")
+    field(PINI, "YES")
+    field(DTYP, "asynOctetRead")
+    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_SERIAL_NUMBER")
 }
 
 record(stringin, "$(P)$(R)FirmwareVersion")
 {
-   field(PINI, "YES")
-   field(DTYP, "asynOctetRead")
-   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_FIRMWARE_VERSION")
+    field(PINI, "YES")
+    field(DTYP, "asynOctetRead")
+    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_FIRMWARE_VERSION")
 }
 
 record(stringin, "$(P)$(R)SoftwareVersion")
 {
-   field(PINI, "YES")
-   field(DTYP, "asynOctetRead")
-   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_SOFTWARE_VERSION")
+    field(PINI, "YES")
+    field(DTYP, "asynOctetRead")
+    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_SOFTWARE_VERSION")
 }
 
 record(stringin, "$(P)$(R)ControllerID")
 {
-   field(PINI, "YES")
-   field(DTYP, "asynOctetRead")
-   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_CONTROLLER_ID")
+    field(PINI, "YES")
+    field(DTYP, "asynOctetRead")
+    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_CONTROLLER_ID")
 }
 
 ###############################################################################
@@ -349,157 +349,157 @@ record(stringin, "$(P)$(R)ControllerID")
 
 record(mbbo, "$(P)$(R)GateMode")
 {
-   field(PINI, "YES")
-   field(DTYP, "asynInt32")
-   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_GATE_MODE")
+    field(PINI, "YES")
+    field(DTYP, "asynInt32")
+    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_GATE_MODE")
 }
 
 record(mbbi, "$(P)$(R)GateMode_RBV")
 {
-   field(DTYP, "asynInt32")
-   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_GATE_MODE")
-   field(SCAN, "I/O Intr")
+    field(DTYP, "asynInt32")
+    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_GATE_MODE")
+    field(SCAN, "I/O Intr")
 }
 
 record(mbbo, "$(P)$(R)InsertionDelay")
 {
-   field(PINI, "YES")
-   field(VAL,  "0")
-   field(DTYP, "asynInt32")
-   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_INSERTION_DELAY")
+    field(PINI, "YES")
+    field(VAL,  "0")
+    field(DTYP, "asynInt32")
+    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_INSERTION_DELAY")
 }
 
 record(mbbi, "$(P)$(R)InsertionDelay_RBV")
 {
-   field(DTYP, "asynInt32")
-   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_INSERTION_DELAY")
-   field(SCAN, "I/O Intr")
+    field(DTYP, "asynInt32")
+    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_INSERTION_DELAY")
+    field(SCAN, "I/O Intr")
 }
 
 record(longout, "$(P)$(R)MCPGain")
 {
-   field(PINI, "YES")
-   field(VAL,  "0")
-   field(DTYP, "asynInt32")
-   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_MCP_GAIN")
+    field(PINI, "YES")
+    field(VAL,  "0")
+    field(DTYP, "asynInt32")
+    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_MCP_GAIN")
 }
 
 record(longin, "$(P)$(R)MCPGain_RBV")
 {
-   field(DTYP, "asynInt32")
-   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_MCP_GAIN")
-   field(SCAN, "I/O Intr")
+    field(DTYP, "asynInt32")
+    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_MCP_GAIN")
+    field(SCAN, "I/O Intr")
 }
 
 record(bo, "$(P)$(R)MCPIntelligate")
 {
-   field(PINI, "YES")
-   field(VAL,  "0")
-   field(DTYP, "asynInt32")
-   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_MCP_INTELLIGATE")
-   field(ZNAM, "Off")
-   field(ONAM, "On")
+    field(PINI, "YES")
+    field(VAL,  "0")
+    field(DTYP, "asynInt32")
+    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_MCP_INTELLIGATE")
+    field(ZNAM, "Off")
+    field(ONAM, "On")
 }
 
 record(bi, "$(P)$(R)MCPIntelligate_RBV")
 {
-   field(DTYP, "asynInt32")
-   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_MCP_INTELLIGATE")
-   field(SCAN, "I/O Intr")
-   field(ZNAM, "Off")
-   field(ONAM, "On")
+    field(DTYP, "asynInt32")
+    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_MCP_INTELLIGATE")
+    field(SCAN, "I/O Intr")
+    field(ZNAM, "Off")
+    field(ONAM, "On")
 }
 
 record(ao, "$(P)$(R)DDGOutputDelay")
 {
-   field(PINI, "YES")
-   field(VAL,  "0")
-   field(DTYP, "asynInt32")
-   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_OUTPUT_DELAY")
+    field(PINI, "YES")
+    field(VAL,  "0")
+    field(DTYP, "asynInt32")
+    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_OUTPUT_DELAY")
 }
 
 record(ai, "$(P)$(R)DDGOutputDelay_RBV")
 {
-   field(DTYP, "asynInt32")
-   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_OUTPUT_DELAY")
-   field(SCAN, "I/O Intr")
+    field(DTYP, "asynInt32")
+    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_OUTPUT_DELAY")
+    field(SCAN, "I/O Intr")
 }
 
 record(bo, "$(P)$(R)DDGOutputEnable")
 {
-   field(PINI, "YES")
-   field(DTYP, "asynInt32")
-   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_OUTPUT_ENABLE")
-   field(ZNAM, "Disable")
-   field(ONAM, "Enable")
+    field(PINI, "YES")
+    field(DTYP, "asynInt32")
+    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_OUTPUT_ENABLE")
+    field(ZNAM, "Disable")
+    field(ONAM, "Enable")
 }
 
 record(bi, "$(P)$(R)DDGOutputEnable_RBV")
 {
-   field(DTYP, "asynInt32")
-   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_OUTPUT_ENABLE")
-   field(SCAN, "I/O Intr")
-   field(ZNAM, "Disable")
-   field(ONAM, "Enable")
+    field(DTYP, "asynInt32")
+    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_OUTPUT_ENABLE")
+    field(SCAN, "I/O Intr")
+    field(ZNAM, "Disable")
+    field(ONAM, "Enable")
 }
 
 record(mbbo, "$(P)$(R)DDGOutputPolarity")
 {
-   field(PINI, "YES")
-   field(DTYP, "asynInt32")
-   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_OUTPUT_POLARITY")
+    field(PINI, "YES")
+    field(DTYP, "asynInt32")
+    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_OUTPUT_POLARITY")
 }
 
 record(mbbi, "$(P)$(R)DDGOutputPolarity_RBV")
 {
-   field(DTYP, "asynInt32")
-   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_OUTPUT_POLARITY")
-   field(SCAN, "I/O Intr")
+    field(DTYP, "asynInt32")
+    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_OUTPUT_POLARITY")
+    field(SCAN, "I/O Intr")
 }
 
 record(mbbo, "$(P)$(R)DDGOutputSelect")
 {
-   field(PINI, "YES")
-   field(DTYP, "asynInt32")
-   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_OUTPUT_SELECT")
+    field(PINI, "YES")
+    field(DTYP, "asynInt32")
+    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_OUTPUT_SELECT")
 }
 
 record(mbbi, "$(P)$(R)DDGOutputSelect_RBV")
 {
-   field(DTYP, "asynInt32")
-   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_OUTPUT_SELECT")
-   field(SCAN, "I/O Intr")
+    field(DTYP, "asynInt32")
+    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_OUTPUT_SELECT")
+    field(SCAN, "I/O Intr")
 }
 
 record(bo, "$(P)$(R)DDGOutputStepEnable")
 {
-   field(PINI, "YES")
-   field(DTYP, "asynInt32")
-   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_OUTPUT_STEP_ENABLE")
-   field(ZNAM, "Disable")
-   field(ONAM, "Enable")
+    field(PINI, "YES")
+    field(DTYP, "asynInt32")
+    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_OUTPUT_STEP_ENABLE")
+    field(ZNAM, "Disable")
+    field(ONAM, "Enable")
 }
 
 record(bi, "$(P)$(R)DDGOutputStepEnable_RBV")
 {
-   field(DTYP, "asynInt32")
-   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_OUTPUT_STEP_ENABLE")
-   field(SCAN, "I/O Intr")
-   field(ZNAM, "Disable")
-   field(ONAM, "Enable")
+    field(DTYP, "asynInt32")
+    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_OUTPUT_STEP_ENABLE")
+    field(SCAN, "I/O Intr")
+    field(ZNAM, "Disable")
+    field(ONAM, "Enable")
 }
 
 record(ao, "$(P)$(R)DDGOutputWidth")
 {
-   field(PINI, "YES")
-   field(VAL,  "0")
-   field(DTYP, "asynInt32")
-   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_OUTPUT_WIDTH")
+    field(PINI, "YES")
+    field(VAL,  "0")
+    field(DTYP, "asynInt32")
+    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_OUTPUT_WIDTH")
 }
 
 record(ai, "$(P)$(R)DDGOutputWidth_RBV")
 {
-   field(DTYP, "asynInt32")
-   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_OUTPUT_WIDTH")
-   field(SCAN, "I/O Intr")
+    field(DTYP, "asynInt32")
+    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_OUTPUT_WIDTH")
+    field(SCAN, "I/O Intr")
 }

From 132aa961159f93308269878779d73e57e91cf7ba Mon Sep 17 00:00:00 2001
From: IrieR <175622981+irierr@users.noreply.github.com>
Date: Fri, 30 Jan 2026 10:40:07 +0000
Subject: [PATCH 04/14] Add EGU of ps to DDG output delay and width

---
 andor3App/Db/andor3.template | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/andor3App/Db/andor3.template b/andor3App/Db/andor3.template
index cf151bdd..d9057fe0 100644
--- a/andor3App/Db/andor3.template
+++ b/andor3App/Db/andor3.template
@@ -415,12 +415,14 @@ record(ao, "$(P)$(R)DDGOutputDelay")
     field(PINI, "YES")
     field(VAL,  "0")
     field(DTYP, "asynInt32")
+    field(EGU, "ps")
     field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_OUTPUT_DELAY")
 }
 
 record(ai, "$(P)$(R)DDGOutputDelay_RBV")
 {
     field(DTYP, "asynInt32")
+    field(EGU, "ps")
     field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_OUTPUT_DELAY")
     field(SCAN, "I/O Intr")
 }
@@ -494,12 +496,14 @@ record(ao, "$(P)$(R)DDGOutputWidth")
     field(PINI, "YES")
     field(VAL,  "0")
     field(DTYP, "asynInt32")
+    field(EGU, "ps")
     field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_OUTPUT_WIDTH")
 }
 
 record(ai, "$(P)$(R)DDGOutputWidth_RBV")
 {
     field(DTYP, "asynInt32")
+    field(EGU, "ps")
     field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_OUTPUT_WIDTH")
     field(SCAN, "I/O Intr")
 }

From 0bfcdeed793b19a6a4fb1a827dbeea6e786de4dd Mon Sep 17 00:00:00 2001
From: IrieR <175622981+irierr@users.noreply.github.com>
Date: Fri, 30 Jan 2026 12:00:47 +0000
Subject: [PATCH 05/14] fix registering of DDG output width

---
 andor3App/src/andor3.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/andor3App/src/andor3.cpp b/andor3App/src/andor3.cpp
index 52ecb29e..e5cba82e 100644
--- a/andor3App/src/andor3.cpp
+++ b/andor3App/src/andor3.cpp
@@ -1566,7 +1566,7 @@ andor3::andor3(const char *portName, const char *cameraSerial, int maxBuffers,
     status |= registerFeature(L"DDGOutputPolarity",        ATenum,   Andor3DDGOutputPolarity);
     status |= registerFeature(L"DDGOutputSelector",        ATenum,   Andor3DDGOutputSelect);
     status |= registerFeature(L"DDGOutputStepEnable",      ATbool,   Andor3DDGOutputStepEnable);
-    status |= registerFeature(L"DDGOutputWidth",           ATint,    Andor3DDGOutputPolarity);
+    status |= registerFeature(L"DDGOutputWidth",           ATint,    Andor3DDGOutputWidth);
 
     if(status != AT_SUCCESS) {
         asynPrint(pasynUserSelf, ASYN_TRACE_ERROR,

From 86a86c52cf4d3dffb44257ce3aa173eb76ffa2ea Mon Sep 17 00:00:00 2001
From: IrieR <175622981+irierr@users.noreply.github.com>
Date: Fri, 30 Jan 2026 13:58:43 +0000
Subject: [PATCH 06/14] add prec of 2 to ddg output inputs

---
 andor3App/Db/andor3.template | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/andor3App/Db/andor3.template b/andor3App/Db/andor3.template
index d9057fe0..78acdd74 100644
--- a/andor3App/Db/andor3.template
+++ b/andor3App/Db/andor3.template
@@ -416,6 +416,7 @@ record(ao, "$(P)$(R)DDGOutputDelay")
     field(VAL,  "0")
     field(DTYP, "asynInt32")
     field(EGU, "ps")
+    field(PREC, "0")
     field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_OUTPUT_DELAY")
 }
 
@@ -423,6 +424,7 @@ record(ai, "$(P)$(R)DDGOutputDelay_RBV")
 {
     field(DTYP, "asynInt32")
     field(EGU, "ps")
+    field(PREC, "0")
     field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_OUTPUT_DELAY")
     field(SCAN, "I/O Intr")
 }
@@ -497,6 +499,7 @@ record(ao, "$(P)$(R)DDGOutputWidth")
     field(VAL,  "0")
     field(DTYP, "asynInt32")
     field(EGU, "ps")
+    field(PREC, "0")
     field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_OUTPUT_WIDTH")
 }
 
@@ -504,6 +507,7 @@ record(ai, "$(P)$(R)DDGOutputWidth_RBV")
 {
     field(DTYP, "asynInt32")
     field(EGU, "ps")
+    field(PREC, "0")
     field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_OUTPUT_WIDTH")
     field(SCAN, "I/O Intr")
 }

From 4245db923794a47b491117a80447cb350239746e Mon Sep 17 00:00:00 2001
From: IrieR <175622981+irierr@users.noreply.github.com>
Date: Fri, 30 Jan 2026 16:08:45 +0000
Subject: [PATCH 07/14] add fanout to update DDG output parameters based on
 selected output

---
 andor3App/Db/andor3.template | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/andor3App/Db/andor3.template b/andor3App/Db/andor3.template
index 78acdd74..3d580bd3 100644
--- a/andor3App/Db/andor3.template
+++ b/andor3App/Db/andor3.template
@@ -473,6 +473,16 @@ record(mbbi, "$(P)$(R)DDGOutputSelect_RBV")
     field(DTYP, "asynInt32")
     field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_OUTPUT_SELECT")
     field(SCAN, "I/O Intr")
+    field(FLNK, "$(P)$(R)DDGOutputSelectFanout")
+}
+
+record(fanout, "$(P)$(R)DDGOutputSelectFanout")
+{
+    field(LNK1, "$(P)$(R)DDGOutputDelay")
+    field(LNK2, "$(P)$(R)DDGOutputWidth")
+    field(LNK3, "$(P)$(R)DDGOutputPolarity")
+    field(LNK4, "$(P)$(R)DDGOutputEnable")
+    field(LNK5, "$(P)$(R)DDGOutputStepEnable")
 }
 
 record(bo, "$(P)$(R)DDGOutputStepEnable")

From b235d7f32319db848f96d9ff5e7f774704786a36 Mon Sep 17 00:00:00 2001
From: IrieR <175622981+irierr@users.noreply.github.com>
Date: Mon, 9 Feb 2026 14:58:45 +0000
Subject: [PATCH 08/14] add update of ddg output features after output
 selection

---
 andor3App/Db/andor3.template | 10 ----------
 andor3App/src/andor3.cpp     |  8 ++++++++
 2 files changed, 8 insertions(+), 10 deletions(-)

diff --git a/andor3App/Db/andor3.template b/andor3App/Db/andor3.template
index 3d580bd3..78acdd74 100644
--- a/andor3App/Db/andor3.template
+++ b/andor3App/Db/andor3.template
@@ -473,16 +473,6 @@ record(mbbi, "$(P)$(R)DDGOutputSelect_RBV")
     field(DTYP, "asynInt32")
     field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_OUTPUT_SELECT")
     field(SCAN, "I/O Intr")
-    field(FLNK, "$(P)$(R)DDGOutputSelectFanout")
-}
-
-record(fanout, "$(P)$(R)DDGOutputSelectFanout")
-{
-    field(LNK1, "$(P)$(R)DDGOutputDelay")
-    field(LNK2, "$(P)$(R)DDGOutputWidth")
-    field(LNK3, "$(P)$(R)DDGOutputPolarity")
-    field(LNK4, "$(P)$(R)DDGOutputEnable")
-    field(LNK5, "$(P)$(R)DDGOutputStepEnable")
 }
 
 record(bo, "$(P)$(R)DDGOutputStepEnable")
diff --git a/andor3App/src/andor3.cpp b/andor3App/src/andor3.cpp
index e5cba82e..203c84b3 100644
--- a/andor3App/src/andor3.cpp
+++ b/andor3App/src/andor3.cpp
@@ -1303,6 +1303,14 @@ asynStatus andor3::writeInt32(asynUser *pasynUser, epicsInt32 value)
         featureInfo *info = &featureInfo_[index];
         if (info->isImplemented) {
             status = setFeature(Andor3DDGOutputSelect);
+            if (status == AT_SUCCESS)
+            {
+                status  = getFeature(Andor3DDGOutputEnable);
+                status |= getFeature(Andor3DDGOutputDelay);
+                status |= getFeature(Andor3DDGOutputPolarity);
+                status |= getFeature(Andor3DDGOutputWidth);
+                status |= getFeature(Andor3DDGOutputStepEnable);
+            }
         }
     }
     else if(index == Andor3DDGOutputStepEnable) {

From 5a646a87238699f3cf9d98ca6b895c7952919a41 Mon Sep 17 00:00:00 2001
From: IrieR <175622981+irierr@users.noreply.github.com>
Date: Tue, 10 Feb 2026 10:56:17 +0000
Subject: [PATCH 09/14] Add support for AOILayout feature

---
 andor3App/Db/andor3.template | 14 ++++++++++++++
 andor3App/src/andor3.cpp     | 24 ++++++++++++++++++------
 2 files changed, 32 insertions(+), 6 deletions(-)

diff --git a/andor3App/Db/andor3.template b/andor3App/Db/andor3.template
index 78acdd74..46a577cd 100644
--- a/andor3App/Db/andor3.template
+++ b/andor3App/Db/andor3.template
@@ -240,6 +240,20 @@ record(mbbi, "$(P)$(R)A3Binning_RBV")
     field(SCAN, "I/O Intr")
 }
 
+record(mbbo, "$(P)$(R)A3AOILayout")
+{
+    field(PINI, "YES")
+    field(DTYP, "asynInt32")
+    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_AOI_LAYOUT")
+}
+
+record(mbbi, "$(P)$(R)A3AOILayout_RBV")
+{
+    field(DTYP, "asynInt32")
+    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_AOI_LAYOUT")
+    field(SCAN, "I/O Intr")
+}
+
 record(mbbo, "$(P)$(R)A3ShutterMode")
 {
     field(PINI, "YES")
diff --git a/andor3App/src/andor3.cpp b/andor3App/src/andor3.cpp
index 203c84b3..d8239e2f 100644
--- a/andor3App/src/andor3.cpp
+++ b/andor3App/src/andor3.cpp
@@ -99,6 +99,7 @@ class andor3 : public ADDriver {
     int Andor3PixelEncoding;
     int Andor3FullAOIControl;
     int Andor3Binning;
+    int Andor3AOILayout;
     int Andor3ShutterMode;
     int Andor3SoftwareTrigger;
     int Andor3SensorCooling;
@@ -157,6 +158,7 @@ class andor3 : public ADDriver {
 #define Andor3PixelEncodingString       "A3_PIXEL_ENCODING"        /* asynInt32    rw */
 #define Andor3FullAOIControlString      "A3_FULL_AOI_CONTROL"      /* asynInt32    ro */
 #define Andor3BinningString             "A3_BINNING"               /* asynInt32    rw */
+#define Andor3AOILayoutString           "A3_AOI_LAYOUT"            /* asynInt32    rw */
 #define Andor3ShutterModeString         "A3_SHUTTER_MODE"          /* asynInt32    rw */
 #define Andor3SoftwareTriggerString     "A3_SOFTWARE_TRIGGER"      /* asynInt32    wo */
 #define Andor3SensorCoolingString       "A3_SENSOR_COOLING"        /* asynInt32    rw */
@@ -646,6 +648,7 @@ void andor3::report(FILE *fp, int details)
     reportFeature(ADMinX, fp, details);
     reportFeature(ADMinY, fp, details);
     reportFeature(Andor3Binning, fp, details);
+    reportFeature(Andor3AOILayout, fp, details);
     reportFeature(Andor3ShutterMode, fp, details);
     reportFeature(Andor3PixelEncoding, fp, details);
     reportFeature(Andor3ReadoutRate, fp, details);
@@ -816,6 +819,7 @@ int andor3::setAOI()
     int minY, sizeY, binY;
     int binning;
     int binValues[] = {1, 2, 3, 4, 8};
+    int aoiLayout;
     static const char *functionName = "setAOI";
 
     asynPrint(pasynUserSelf, ASYN_TRACEIO_DRIVER,
@@ -827,6 +831,7 @@ int andor3::setAOI()
     status |= getIntegerParam(Andor3Binning, &binning);
     status |= getIntegerParam(ADMinX, &minX);
     status |= getIntegerParam(ADMinY, &minY);
+    status |= getIntegerParam(Andor3AOILayout, &aoiLayout);
     if (status) {
         asynPrint(pasynUserSelf, ASYN_TRACE_ERROR,
             "%s:%s: error getting values, error=%d\n",
@@ -845,6 +850,7 @@ int andor3::setAOI()
     status |= getIntegerParam(ADMaxSizeY, &maxSizeY);
     width  = (maxSizeX / binX) * binX;
     height = (maxSizeY / binY) * binY;
+    status |= AT_SetEnumIndex(handle_, L"AOILayout", aoiLayout);
     status |= AT_SetEnumIndex(handle_, L"AOIBinning", 0);
     status |= AT_SetInt(handle_, L"AOILeft",   1);
     status |= AT_SetInt(handle_, L"AOITop",    1);
@@ -869,6 +875,7 @@ int andor3::getAOI()
     AT_64 minY, sizeY, binY;
     int binning;
     int binValues[] = {1, 2, 3, 4, 8};
+    int aoiLayout;
     static const char *functionName = "getAOI";
 
     asynPrint(pasynUserSelf, ASYN_TRACEIO_DRIVER,
@@ -880,9 +887,10 @@ int andor3::getAOI()
     status |= AT_GetInt(handle_, L"AOIHeight", &sizeY);
     status |= AT_GetInt(handle_, L"AOITop",    &minY);
     status |= AT_GetEnumIndex(handle_, L"AOIBinning", &binning);
+    status |= AT_GetEnumIndex(handle_, L"AOILayout", &aoiLayout);
     asynPrint(pasynUserSelf, ASYN_TRACEIO_DRIVER,
-        "%s:%s: minX=%lld, sizeX=%lld, minY=%lld, sizeY=%lld, binning=%d\n",
-        driverName, functionName, minX, sizeX, minY, sizeY, binning);
+        "%s:%s: minX=%lld, sizeX=%lld, minY=%lld, sizeY=%lld, binning=%d, layout=%d\n",
+        driverName, functionName, minX, sizeX, minY, sizeY, binning, aoiLayout);
     if (status) {
         asynPrint(pasynUserSelf, ASYN_TRACE_ERROR,
             "%s:%s: error getting values, error=%d\n",
@@ -898,6 +906,7 @@ int andor3::getAOI()
     status |= setIntegerParam(ADSizeY, (int)(sizeY*binY));
     status |= setIntegerParam(ADMinY,  (int)minY);
     status |= setIntegerParam(Andor3Binning, binning);
+    status |= setIntegerParam(Andor3AOILayout, aoiLayout);
 
     /* set NDArray parameters */
     status |= setIntegerParam(NDArraySizeX, (int)sizeX);
@@ -1211,10 +1220,11 @@ asynStatus andor3::writeInt32(asynUser *pasynUser, epicsInt32 value)
     }
     else if 
        ((index == Andor3Binning) ||
-        (index == ADMinX)  ||
-        (index == ADSizeX) ||
-        (index == ADMinY)  ||
-        (index == ADSizeY)) {
+       (index == ADMinX)  ||
+       (index == ADSizeX) ||
+       (index == ADMinY)  ||
+       (index == ADSizeY) ||
+       (index == Andor3AOILayout)) {
         status = setAOI();
     }
     else if(index == ADReadStatus) {
@@ -1457,6 +1467,7 @@ andor3::andor3(const char *portName, const char *cameraSerial, int maxBuffers,
     createParam(Andor3PixelEncodingString,      asynParamInt32,   &Andor3PixelEncoding);
     createParam(Andor3FullAOIControlString,     asynParamInt32,   &Andor3FullAOIControl);
     createParam(Andor3BinningString,            asynParamInt32,   &Andor3Binning);
+    createParam(Andor3AOILayoutString,          asynParamInt32,   &Andor3AOILayout);
     createParam(Andor3ShutterModeString,        asynParamInt32,   &Andor3ShutterMode);
     createParam(Andor3SoftwareTriggerString,    asynParamInt32,   &Andor3SoftwareTrigger);
     createParam(Andor3SensorCoolingString,      asynParamInt32,   &Andor3SensorCooling);
@@ -1538,6 +1549,7 @@ andor3::andor3(const char *portName, const char *cameraSerial, int maxBuffers,
     status |= registerFeature(L"AOITop",                   ATint,    ADMinY);
     status |= registerFeature(L"AOIBinning",               ATenum,   Andor3Binning);
     status |= registerFeature(L"ImageSizeBytes",           ATint ,   NDArraySize);
+    status |= registerFeature(L"AOILayout",                ATenum,   Andor3AOILayout);
 
     status |= registerFeature(L"SensorCooling",            ATbool,   Andor3SensorCooling);
     status |= registerFeature(L"TargetSensorTemperature",  ATfloat,  ADTemperature);

From 1bae445f2e70469f0f7fd8b50cd38e222bbb4ec4 Mon Sep 17 00:00:00 2001
From: IrieR <175622981+irierr@users.noreply.github.com>
Date: Thu, 12 Feb 2026 11:27:20 +0000
Subject: [PATCH 10/14] add ddg step features

---
 andor3App/Db/andor3.template | 114 +++++++++++++++++++++++++++++++++++
 andor3App/src/andor3.cpp     |  81 ++++++++++++++++++++++++-
 2 files changed, 193 insertions(+), 2 deletions(-)

diff --git a/andor3App/Db/andor3.template b/andor3App/Db/andor3.template
index 46a577cd..66925e2b 100644
--- a/andor3App/Db/andor3.template
+++ b/andor3App/Db/andor3.template
@@ -525,3 +525,117 @@ record(ai, "$(P)$(R)DDGOutputWidth_RBV")
     field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_OUTPUT_WIDTH")
     field(SCAN, "I/O Intr")
 }
+
+record(bo, "$(P)$(R)DDGStepEnabled")
+{
+    field(PINI, "YES")
+    field(DTYP, "asynInt32")
+    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_STEP_ENABLE")
+    field(ZNAM, "Disable")
+    field(ONAM, "Enable")
+}
+
+record(bi, "$(P)$(R)DDGStepEnabled_RBV")
+{
+    field(DTYP, "asynInt32")
+    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_STEP_ENABLE")
+    field(SCAN, "I/O Intr")
+    field(ZNAM, "Disable")
+    field(ONAM, "Enable")
+}
+
+record(mbbo, "$(P)$(R)DDGStepDelayMode")
+{
+    field(PINI, "YES")
+    field(DTYP, "asynInt32")
+    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_STEP_DELAY_MODE")
+}
+
+record(mbbi, "$(P)$(R)DDGStepDelayMode_RBV")
+{
+    field(DTYP, "asynInt32")
+    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_STEP_DELAY_MODE")
+    field(SCAN, "I/O Intr")
+}
+
+record(ao, "$(P)$(R)DDGStepDelayCoefficientA")
+{
+    field(PINI, "YES")
+    field(VAL,  "0")
+    field(DTYP, "asynFloat64")
+    field(PREC, "0")
+    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_STEP_DELAY_COEFF_A")
+}
+
+record(ai, "$(P)$(R)DDGStepDelayCoefficientA_RBV")
+{
+    field(DTYP, "asynFloat64")
+    field(PREC, "0")
+    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_STEP_DELAY_COEFF_A")
+    field(SCAN, "I/O Intr")
+}
+
+record(ao, "$(P)$(R)DDGStepDelayCoefficientB")
+{
+    field(PINI, "YES")
+    field(VAL,  "0")
+    field(DTYP, "asynFloat64")
+    field(PREC, "0")
+    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_STEP_DELAY_COEFF_B")
+}
+
+record(ai, "$(P)$(R)DDGStepDelayCoefficientB_RBV")
+{
+    field(DTYP, "asynFloat64")
+    field(PREC, "0")
+    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_STEP_DELAY_COEFF_B")
+    field(SCAN, "I/O Intr")
+}
+
+record(mbbo, "$(P)$(R)DDGStepWidthMode")
+{
+    field(PINI, "YES")
+    field(DTYP, "asynInt32")
+    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_STEP_WIDTH_MODE")
+}
+
+record(mbbi, "$(P)$(R)DDGStepWidthMode_RBV")
+{
+    field(DTYP, "asynInt32")
+    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_STEP_WIDTH_MODE")
+    field(SCAN, "I/O Intr")
+}
+
+record(ao, "$(P)$(R)DDGStepWidthCoefficientA")
+{
+    field(PINI, "YES")
+    field(VAL,  "0")
+    field(DTYP, "asynFloat64")
+    field(PREC, "0")
+    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_STEP_WIDTH_COEFF_A")
+}
+
+record(ai, "$(P)$(R)DDGStepWidthCoefficientA_RBV")
+{
+    field(DTYP, "asynFloat64")
+    field(PREC, "0")
+    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_STEP_WIDTH_COEFF_A")
+    field(SCAN, "I/O Intr")
+}
+
+record(ao, "$(P)$(R)DDGStepWidthCoefficientB")
+{
+    field(PINI, "YES")
+    field(VAL,  "0")
+    field(DTYP, "asynFloat64")
+    field(PREC, "0")
+    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_STEP_WIDTH_COEFF_B")
+}
+
+record(ai, "$(P)$(R)DDGStepWidthCoefficientB_RBV")
+{
+    field(DTYP, "asynFloat64")
+    field(PREC, "0")
+    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_DDG_STEP_WIDTH_COEFF_B")
+    field(SCAN, "I/O Intr")
+}
diff --git a/andor3App/src/andor3.cpp b/andor3App/src/andor3.cpp
index d8239e2f..418ed3b9 100644
--- a/andor3App/src/andor3.cpp
+++ b/andor3App/src/andor3.cpp
@@ -126,7 +126,14 @@ class andor3 : public ADDriver {
     int Andor3DDGOutputSelect;
     int Andor3DDGOutputStepEnable;
     int Andor3DDGOutputWidth;
-    #define LAST_ANDOR3_PARAM Andor3DDGOutputWidth
+    int Andor3DDGStepEnabled;
+    int Andor3DDGStepDelayMode;
+    int Andor3DDGStepDelayCoefficientA;
+    int Andor3DDGStepDelayCoefficientB;
+    int Andor3DDGStepWidthMode;
+    int Andor3DDGStepWidthCoefficientA;
+    int Andor3DDGStepWidthCoefficientB;
+    #define LAST_ANDOR3_PARAM Andor3DDGStepWidthCoefficientB
 private:
     int registerFeature(const AT_WC *feature, Andor3FeatureType type,
                         int paramIndex);
@@ -185,6 +192,13 @@ class andor3 : public ADDriver {
 #define Andor3DDGOutputSelectString     "A3_DDG_OUTPUT_SELECT"     /* asynInt32    rw */
 #define Andor3DDGOutputStepEnableString "A3_DDG_OUTPUT_STEP_ENABLE"/* asynInt32    rw */
 #define Andor3DDGOutputWidthString      "A3_DDG_OUTPUT_WIDTH"      /* asynInt32    rw */
+#define Andor3DDGStepEnabledString      "A3_DDG_STEP_ENABLE"       /* asynInt32    rw */
+#define Andor3DDGStepDelayModeString    "A3_DDG_STEP_DELAY_MODE"   /* asynInt32    rw */
+#define Andor3DDGStepDelayCoeffAString  "A3_DDG_STEP_DELAY_COEFF_A"/* asynFloat64  rw */
+#define Andor3DDGStepDelayCoeffBString  "A3_DDG_STEP_DELAY_COEFF_B"/* asynFloat64  rw */
+#define Andor3DDGStepWidthModeString    "A3_DDG_STEP_WIDTH_MODE"   /* asynInt32    rw */
+#define Andor3DDGStepWidthCoeffAString  "A3_DDG_STEP_WIDTH_COEFF_A"/* asynFloat64  rw */
+#define Andor3DDGStepWidthCoeffBString  "A3_DDG_STEP_WIDTH_COEFF_B"/* asynFloat64  rw */
 
 static void c_shutdown(void *arg)
 {
@@ -681,6 +695,13 @@ void andor3::report(FILE *fp, int details)
     reportFeature(Andor3DDGOutputSelect, fp, details);
     reportFeature(Andor3DDGOutputStepEnable, fp, details);
     reportFeature(Andor3DDGOutputWidth, fp, details);
+    reportFeature(Andor3DDGStepEnabled, fp, details);
+    reportFeature(Andor3DDGStepDelayMode, fp, details);
+    reportFeature(Andor3DDGStepDelayCoefficientA, fp, details);
+    reportFeature(Andor3DDGStepDelayCoefficientB, fp, details);
+    reportFeature(Andor3DDGStepWidthMode, fp, details);
+    reportFeature(Andor3DDGStepWidthCoefficientA, fp, details);
+    reportFeature(Andor3DDGStepWidthCoefficientB, fp, details);
     
     ADDriver::report(fp, details);
 }    
@@ -1335,6 +1356,24 @@ asynStatus andor3::writeInt32(asynUser *pasynUser, epicsInt32 value)
             status = setFeature(Andor3DDGOutputWidth);
         }
     }
+    else if(index == Andor3DDGStepEnabled) {
+        featureInfo *info = &featureInfo_[index];
+        if (info->isImplemented) {
+            status = setFeature(Andor3DDGStepEnabled);
+        }
+    }
+    else if(index == Andor3DDGStepDelayMode) {
+        featureInfo *info = &featureInfo_[index];
+        if (info->isImplemented) {
+            status = setFeature(Andor3DDGStepDelayMode);
+        }
+    }
+    else if(index == Andor3DDGStepWidthMode) {
+        featureInfo *info = &featureInfo_[index];
+        if (info->isImplemented) {
+            status = setFeature(Andor3DDGStepWidthMode);
+        }
+    }
     else {
         if(index < FIRST_ANDOR3_PARAM) {
             status = ADDriver::writeInt32(pasynUser, value);
@@ -1390,6 +1429,30 @@ asynStatus andor3::writeFloat64(asynUser *pasynUser, epicsFloat64 value)
     else if(index == Andor3FrameRate) {
         status = setFeature(Andor3FrameRate);
     }
+    else if(index == Andor3DDGStepDelayCoefficientA) {
+        featureInfo *info = &featureInfo_[index];
+        if (info->isImplemented) {
+            status = setFeature(Andor3DDGStepDelayCoefficientA);
+        }
+    }
+    else if(index == Andor3DDGStepDelayCoefficientB) {
+        featureInfo *info = &featureInfo_[index];
+        if (info->isImplemented) {
+            status = setFeature(Andor3DDGStepDelayCoefficientB);
+        }
+    }
+    else if(index == Andor3DDGStepWidthCoefficientA) {
+        featureInfo *info = &featureInfo_[index];
+        if (info->isImplemented) {
+            status = setFeature(Andor3DDGStepWidthCoefficientA);
+        }
+    }
+    else if(index == Andor3DDGStepWidthCoefficientB) {
+        featureInfo *info = &featureInfo_[index];
+        if (info->isImplemented) {
+            status = setFeature(Andor3DDGStepWidthCoefficientB);
+        }
+    }
     else {    
         if(index < FIRST_ANDOR3_PARAM) {
             status = ADDriver::writeFloat64(pasynUser, value);
@@ -1494,7 +1557,14 @@ andor3::andor3(const char *portName, const char *cameraSerial, int maxBuffers,
     createParam(Andor3DDGOutputSelectString,    asynParamInt32,   &Andor3DDGOutputSelect);
     createParam(Andor3DDGOutputStepEnableString,asynParamInt32,   &Andor3DDGOutputStepEnable);
     createParam(Andor3DDGOutputWidthString,     asynParamInt32,   &Andor3DDGOutputWidth);
-
+    createParam(Andor3DDGStepEnabledString,     asynParamInt32,   &Andor3DDGStepEnabled);
+    createParam(Andor3DDGStepDelayModeString,   asynParamInt32,   &Andor3DDGStepDelayMode);
+    createParam(Andor3DDGStepDelayCoeffAString, asynParamFloat64, &Andor3DDGStepDelayCoefficientA);
+    createParam(Andor3DDGStepDelayCoeffBString, asynParamFloat64, &Andor3DDGStepDelayCoefficientB);
+    createParam(Andor3DDGStepWidthModeString,   asynParamInt32,   &Andor3DDGStepWidthMode);
+    createParam(Andor3DDGStepWidthCoeffAString, asynParamFloat64, &Andor3DDGStepWidthCoefficientA);
+    createParam(Andor3DDGStepWidthCoeffBString, asynParamFloat64, &Andor3DDGStepWidthCoefficientB);
+    
     featureInfo_ = (featureInfo *)calloc(LAST_ANDOR3_PARAM+1, sizeof(featureInfo));
         
     /* set read-only parameters */
@@ -1587,6 +1657,13 @@ andor3::andor3(const char *portName, const char *cameraSerial, int maxBuffers,
     status |= registerFeature(L"DDGOutputSelector",        ATenum,   Andor3DDGOutputSelect);
     status |= registerFeature(L"DDGOutputStepEnable",      ATbool,   Andor3DDGOutputStepEnable);
     status |= registerFeature(L"DDGOutputWidth",           ATint,    Andor3DDGOutputWidth);
+    status |= registerFeature(L"DDGStepEnabled",           ATbool,   Andor3DDGStepEnabled);
+    status |= registerFeature(L"DDGStepDelayMode",         ATenum,   Andor3DDGStepDelayMode);
+    status |= registerFeature(L"DDGStepDelayCoefficientA", ATfloat,  Andor3DDGStepDelayCoefficientA);
+    status |= registerFeature(L"DDGStepDelayCoefficientB", ATfloat,  Andor3DDGStepDelayCoefficientB);
+    status |= registerFeature(L"DDGStepWidthMode",         ATenum,   Andor3DDGStepWidthMode);
+    status |= registerFeature(L"DDGStepWidthCoefficientA", ATfloat,  Andor3DDGStepWidthCoefficientA);
+    status |= registerFeature(L"DDGStepWidthCoefficientB", ATfloat,  Andor3DDGStepWidthCoefficientB);
 
     if(status != AT_SUCCESS) {
         asynPrint(pasynUserSelf, ASYN_TRACE_ERROR,

From 04f0164b4a28799270a2e1232c67345f58fb9a1d Mon Sep 17 00:00:00 2001
From: IrieR <175622981+irierr@users.noreply.github.com>
Date: Fri, 27 Feb 2026 18:51:17 +0000
Subject: [PATCH 11/14] remove AOILayout exposure as I don't have a way to test
 it works

---
 andor3App/Db/andor3.template | 14 --------------
 andor3App/src/andor3.cpp     | 18 +++---------------
 2 files changed, 3 insertions(+), 29 deletions(-)

diff --git a/andor3App/Db/andor3.template b/andor3App/Db/andor3.template
index 66925e2b..1a14e790 100644
--- a/andor3App/Db/andor3.template
+++ b/andor3App/Db/andor3.template
@@ -240,20 +240,6 @@ record(mbbi, "$(P)$(R)A3Binning_RBV")
     field(SCAN, "I/O Intr")
 }
 
-record(mbbo, "$(P)$(R)A3AOILayout")
-{
-    field(PINI, "YES")
-    field(DTYP, "asynInt32")
-    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_AOI_LAYOUT")
-}
-
-record(mbbi, "$(P)$(R)A3AOILayout_RBV")
-{
-    field(DTYP, "asynInt32")
-    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_AOI_LAYOUT")
-    field(SCAN, "I/O Intr")
-}
-
 record(mbbo, "$(P)$(R)A3ShutterMode")
 {
     field(PINI, "YES")
diff --git a/andor3App/src/andor3.cpp b/andor3App/src/andor3.cpp
index 418ed3b9..6dbf6f13 100644
--- a/andor3App/src/andor3.cpp
+++ b/andor3App/src/andor3.cpp
@@ -99,7 +99,6 @@ class andor3 : public ADDriver {
     int Andor3PixelEncoding;
     int Andor3FullAOIControl;
     int Andor3Binning;
-    int Andor3AOILayout;
     int Andor3ShutterMode;
     int Andor3SoftwareTrigger;
     int Andor3SensorCooling;
@@ -165,7 +164,6 @@ class andor3 : public ADDriver {
 #define Andor3PixelEncodingString       "A3_PIXEL_ENCODING"        /* asynInt32    rw */
 #define Andor3FullAOIControlString      "A3_FULL_AOI_CONTROL"      /* asynInt32    ro */
 #define Andor3BinningString             "A3_BINNING"               /* asynInt32    rw */
-#define Andor3AOILayoutString           "A3_AOI_LAYOUT"            /* asynInt32    rw */
 #define Andor3ShutterModeString         "A3_SHUTTER_MODE"          /* asynInt32    rw */
 #define Andor3SoftwareTriggerString     "A3_SOFTWARE_TRIGGER"      /* asynInt32    wo */
 #define Andor3SensorCoolingString       "A3_SENSOR_COOLING"        /* asynInt32    rw */
@@ -662,7 +660,6 @@ void andor3::report(FILE *fp, int details)
     reportFeature(ADMinX, fp, details);
     reportFeature(ADMinY, fp, details);
     reportFeature(Andor3Binning, fp, details);
-    reportFeature(Andor3AOILayout, fp, details);
     reportFeature(Andor3ShutterMode, fp, details);
     reportFeature(Andor3PixelEncoding, fp, details);
     reportFeature(Andor3ReadoutRate, fp, details);
@@ -840,7 +837,6 @@ int andor3::setAOI()
     int minY, sizeY, binY;
     int binning;
     int binValues[] = {1, 2, 3, 4, 8};
-    int aoiLayout;
     static const char *functionName = "setAOI";
 
     asynPrint(pasynUserSelf, ASYN_TRACEIO_DRIVER,
@@ -852,7 +848,6 @@ int andor3::setAOI()
     status |= getIntegerParam(Andor3Binning, &binning);
     status |= getIntegerParam(ADMinX, &minX);
     status |= getIntegerParam(ADMinY, &minY);
-    status |= getIntegerParam(Andor3AOILayout, &aoiLayout);
     if (status) {
         asynPrint(pasynUserSelf, ASYN_TRACE_ERROR,
             "%s:%s: error getting values, error=%d\n",
@@ -871,7 +866,6 @@ int andor3::setAOI()
     status |= getIntegerParam(ADMaxSizeY, &maxSizeY);
     width  = (maxSizeX / binX) * binX;
     height = (maxSizeY / binY) * binY;
-    status |= AT_SetEnumIndex(handle_, L"AOILayout", aoiLayout);
     status |= AT_SetEnumIndex(handle_, L"AOIBinning", 0);
     status |= AT_SetInt(handle_, L"AOILeft",   1);
     status |= AT_SetInt(handle_, L"AOITop",    1);
@@ -896,7 +890,6 @@ int andor3::getAOI()
     AT_64 minY, sizeY, binY;
     int binning;
     int binValues[] = {1, 2, 3, 4, 8};
-    int aoiLayout;
     static const char *functionName = "getAOI";
 
     asynPrint(pasynUserSelf, ASYN_TRACEIO_DRIVER,
@@ -908,10 +901,9 @@ int andor3::getAOI()
     status |= AT_GetInt(handle_, L"AOIHeight", &sizeY);
     status |= AT_GetInt(handle_, L"AOITop",    &minY);
     status |= AT_GetEnumIndex(handle_, L"AOIBinning", &binning);
-    status |= AT_GetEnumIndex(handle_, L"AOILayout", &aoiLayout);
     asynPrint(pasynUserSelf, ASYN_TRACEIO_DRIVER,
-        "%s:%s: minX=%lld, sizeX=%lld, minY=%lld, sizeY=%lld, binning=%d, layout=%d\n",
-        driverName, functionName, minX, sizeX, minY, sizeY, binning, aoiLayout);
+        "%s:%s: minX=%lld, sizeX=%lld, minY=%lld, sizeY=%lld, binning=%d\n",
+        driverName, functionName, minX, sizeX, minY, sizeY, binning);
     if (status) {
         asynPrint(pasynUserSelf, ASYN_TRACE_ERROR,
             "%s:%s: error getting values, error=%d\n",
@@ -927,7 +919,6 @@ int andor3::getAOI()
     status |= setIntegerParam(ADSizeY, (int)(sizeY*binY));
     status |= setIntegerParam(ADMinY,  (int)minY);
     status |= setIntegerParam(Andor3Binning, binning);
-    status |= setIntegerParam(Andor3AOILayout, aoiLayout);
 
     /* set NDArray parameters */
     status |= setIntegerParam(NDArraySizeX, (int)sizeX);
@@ -1244,8 +1235,7 @@ asynStatus andor3::writeInt32(asynUser *pasynUser, epicsInt32 value)
        (index == ADMinX)  ||
        (index == ADSizeX) ||
        (index == ADMinY)  ||
-       (index == ADSizeY) ||
-       (index == Andor3AOILayout)) {
+       (index == ADSizeY)) {
         status = setAOI();
     }
     else if(index == ADReadStatus) {
@@ -1530,7 +1520,6 @@ andor3::andor3(const char *portName, const char *cameraSerial, int maxBuffers,
     createParam(Andor3PixelEncodingString,      asynParamInt32,   &Andor3PixelEncoding);
     createParam(Andor3FullAOIControlString,     asynParamInt32,   &Andor3FullAOIControl);
     createParam(Andor3BinningString,            asynParamInt32,   &Andor3Binning);
-    createParam(Andor3AOILayoutString,          asynParamInt32,   &Andor3AOILayout);
     createParam(Andor3ShutterModeString,        asynParamInt32,   &Andor3ShutterMode);
     createParam(Andor3SoftwareTriggerString,    asynParamInt32,   &Andor3SoftwareTrigger);
     createParam(Andor3SensorCoolingString,      asynParamInt32,   &Andor3SensorCooling);
@@ -1619,7 +1608,6 @@ andor3::andor3(const char *portName, const char *cameraSerial, int maxBuffers,
     status |= registerFeature(L"AOITop",                   ATint,    ADMinY);
     status |= registerFeature(L"AOIBinning",               ATenum,   Andor3Binning);
     status |= registerFeature(L"ImageSizeBytes",           ATint ,   NDArraySize);
-    status |= registerFeature(L"AOILayout",                ATenum,   Andor3AOILayout);
 
     status |= registerFeature(L"SensorCooling",            ATbool,   Andor3SensorCooling);
     status |= registerFeature(L"TargetSensorTemperature",  ATfloat,  ADTemperature);

From ddd17b42b64bae6cf70f3b3a2c46a99e5f838f87 Mon Sep 17 00:00:00 2001
From: IrieR <175622981+irierr@users.noreply.github.com>
Date: Fri, 27 Feb 2026 18:56:05 +0000
Subject: [PATCH 12/14] add ddg step records to autosave reqs

---
 andor3App/Db/andor3_settings.req | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/andor3App/Db/andor3_settings.req b/andor3App/Db/andor3_settings.req
index ccbbea93..290b5a95 100644
--- a/andor3App/Db/andor3_settings.req
+++ b/andor3App/Db/andor3_settings.req
@@ -19,4 +19,11 @@ $(P)$(R)DDGOutputPolarity
 $(P)$(R)DDGOutputSelect
 $(P)$(R)DDGOutputStepEnable
 $(P)$(R)DDGOutputWidth
+$(P)$(R)DDGStepEnabled
+$(P)$(R)DDGStepDelayMode
+$(P)$(R)DDGStepDelayCoefficientA
+$(P)$(R)DDGStepDelayCoefficientB
+$(P)$(R)DDGStepWidthMode
+$(P)$(R)DDGStepWidthCoefficientA
+$(P)$(R)DDGStepWidthCoefficientB
 file "ADBase_settings.req", P=$(P), R=$(R)

From 0849ee24fca214a8ddacf4350411b35e25f1051c Mon Sep 17 00:00:00 2001
From: IrieR <175622981+irierr@users.noreply.github.com>
Date: Tue, 10 Mar 2026 11:52:52 +0000
Subject: [PATCH 13/14] Add new features to docs

---
 docs/ADAndor3/ADAndorDoc.rst | 38 ++++++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/docs/ADAndor3/ADAndorDoc.rst b/docs/ADAndor3/ADAndorDoc.rst
index 2767ae5a..f44addba 100644
--- a/docs/ADAndor3/ADAndorDoc.rst
+++ b/docs/ADAndor3/ADAndorDoc.rst
@@ -424,6 +424,44 @@ Andor specific parameters
     - A3_MCP_INTELLIGATE
     - MCPIntelligate, MCPIntelligate_RBV
     - bo, bi
+  * - **Digital Delay Generator (DDG) Control**
+  * - Andor3DDGOutputDelay
+    - asynInt32
+    - R/W
+    - Configures the delay (in picoseconds) for the currently selected DDG output.
+    - A3_DDG_OUTPUT_DELAY
+    - DDGOutputDelay, DDGOutputDelay_RBV
+    - ao, ai
+  * - Andor3DDGOutputEnable
+    - asynInt32
+    - R/W
+    - Enable or disable the currently selected DDG output. Has no effect if "Gater" output is selected.
+    - A3_DDG_OUTPUT_ENABLE
+    - DDGOutputEnable, DDGOutputEnable_RBV
+    - bo, bi
+  * - Andor3DDGOutputPolarity
+    - asynInt32
+    - R/W
+    - Configures the polarity for the currently selected DDG output.
+      Choices for iStar are 0 (Negative) and 1 (Positive).
+    - A3_DDG_OUTPUT_POLARITY
+    - DDGOutputPolarity, DDGOutputPolarity_RBV
+    - mbbo, mbbi
+  * - Andor3DDGOutputSelect
+    - asynInt32
+    - R/W
+    - Selects the DDG output that you subsequently wish to configure using the DDG output features.
+      Choices for iStar are 0 (Gater), 1 (Output A), 2 (Output B), and 3 (Output C).
+    - A3_DDG_OUTPUT_SELECT
+    - DDGOutputSelect, DDGOutputSelect_RBV
+    - mbbo, mbbi
+  * - Andor3DDGOutputWidth
+    - asynInt32
+    - R/W
+    - Configures the width (in picoseconds) for the currently selected DDG output.
+    - A3_DDG_OUTPUT_WIDTH
+    - DDGOutputWidth, DDGOutputWidth_RBV
+    - ao, ai
 
 The Andor driver implements the following parameters in addition to
 those in asynNDArrayDriver.h and ADDriver.h.

From 1f87af59294dc008ef7732f607ae6aa6c685169e Mon Sep 17 00:00:00 2001
From: IrieR <175622981+irierr@users.noreply.github.com>
Date: Tue, 10 Mar 2026 11:53:17 +0000
Subject: [PATCH 14/14] add step features to docs - might remove

---
 docs/ADAndor3/ADAndorDoc.rst | 70 ++++++++++++++++++++++++++++++++++++
 1 file changed, 70 insertions(+)

diff --git a/docs/ADAndor3/ADAndorDoc.rst b/docs/ADAndor3/ADAndorDoc.rst
index f44addba..726f1c68 100644
--- a/docs/ADAndor3/ADAndorDoc.rst
+++ b/docs/ADAndor3/ADAndorDoc.rst
@@ -455,6 +455,13 @@ Andor specific parameters
     - A3_DDG_OUTPUT_SELECT
     - DDGOutputSelect, DDGOutputSelect_RBV
     - mbbo, mbbi
+  * - Andor3DDGOutputStepEnable
+    - asynInt32
+    - R/W
+    - Enable or disable DDG step mode for the currently selected DDG output.
+    - A3_DDG_OUTPUT_STEP_ENABLE
+    - DDGOutputStepEnable, DDGOutputStepEnable_RBV
+    - bo, bi
   * - Andor3DDGOutputWidth
     - asynInt32
     - R/W
@@ -462,6 +469,69 @@ Andor specific parameters
     - A3_DDG_OUTPUT_WIDTH
     - DDGOutputWidth, DDGOutputWidth_RBV
     - ao, ai
+  * - Andor3DDGStepEnabled
+    - asynInt32
+    - R/O
+    - Indicates when DDG step is enabled.
+    - A3_DDG_STEP_ENABLED
+    - DDGStepEnabled, DDGStepEnabled_RBV
+    - bo, bi
+  * - Andor3DDGStepDelayMode
+    - asynInt32
+    - R/W
+    - Configures the mode for incrementing the DDG step delay.
+      Choices for iStar are 0 (Off), 1 (Constant), 2 (Exponential), 3 (Logarithmic).
+    - A3_DDG_STEP_DELAY_MODE
+    - DDGStepDelayMode, DDGStepDelayMode_RBV
+    - mbbo, mbbi
+  * - Andor3DDGStepDelayCoefficientA
+    - asynFloat64
+    - R/W
+    - Coefficient A for calculating the DDG step delay. The step delay is calculated as follows:
+      |br| If DDGStepDelayMode=Constant then StepDelay = A |br|
+      If DDGStepDelayMode=Exponential then StepDelay = A*exp(B*Step) |br|
+      If DDGStepDelayMode=Logarithmic then StepDelay = A*log(B*Step)
+    - A3_DDG_STEP_DELAY_COEFFICIENT_A
+    - DDGStepDelayCoefficientA, DDGStepDelayCoefficientA_RBV
+    - ao, ai
+  * - Andor3DDGStepDelayCoefficientB
+    - asynFloat64
+    - R/W
+    - Coefficient B for calculating the DDG step delay. The step delay is calculated as follows:
+      |br| If DDGStepDelayMode=Constant then StepDelay = A |br|
+      If DDGStepDelayMode=Exponential then StepDelay = A*exp(B*Step) |br|
+      If DDGStepDelayMode=Logarithmic then StepDelay = A*log(B*Step)
+    - A3_DDG_STEP_DELAY_COEFFICIENT_B
+    - DDGStepDelayCoefficientB, DDGStepDelayCoefficientB_RBV
+    - ao, ai
+  * - Andor3DDGStepWidthMode
+    - asynInt32
+    - R/W
+    - Configures the mode for incrementing the DDG step width.
+      Choices for iStar are 0 (Off), 1 (Constant), 2 (Exponential), 3 (Logarithmic).
+    - A3_DDG_STEP_WIDTH_MODE
+    - DDGStepWidthMode, DDGStepWidthMode_RBV
+    - mbbo, mbbi
+  * - Andor3DDGStepWidthCoefficientA
+    - asynFloat64
+    - R/W
+    - Coefficient A for calculating the DDG step width. The step width is calculated as follows:
+      |br| If DDGStepWidthMode=Constant then StepWidth = A |br|
+      If DDGStepWidthMode=Exponential then StepWidth = A*exp(B*Step) |br|
+      If DDGStepWidthMode=Logarithmic then StepWidth = A*log(B*Step)
+    - A3_DDG_STEP_WIDTH_COEFFICIENT_A
+    - DDGStepWidthCoefficientA, DDGStepWidthCoefficientA_RBV
+    - ao, ai
+  * - Andor3DDGStepWidthCoefficientB
+    - asynFloat64
+    - R/W
+    - Coefficient B for calculating the DDG step width. The step width is calculated as follows:
+      |br| If DDGStepWidthMode=Constant then StepWidth = A |br|
+      If DDGStepWidthMode=Exponential then StepWidth = A*exp(B*Step) |br|
+      If DDGStepWidthMode=Logarithmic then StepWidth = A*log(B*Step)
+    - A3_DDG_STEP_WIDTH_COEFFICIENT_B
+    - DDGStepWidthCoefficientB, DDGStepWidthCoefficientB_RBV
+    - ao, ai
 
 The Andor driver implements the following parameters in addition to
 those in asynNDArrayDriver.h and ADDriver.h.