diff --git a/ADHamaApp/Db/hama.template b/ADHamaApp/Db/hama.template
index 7d9bad4..d5bf499 100644
--- a/ADHamaApp/Db/hama.template
+++ b/ADHamaApp/Db/hama.template
@@ -90,6 +90,30 @@ record(mbbi, "$(P)$(R)ColorMode_RBV") {
     field(SVVL, "")
 }
 
+record("*", "$(P)$(R)SizeX")
+{
+    field(DRVH, "2048")
+    field(DRVL, "4")
+}
+
+record("*", "$(P)$(R)SizeY")
+{
+    field(DRVH, "2048")
+    field(DRVL, "4")
+}
+
+record("*", "$(P)$(R)MinX")
+{
+    field(DRVH, "2044")
+    field(DRVL, "0")
+}
+
+record("*", "$(P)$(R)MinY")
+{
+    field(DRVH, "2044")
+    field(DRVL, "0")
+}
+
 record("*", "$(P)$(R)AcquirePeriod_RBV")
 {
     field(FLNK, "$(P)$(R)#EVRAcquireTime-S.PROC PP MS")
@@ -701,25 +725,6 @@ record(mbbi, "$(P)$(R)SubarrayMode-RB") {
 }
 
 
-##########################################################################
-# Feature                                                                #
-##########################################################################
-record(ao, "$(P)$(R)ExposureTime-S") {
-   field(DESC, "")
-   field(DTYP, "asynFloat64")
-   field(DRVL, "0.001004")
-   field(DRVH, "10.0")
-   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_EXPOSURE_TIME")  
-   field(VAL,  "0.009998")
-}
-
-record(ai, "$(P)$(R)ExposureTime-RB") {
-   field(DESC, "")
-   field(DTYP, "asynFloat64")
-   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_EXPOSURE_TIME")  
-   field(SCAN, "I/O Intr")
-}
-
 ##########################################################################
 # ALU                                                                    #
 ##########################################################################
diff --git a/ADHamaApp/src/hama.cpp b/ADHamaApp/src/hama.cpp
index 49cf33f..108dbe8 100644
--- a/ADHamaApp/src/hama.cpp
+++ b/ADHamaApp/src/hama.cpp
@@ -103,9 +103,6 @@ Hama::Hama(const char* portName, int cameraId, int maxBuffers, size_t maxMemory,
     createParam( hSubarrayVSizeString,          asynParamInt32,   &hSubarrayVSize);
     createParam( hSubarrayModeString,           asynParamInt32,   &hSubarrayMode);
 
-//Feature
-    createParam( hExposureTimeString,           asynParamFloat64, &hExposureTime);
-
 //ALU
     createParam( hDefectCorrectModeString,      asynParamInt32,   &hDefectCorrectMode); 
     createParam( hHotPixelCorrectLevelString,   asynParamInt32,   &hHotPixelCorrectLevel);
@@ -481,11 +478,10 @@ int Hama::readParameter(int propertyID){
       status = setIntegerParam(hSubarrayMode, dvalue);
    break;
 
-   // - feature
-   case DCAM_IDPROP_EXPOSURETIME:    //(RW123)
-      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_EXPOSURETIME, &dvalue);
-      status = setIntegerParam(hExposureTime, dvalue);
-   break;
+    case DCAM_IDPROP_EXPOSURETIME:
+        m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_EXPOSURETIME, &dvalue);
+        status = setDoubleParam(ADAcquireTime, dvalue);
+    break;
 
    // - alu
    case DCAM_IDPROP_DEFECTCORRECT_MODE:   //(RW123)
@@ -949,177 +945,6 @@ void Hama::temperatureTask(){
 
 }
 
-//============================================================================
-asynStatus Hama::readAttributes(){
-
-    int status = 0;
-
-    readParameter( DCAM_IDPROP_COLORTYPE );
-    //status |= readParameter( DCAM_IDPROP_BITSPERCHANNEL );
-    status = readParameter( DCAM_IDPROP_IMAGE_ROWBYTES );
-    status = readParameter( DCAM_IDPROP_IMAGE_FRAMEBYTES );
-    status = readParameter( DCAM_IDPROP_IMAGE_TOPOFFSETBYTES );
-    //status |= readParameter( DCAM_IDPROP_IMAGE_PIXELTYPE );
-    status = readParameter( DCAM_IDPROP_BUFFER_ROWBYTES );
-    status = readParameter( DCAM_IDPROP_BUFFER_FRAMEBYTES );
-    status = readParameter( DCAM_IDPROP_BUFFER_TOPOFFSETBYTES );
-    status = readParameter( DCAM_IDPROP_BUFFER_PIXELTYPE );
-    status = readParameter( DCAM_IDPROP_RECORDFIXEDBYTES_PERFILE );
-    status = readParameter( DCAM_IDPROP_RECORDFIXEDBYTES_PERSESSION );
-    status = readParameter( DCAM_IDPROP_RECORDFIXEDBYTES_PERFRAME );
-    status = readParameter( DCAM_IDPROP_SYSTEM_ALIVE );
-    status = readParameter( DCAM_IDPROP_CONVERSIONFACTOR_COEFF );
-    status = readParameter( DCAM_IDPROP_CONVERSIONFACTOR_OFFSET );
-    status = readParameter( DCAM_IDPROP_NUMBEROF_VIEW );
-
-return (asynStatus)status; 
-}
-
-
-//============================================================================
-asynStatus Hama::readSensor(){
- 
-   asynStatus status = asynSuccess;
-/*
-   int minH=0, minV=0, sizeH=0, sizeV=0, binning=1, bitPerChannel = 0;
-   double dminH=0, dminV=0, dsizeH=0, dsizeV=0, dbinning=1;
-   double dFrameBytes = 0, dRowBytes = 0;
-   double dvalue = 0;
-   int mode = 0;
-
-
-   getIntegerParam(ADMinX,  &minH);
-   getIntegerParam(ADMinY,  &minV);
-   getIntegerParam(ADSizeX, &sizeH);
-   getIntegerParam(ADSizeY, &sizeV);
-   getIntegerParam(hBinning, &binning);
-   getIntegerParam(hBitPerChannel, &bitPerChannel);
-   getIntegerParam(hSubarrayMode ,&mode);
-
-   if(mode == DCAMPROP_MODE__OFF){
-      status = asynError;
-      return status ;
-   }
-
-
-   dbinning = binning;
-   dminH = minH;
-   dminV = minV;
-   dsizeH = sizeH;
-   dsizeV = sizeV;
-   double modeON = DCAMPROP_MODE__ON; 
-   double modeOFF = DCAMPROP_MODE__OFF; 
-   double dsensorH = 2048;
-   double dsensorV = 2048;
-
-
-   //m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYMODE, &modeOFF);
-   //if(failed(m_err)) 
-   //   printError(m_hdcam, m_err, "dcamprop_SubarrayMode()", " VALUE:%f\n", modeOFF);
-      
-
-   m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_BINNING,   &dbinning);
-   if(failed(m_err)) 
-      printError(m_hdcam, m_err, "dcamprop_Binning()", " VALUE:%f\n", dbinning);
-   status = setIntegerParam(hBinning, dbinning);
- 
-   printf("BEFORE::::n");
-   printf("SUBARRAY Hpos  = %f \n", dminH);
-   printf("SUBARRAY Vpos  = %f \n", dminV);
-   printf("SUBARRAY Hsize = %f \n", dsizeH);
-   printf("SUBARRAY Vsize = %f \n", dsizeV);
-
-   if(dsizeH > (dsensorH - dminH)){
-      dsizeH = dsensorH - dminH;
-      m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHSIZE, &dsizeH);
-      m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHPOS,  &dminH);
-   }
-   if(dsizeV > (dsensorV - dminV)){
-      dsizeV = dsensorV - dminV;
-      m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVSIZE, &dsizeV);
-      m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVPOS,  &dminV);
-   }
-
-
-
-   m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHPOS,  &dminH);
-   if(failed(m_err)) 
-      printError(m_hdcam, m_err, "dcamprop_SubarrayHPos()", " VALUE:%f\n", dminH);
-   else 
-      status = setIntegerParam(ADMinX, dminH);
-
-   m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVPOS,  &dminV);
-   if(failed(m_err)) 
-      printError(m_hdcam, m_err, "dcamprop_SubarrayVPos()", " VALUE:%f\n", dminV);
-   else status = setIntegerParam(ADMinY, dminV);
-   
-   //dsizeH = 2048 - dminH;
-   //dsizeV = 2048 - dminV;
-   
-   m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHSIZE, &dsizeH);
-   if(failed(m_err)) 
-      printError(m_hdcam, m_err, "dcamprop_SubarrayHSize()", " VALUE:%f\n", dsizeH);
-   else status = setIntegerParam(ADSizeX, dsizeH);
-
-   m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVSIZE, &dsizeV);
-   if(failed(m_err)) 
-      printError(m_hdcam, m_err, "dcamprop_SubarrayVSize()", " VALUE:%f\n", dsizeV);
-   else status = setIntegerParam(ADSizeY, dsizeV);
-
-   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_WIDTH, &dvalue);
-   if(failed(m_err)) 
-      printError(m_hdcam, m_err, "dcamprop_ImageWidth()", " VALUE:%f\n", dvalue);
-   else status = setIntegerParam(ADBinX, dvalue);
-
-   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_HEIGHT, &dvalue);
-   if(failed(m_err)) 
-      printError(m_hdcam, m_err, "dcamprop_ImageHeight()", " VALUE:%f\n", dvalue);
-   else status = setIntegerParam(ADBinY, dvalue);
-   
-   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_ROWBYTES, &dRowBytes);
-   if(failed(m_err)) 
-      printError(m_hdcam, m_err, "dcamprop_ImageRowBytes()", " VALUE:%f\n", dRowBytes);
-   else status = setIntegerParam(hImageRowbytes, dRowBytes);
-
-   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &dFrameBytes);
-   if(failed(m_err)) 
-      printError(m_hdcam, m_err, "dcamprop_ImageFrameBytes()", " VALUE:%f\n", dFrameBytes);
-   else status = setIntegerParam(hImageFramebytes, dFrameBytes);
-
-   //m_err = dcamprop_getvalue(m_hdcam, , &dvalue);
-   
- 
-   printf("AFTER::::n");
-   printf("SUBARRAY Hpos  = %f \n", dminH);
-   printf("SUBARRAY Vpos  = %f \n", dminV);
-   printf("SUBARRAY Hsize = %f \n", dsizeH);
-   printf("SUBARRAY Vsize = %f \n", dsizeV);
-
-   printf("binning        = %f \n", dbinning);
-
-   unsigned long size = (dsizeH-dminH) * (dsizeV-dminV) / dbinning * 2;
-   printf("ImageSize       = %ld\n", size);
-   
-   status = setIntegerParam(hImageFramebytes, dFrameBytes);
-   status = setIntegerParam(hImageRowbytes, dRowBytes);
-   
-   int bytes = 2;
-   if(bitPerChannel >=12) bytes = 2;
-   else bytes = 1;
-   
-   status = setIntegerParam(NDArraySize, bytes);
-   
-
-//   m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYMODE, &modeON);
-
-
-   callParamCallbacks();
-   */
-return status;
-}
-
-
-
 //============================================================================
 asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value) {
    asynStatus  status = asynSuccess;
@@ -1150,18 +975,6 @@ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value) {
             stopAcquire();
         }
     }
-   /*
-   else if (index == ADMaxSizeX_RBV) {
-      dcamprop_setvalue(m_hdcam, DETECTOR_PIXEL_NUM_HORZ, value);
-      dcamprop_getvalue(m_hdcam, DETECTOR_PIXEL_NUM_HORZ, &value_d);
-      printf("[DEBUG]::function ADNumExposures\n"); 
-   }
-   else if (index == ADMaxSizeY_RBV) {
-      dcamprop_setvalue(m_hdcam, DETECTOR_PIXEL_NUM_VERT, value);
-      dcamprop_getvalue(m_hdcam, DETECTOR_PIXEL_NUM_VERT, &value_d);
-      printf("[DEBUG]::function ADMinX\n"); 
-   }
-   */
    else if (index == ADImageMode) {
     //  dcamprop_setvalue(m_hdcam, DCAM_IDPROP_, value);
     //  dcamprop_getvalue(m_hdcam, DCAM_IDPROP_, &value_d);
@@ -1172,131 +985,123 @@ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value) {
       //dcamprop_getvalue(m_hdcam, DCAM_IDPROP_EXPOSURETIME, &value_d);
       printf("[DEBUG]::writeInit32 ADNumExposures\n"); 
    }
-   else if (index == ADMinX) {
-      
-      int sensorH = 2048, minH = 0, sizeH = 0;
-      double dFrameBytes = 0;
-      getIntegerParam(ADMinX,   &minH);
-      getIntegerParam(ADSizeX,  &sizeH);
-      
-      if(sizeH > (sensorH - minH)){
-         sizeH = sensorH - 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);
-         printf("--- minH = %d\n", sizeH);
-         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);
-      }
-   }
-   else if (index == ADMinY) {
-      int sensorV = 2048, minV = 0, sizeV = 0;
-      double dFrameBytes = 0;
-      getIntegerParam(ADMinY,   &minV);
-      getIntegerParam(ADSizeY,  &sizeV);
+    else if (index == ADMinX) {      
+        int minH = 0, sizeH = 0;
+        double dFrameBytes = 0;
+        getIntegerParam(ADMinX,   &minH);
+        getIntegerParam(ADSizeX,  &sizeH);
 
-      if(sizeV > (sensorV - minV)){
-         sizeV = sensorV - 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);
-         printf("--- sizeV = %d\n", sizeV);
-         setIntegerParam(ADSizeY, sizeV);
-         dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &dFrameBytes);
-         status = setIntegerParam(hImageFramebytes, dFrameBytes);
-      }
-      else{
-         double dsizeV = sizeV;
-         double dminV = minV;
-         m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHSIZE, &dsizeV);
-         m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHPOS,  &dminV);
-         dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &dFrameBytes);
-         status = setIntegerParam(hImageFramebytes, dFrameBytes);
-      }
-   }
-   else if (index == ADSizeX) {
-      int sensorX = 2048, minX = 0, sizeX = 0;
-      double dFrameBytes = 0;
-      getIntegerParam(ADMinX,   &minX);
-      getIntegerParam(ADSizeX,  &sizeX);
-         
-      if(sizeX < sensorX - minX){
-         double dsizeX = 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);
-         status = setIntegerParam(ADSizeX, (int)dsizeX);   
-         printf("1-Status = %d\n", status);
-      }
-      else{
-         
-         double dsizeX = sensorX - minX;
-         m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHSIZE, &dsizeX);
-         m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &dFrameBytes);
-         status = setIntegerParam(ADSizeX, sizeX);
-         printf("2-Status = %d\n", status);
-         status = setIntegerParam(hImageFramebytes, dFrameBytes);
-         }
+        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);
+    }
+    else if (index == ADMinY) {
+        int minV = 0, sizeV = 0;
+        double dFrameBytes = 0;
+        status = getIntegerParam(ADMinY, &minV);
+        getIntegerParam(ADSizeY, &sizeV);
 
-   }
-   else if (index == ADSizeY) {
-      int sensorY = 2048, minY = 0, sizeY = 0;
-      double dFrameBytes = 0;
-      getIntegerParam(ADMinY,   &minY);
-      getIntegerParam(ADSizeY,  &sizeY);
+        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);
+        }
+        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);
+        }
+        readParameter(DCAM_IDPROP_TIMING_READOUTTIME);
+    }
 
-      if(sizeY < sensorY - minY){
-         double dsizeY = sizeY;
-         m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVSIZE, &dsizeY);
-         m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &dFrameBytes);
-         status = setIntegerParam(ADSizeX, (int)dsizeY); 
-         status = setIntegerParam(hImageFramebytes, dFrameBytes);
-      }
-      else{
-         double dsizeY = sizeY;
-         //printf("---4 sensor = %d min = %d size = %d\n", sensorY, minY, sizeY);
-         m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVSIZE, &dsizeY);
-         //if(failed(m_err)) printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%d\n", index, (int)dsizeY);
-      
-         m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &dFrameBytes);
-         //if(failed(m_err)) printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%d\n", index, (int)dFrameBytes);
-      
-         status = setIntegerParam(hImageFramebytes, dFrameBytes);
-         status = setIntegerParam(ADSizeX, (int)dsizeY);  
-      }
+    else if (index == ADSizeX) {
+        int minX = 0, sizeX = 0;
+        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;
+        }
+        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;
+        }
+        readParameter(DCAM_IDPROP_TIMING_READOUTTIME);
+    }
+
+    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);
+        }
+        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; 
+        }
+        readParameter(DCAM_IDPROP_TIMING_READOUTTIME);
+    }
    else if (index == ADReadStatus) {
     //  dcamprop_setvalue(m_hdcam, DCAM_IDPROP_, value);
     //  dcamprop_getvalue(m_hdcam, DCAM_IDPROP_, &value_d);
       printf("[DEBUG]::writeInit32 ADReadStatus\n"); 
    }
-   //-- Sensor mode and speed
-   else if (index == hSensorMode) {
-      printf("[DEBUG]::writeInit32 SensorMode %d\n", value); 
-      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);
-      }
-   }
-   else if (index == hReadoutSpeed) {
-      printf("[DEBUG]::writeInit32 ReadoutSpeed %d\n", value); 
-      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);
-      }
-   }
+
+    else if (index == hSensorMode) {
+        printf("[DEBUG]::writeInit32 SensorMode %d\n", value); 
+        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);
+    }
+   
+    else if (index == hReadoutSpeed) {
+        printf("[DEBUG]::writeInit32 ReadoutSpeed %d\n", value); 
+        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);
+        readParameter(DCAM_IDPROP_TIMING_READOUTTIME);
+    }
+
    else if (index == hReadoutDirection) {
       printf("[DEBUG]::writeInit32 ReadoutDirection %d\n", value); 
       m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_READOUT_DIRECTION, &dvalue, 0);
@@ -1378,36 +1183,6 @@ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value) {
       status = setIntegerParam(hBinning, dbinning);
       printf("[DEBUG]::writeInit32 Binning %d\n", value); 
    }
-   /*
-   else if (index == hSubarrayHPos) {
-      printf("[DEBUG]::function SubArrayHPos %d\n", value); 
-      m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHPOS, &dvalue);
-      if(failed(m_err)) {
-        printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
-      }
-   }
-   else if (index == hSubarrayHSize) {
-      printf("[DEBUG]::writeInit32 SubarrayHSize %d\n", value); 
-      m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHSIZE, &dvalue);
-      if(failed(m_err)) {
-        printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
-      }
-   }
-   else if (index == hSubarrayVPos) {
-      printf("[DEBUG]::writeInit32 SubarrayVPos %d\n", value); 
-      m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVPOS, &dvalue);
-      if(failed(m_err)) {
-        printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
-      }
-   }
-   else if (index == hSubarrayVSize) {
-      printf("[DEBUG]::writeInit32 SubarrayVSize %d\n", value); 
-      m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVSIZE, &dvalue);
-      if(failed(m_err)) {
-        printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
-      }
-   }
-   */
    else if (index == hSubarrayMode) {
       printf("[DEBUG]::writeInit32 SubarrayMode %d\n", value); 
       m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYMODE, &dvalue);
@@ -1642,7 +1417,6 @@ asynStatus Hama::writeFloat64(asynUser *pasynUser, epicsFloat64 value){
     //-- Feature 
     if(index == ADAcquireTime) {
         printf("[DEBUG]::function ADAcquireTime from camera: %f\n", value);
-        
         int trigger_mode = 0;
         double acquire_period = 0;
         status = getDoubleParam(ADAcquirePeriod, &acquire_period);
@@ -1662,7 +1436,10 @@ asynStatus Hama::writeFloat64(asynUser *pasynUser, epicsFloat64 value){
                 status = setIntegerParam(hTriggerSource, DCAMPROP_TRIGGERSOURCE__INTERNAL);
                 callParamCallbacks();
             }
-        }        
+        }
+
+        readParameter(DCAM_IDPROP_TIMING_READOUTTIME);
+        m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_EXPOSURETIME, &value);
     }
 
     else if(index == ADAcquirePeriod) {
@@ -2393,6 +2170,12 @@ int Hama::getProperties(){
 return 0;   
 }
 
+int Hama::roundToNearestMultipleOfFour(int value) {
+    int remainder = value % 4;
+    if (remainder == 0) return value;
+    else if (remainder <= 2) return value - remainder;
+    else return value + (4 - remainder);
+}
 
 
 //============================================================================
diff --git a/ADHamaApp/src/hama.h b/ADHamaApp/src/hama.h
index 88fadf6..c781e8c 100644
--- a/ADHamaApp/src/hama.h
+++ b/ADHamaApp/src/hama.h
@@ -6,6 +6,9 @@
 
 #define MAX_FEATURE_NAME_LEN 64
 
+#define MAX_H_SENSOR_SIZE 2048
+#define MAX_V_SENSOR_SIZE 2048
+
 #define hFrameRateString                "H_FRAMERATE"
 #define hHamaNameString                 "H_HAMA_NAME"                  	/* asynOctet        ro */
 #define hVendorString                   "H_VENDOR"                  /* asynOctet        ro */
@@ -48,9 +51,6 @@
 // #define hFrameBundleMode   (usb3 only not implemented) 
 // #define hFrameBundleNumber (usb3 only not implemented)
 
-// Feature
-#define hExposureTimeString			    "H_EXPOSURE_TIME"		    /* asynFloat64  rw */
-
 // ALU
 #define hDefectCorrectModeString		"H_DEFECTCORRECT_MODE"		/* asynInt32  rw */
 #define hHotPixelCorrectLevelString		"H_HOT_PIXEL_CORRECT_LEVEL"	/* asynInt32  rw */
@@ -301,14 +301,7 @@ private:
     int connectCamera();
     int disconnectCamera();
     int initCamera();    
-
-    // These function can be read more than once
-    asynStatus readAttributes();
-    asynStatus readSensor(); 
     
-   
-
-
     // helper functions for dcamapi 
     void printError(HDCAM hdcam, DCAMERR errid, const char* apiname, const char* fmt=NULL, ...);
     void printInfo(HDCAM hdcam);
@@ -316,6 +309,7 @@ private:
     
     
     int getProperties();
+    int roundToNearestMultipleOfFour(int value);
     
     asynStatus setFeature(int featureIndex, double value);
 };