diff --git a/ADHamaApp/Db/hama.template b/ADHamaApp/Db/hama.template
index 609f66b..99b983b 100644
--- a/ADHamaApp/Db/hama.template
+++ b/ADHamaApp/Db/hama.template
@@ -273,29 +273,6 @@ record(mbbi, "$(P)$(R)ReadoutDirection-RB") {
 }
 
 
-
-
-record(mbbo, "$(P)$(R)ColorType-S") {
-   field(DESC,"")
-   field(PINI, "YES")
-   field(DTYP, "asynInt32")
-   field(ZRVL, "1")
-   field(ZRST, "B/W")
-#   field(DRVL, "1")
-#   field(DRVH, "1")
-   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_COLOR_TYPE")  
-   field(VAL,  "1")
-}
-
-record(mbbi, "$(P)$(R)ColorType-RB") {
-   field(DESC,"")
-   field(ZRVL, "1")
-   field(ZRST, "B/W")
-   field(DTYP, "asynInt32")
-   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_COLOR_TYPE")
-   field(SCAN, "I/O Intr")
-}
-
 record(mbbo, "$(P)$(R)BitPerChannel-S") {
    field(DESC,"")
    field(PINI, "YES")
diff --git a/ADHamaApp/src/hama.cpp b/ADHamaApp/src/hama.cpp
index 2f92730..8fc606c 100644
--- a/ADHamaApp/src/hama.cpp
+++ b/ADHamaApp/src/hama.cpp
@@ -276,16 +276,17 @@ int Hama::initCamera(){
 
    // ALU ---------------------------------------------------
 	err |= getParameter( DCAM_IDPROP_DEFECTCORRECT_MODE);
-   //HOTPIXEL
-   //INTENSITYLUT_MODE
-   //INTENSITYLUT_PAGE
-   //EXTRAXTIONMODE
+	err |= getParameter( DCAM_IDPROP_HOTPIXELCORRECT_LEVEL);
+	err |= getParameter( DCAM_IDPROP_INTENSITYLUT_MODE);
+	err |= getParameter( DCAM_IDPROP_INTENSITYLUT_PAGE);
+	err |= getParameter( DCAM_IDPROP_EXTRACTION_MODE);
 
    // OUTPUT TRIGGER ---------------------------------------- 
 
    // MASTER PULSE ------------------------------------------ 
    // SYNCHRONOUS TIMING ------------------------------------ 
    // SYSTEM INFORMATION ------------------------------------ 
+   err |= getParameter(DCAM_IDPROP_COLORTYPE);
    err |= getParameter(DCAM_IDPROP_BITSPERCHANNEL);
    err |= getParameter(DCAM_IDPROP_IMAGE_TOPOFFSETBYTES);
    err |= getParameter(DCAM_IDPROP_BUFFER_ROWBYTES);
@@ -480,15 +481,60 @@ asynStatus Hama::getParameter(int propertyID){
       m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_DEFECTCORRECT_MODE, &dvalue);
       status = setIntegerParam(hDefectCorrectMode, dvalue);
    break;
-   case DCAM_IDPROP_INTENSITYLUT_PAGE:
-      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_INTENSITYLUT_PAGE, &dvalue);
-      status = setIntegerParam(hIntensityLutPage, dvalue);
+   case DCAM_IDPROP_HOTPIXELCORRECT_LEVEL:
+      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_HOTPIXELCORRECT_LEVEL, &dvalue);
+      status = setIntegerParam(hHotPixelCorrectLevel, dvalue);
    break;
    case DCAM_IDPROP_INTENSITYLUT_MODE:
       m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_INTENSITYLUT_MODE, &dvalue);
       status = setIntegerParam(hIntensityLutMode, dvalue);
    break;
+   case DCAM_IDPROP_INTENSITYLUT_PAGE:
+      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_INTENSITYLUT_PAGE, &dvalue);
+      status = setIntegerParam(hIntensityLutPage, dvalue);
+   break;
+   case DCAM_IDPROP_EXTRACTION_MODE:
+      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_EXTRACTION_MODE, &dvalue);
+      status = setIntegerParam(hExtractionMode, dvalue);
+   break;
    // - output trigger
+   case DCAM_IDPROP_NUMBEROF_OUTPUTTRIGGERCONNECTOR:
+      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_NUMBEROF_OUTPUTTRIGGERCONNECTOR, &dvalue);
+      status = setIntegerParam(hNumberOfOutputTriggerConnector, dvalue);
+   break;
+   case DCAM_IDPROP_OUTPUTTRIGGER_ACTIVE:
+      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_ACTIVE, &dvalue);
+      if(failed(m_err)) {
+           printError(m_hdcam, m_err, "OUTPUT_TRIGGER_ACTIVE", "IDPROP:0x%08x, VALUE:%f\n", propertyID, dvalue);
+      }else{
+         printf("-----------------> value = %f\n", dvalue);
+      }
+      
+      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_ACTIVE+4, &dvalue);
+      if(failed(m_err)) {
+           printError(m_hdcam, m_err, "OUTPUT_TRIGGER_ACTIVE", "IDPROP:0x%08x, VALUE:%f\n", propertyID, dvalue);
+      }else{
+         printf("-----------------> value = %f\n", dvalue);
+      }
+
+      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_ACTIVE+6, &dvalue);
+      if(failed(m_err)) {
+           printError(m_hdcam, m_err, "OUTPUT_TRIGGER_ACTIVE", "IDPROP:0x%08x, VALUE:%f\n", propertyID, dvalue);
+      }else{
+         printf("-----------------> value = %f\n", dvalue);
+      }
+
+
+      status = setIntegerParam(hOutputTriggerActive0, dvalue);
+   break;
+   //case DCAM_IDPROP_OUTPUTTRIGGER_ACTIVE:
+   //   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_ACTIVE, &dvalue);
+   //   status = setIntegerParam(hOutputTriggerActive1, dvalue);
+   //break;
+   //case DCAM_IDPROP_OUTPUTTRIGGER_ACTIVE:
+   //   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_ACTIVE, &dvalue);
+   //   status = setIntegerParam(hOutputTriggerActive2, dvalue);
+   //break;
 
    // - master pulse
 
@@ -724,7 +770,7 @@ void Hama::imageTask(){
             timestamp = (ts_sec + ts_microsec / 1.0e6) - (exposure_time + readout_time);
             status = setDoubleParam(hTimeStamp, timestamp);
 
-            //printf("Timestamp from camera: %f\n", (ts_sec + ts_microsec / 1.0e6));
+            printf("Timestamp from camera: %f\n", (ts_sec + ts_microsec / 1.0e6));
             //printf("Timestamp from camera with correction: %f\n", timestamp);
 
             getIntegerParam(NDArrayCallbacks, &callback);
@@ -822,7 +868,7 @@ return status;
 asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value){
 
 
-   printf("[DEBUG]::writeInt32\t");
+   //printf("[DEBUG]::writeInt32\t");
    asynStatus  status = asynSuccess;
    const char* functionName = "writeInt32";
    const char* paramName;
@@ -840,7 +886,7 @@ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value){
    status = setIntegerParam(index, value);
 
    if (index == ADAcquire) {
-        printf("[DEBUG]::function ADAcquire\n"); 
+        printf("[DEBUG]::writeInit32 ADAcquire\n"); 
         if (value) {
             /* Send an event to wake up the acq task.*/
             puts("Requested acquire start event. Sending acquire start event signal to thread");
@@ -867,12 +913,12 @@ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value){
    else if (index == ADImageMode) {
     //  dcamprop_setvalue(m_hdcam, DCAM_IDPROP_, value);
     //  dcamprop_getvalue(m_hdcam, DCAM_IDPROP_, &value_d);
-      printf("[DEBUG]::function ADImageMode\n"); 
+      printf("[DEBUG]::writeInit32 ADImageMode\n"); 
    }
    else if (index == ADNumExposures) {
       //camprop_setvalue(m_hdcam, DCAM_IDPROP_EXPOSURETIME, value);
       //dcamprop_getvalue(m_hdcam, DCAM_IDPROP_EXPOSURETIME, &value_d);
-      printf("[DEBUG]::function ADNumExposures\n"); 
+      printf("[DEBUG]::writeInit32 ADNumExposures\n"); 
    }
    else if (index == ADMinX) {
       updateSensorSize();
@@ -889,17 +935,17 @@ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value){
    else if (index == ADReadStatus) {
     //  dcamprop_setvalue(m_hdcam, DCAM_IDPROP_, value);
     //  dcamprop_getvalue(m_hdcam, DCAM_IDPROP_, &value_d);
-      printf("[DEBUG]::function ADReadStatus\n"); 
+      printf("[DEBUG]::writeInit32 ADReadStatus\n"); 
    }
    else if (index == hSensorMode) {
-      printf("[DEBUG]::function SensorMode %d\n", value); 
+      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]::function ReadoutSpeed %d\n", value); 
+      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);
@@ -907,7 +953,7 @@ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value){
 
    }
    else if (index == hReadoutDirection) {
-      printf("[DEBUG]::function ReadoutDirection %d\n", value); 
+      printf("[DEBUG]::writeInit32 ReadoutDirection %d\n", value); 
       m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_READOUT_DIRECTION, &dvalue, 0);
       if(failed(m_err)) {
         printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
@@ -915,70 +961,70 @@ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value){
    } 
    
    else if (index == hBitPerChannel) {
-      printf("[DEBUG]::function BitPerChannel %d\n", value); 
+      printf("[DEBUG]::writeInit32 BitPerChannel %d\n", value); 
       m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_BITSPERCHANNEL, &dvalue);
       if(failed(m_err)) {
         printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
       }
    }
    else if (index == hTriggerSource) {
-      printf("[DEBUG]::function TriggerSource %d\n", value); 
+      printf("[DEBUG]::writeInit32 TriggerSource %d\n", value); 
       m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TRIGGERSOURCE, &dvalue);
       if(failed(m_err)) {
         printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
       }
    }
    else if (index == hTriggerMode) {
-      printf("[DEBUG]::function TriggerMode %d\n", value); 
+      printf("[DEBUG]::writeInit32 TriggerMode %d\n", value); 
       m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TRIGGER_MODE, &dvalue);
       if(failed(m_err)) {
         printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
       }
    }
    else if (index == hTriggerActive) {
-      printf("[DEBUG]::function TriggerActive %d\n", value); 
+      printf("[DEBUG]::writeInit32 TriggerActive %d\n", value); 
       m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TRIGGERACTIVE, &dvalue);
       if(failed(m_err)) {
         printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
       }
    }
    else if (index == hTriggerGlobalExposure) {
-      printf("[DEBUG]::function TriggerGlobalExposure %d\n", value); 
+      printf("[DEBUG]::writeInit32 TriggerGlobalExposure %d\n", value); 
       m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TRIGGER_GLOBALEXPOSURE, &dvalue);
       if(failed(m_err)) {
         printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
       }
    }
    else if (index == hTriggerPolarity) {
-      printf("[DEBUG]::function TriggerPolarity %d\n", value);
+      printf("[DEBUG]::writeInit32 TriggerPolarity %d\n", value);
       m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TRIGGERPOLARITY, &dvalue);
       if(failed(m_err)) {
         printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
       }
    }
    else if (index == hTriggerConnector) {
-      printf("[DEBUG]::function TriggerConnector %d\n", value); 
+      printf("[DEBUG]::writeInit32 TriggerConnector %d\n", value); 
       m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TRIGGER_CONNECTOR, &dvalue);
       if(failed(m_err)) {
         printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
       }
    }
    else if (index == hTriggerTimes) {
-      printf("[DEBUG]::function TriggerTimes %d\n", value); 
+      printf("[DEBUG]::writeInit32 TriggerTimes %d\n", value); 
       m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TRIGGERTIMES, &dvalue);
       if(failed(m_err)) {
         printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
       }
    }
    else if (index == hInternalTriggerHandling) {
-      printf("[DEBUG]::function TriggerHandling %d\n", value); 
+      printf("[DEBUG]::writeInit32 TriggerHandling %d\n", value); 
       m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_INTERNALTRIGGER_HANDLING, &dvalue);
       if(failed(m_err)) {
         printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
       }
    } 
    else if (index == hSensorCoolerStatus) {
-      printf("[DEBUG]::function SensorCoolerStatus %d\n", value); 
+      printf("[DEBUG]::writeInit32 SensorCoolerStatus %d\n", value); 
       m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SENSORCOOLERSTATUS, &dvalue);
       if(failed(m_err)) {
         printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
@@ -986,13 +1032,13 @@ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value){
    }
    else if (index == hDefectCorrectMode) {
       m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_DEFECTCORRECT_MODE, &dvalue);
-      printf("[DEBUG]::function DefectCorrerMode %f\n", dvalue); 
+      printf("[DEBUG]::writeInit32 DefectCorrerMode %f\n", dvalue); 
       if(failed(m_err)) {
         printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
       }
    }
    else if (index == hHotPixelCorrectLevel) {
-      printf("[DEBUG]::function HotPixelCorrectLevel %d\n", value); 
+      printf("[DEBUG]::writeInit32 HotPixelCorrectLevel %d\n", value); 
       m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_HOTPIXELCORRECT_LEVEL, &dvalue);
       if(failed(m_err)) {
         printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
@@ -1000,7 +1046,7 @@ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value){
    }
    else if (index == hBinning) {
       updateSensorSize();
-      printf("[DEBUG]::function Binning %d\n", value); 
+      printf("[DEBUG]::writeInit32 Binning %d\n", value); 
    }
    else if (index == hSubarrayHPos) {
       printf("[DEBUG]::function SubArrayHPos %d\n", value); 
@@ -1010,28 +1056,28 @@ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value){
       }
    }
    else if (index == hSubarrayHSize) {
-      printf("[DEBUG]::function SubarrayHSize %d\n", value); 
+      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]::function SubarrayVPos %d\n", value); 
+      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]::function SubarrayVSize %d\n", value); 
+      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]::function SubarrayMode %d\n", value); 
+      printf("[DEBUG]::writeInit32 SubarrayMode %d\n", value); 
       m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYMODE, &dvalue);
       if(failed(m_err)) {
         printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
@@ -1054,217 +1100,225 @@ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value){
    }
    */
    else if (index == hExtractionMode) {
-      printf("[DEBUG]::function ExtractionMode %d\n", value); 
+      printf("[DEBUG]::writeInit32 ExtractionMode %d\n", value); 
       m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_EXTRACTION_MODE, &dvalue);
       if(failed(m_err)) {
         printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
       }
    }
    else if (index == hTimingExposure) {
-      printf("[DEBUG]::function TimingExposure %d\n", value); 
+      printf("[DEBUG]::writeInit32 TimingExposure %d\n", value); 
       m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TIMING_EXPOSURE, &dvalue);
       if(failed(m_err)) {
         printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
       }
    }
    else if (index == ADBinX) {
-      printf("[DEBUG]::function ImageWidth %d\n", value); 
+      printf("[DEBUG]::writeInit32 ImageWidth %d\n", value); 
       m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_WIDTH, &dvalue);
       if(failed(m_err)) {
         printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
       }
    }
    else if (index == ADBinY) {
-      printf("[DEBUG]::function ImageHeight %d\n", value); 
+      printf("[DEBUG]::writeInit32 ImageHeight %d\n", value); 
       m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_HEIGHT, &dvalue);
       if(failed(m_err)) {
         printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
       }
    }
    else if (index == hImageRowbytes) {
-      printf("[DEBUG]::function ImageRowBytes %d\n", value); 
+      printf("[DEBUG]::writeInit32 ImageRowBytes %d\n", value); 
       m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_IMAGE_ROWBYTES, &dvalue);
       if(failed(m_err)) {
         printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
       }
    }
    else if (index == hImageFramebytes) {
-      printf("[DEBUG]::function ImageFramBytes %d\n", value); 
+      printf("[DEBUG]::writeInit32 ImageFramBytes %d\n", value); 
       m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &dvalue);
       if(failed(m_err)) {
         printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
       }
    }
    else if (index == hImageTopOffsetBytes) {
-      printf("[DEBUG]::function ImageTopOffsetBytes %d\n", value); 
+      printf("[DEBUG]::writeInit32 ImageTopOffsetBytes %d\n", value); 
       m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_IMAGE_TOPOFFSETBYTES, &dvalue);
       if(failed(m_err)) {
         printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
       }
    }
    else if (index == hImagePixelType) {
-      printf("[DEBUG]::function ImagePixelType %d\n", value); 
+      printf("[DEBUG]::writeInit32 ImagePixelType %d\n", value); 
       m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_IMAGE_PIXELTYPE, &dvalue);
       if(failed(m_err)) {
         printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
       }
    }
    else if (index == hBufferRowbytes) {
-      printf("[DEBUG]::function BufferRowBytes %d\n", value); 
+      printf("[DEBUG]::writeInit32 BufferRowBytes %d\n", value); 
       m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_BUFFER_ROWBYTES, &dvalue);
       if(failed(m_err)) {
         printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
       }
    }
    else if (index == hBufferFramebytes) {
-      printf("[DEBUG]::function BufferFrameBytes %d\n", value); 
+      printf("[DEBUG]::writeInit32 BufferFrameBytes %d\n", value); 
       m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_BUFFER_FRAMEBYTES, &dvalue);
       if(failed(m_err)) {
         printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
       }
    }
    else if (index == hBufferTopOffsetBytes) {
-      printf("[DEBUG]::function BufferTopOffsetBytes %d\n", value); 
+      printf("[DEBUG]::writeInit32 BufferTopOffsetBytes %d\n", value); 
       m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_BUFFER_TOPOFFSETBYTES, &dvalue);
       if(failed(m_err)) {
         printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
       }
    }
    else if (index == hBufferPixelType) {
-      printf("[DEBUG]::function BufferPixelType %d\n", value); 
+      printf("[DEBUG]::writeInit32 BufferPixelType %d\n", value); 
       m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_BUFFER_PIXELTYPE, &dvalue);
       if(failed(m_err)) {
         printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
       }
    }
    else if (index == hRecordFixedBytesPerFile) {
-      printf("[DEBUG]::function ecordFixedBytesPerFile %d\n", value);
+      printf("[DEBUG]::writeInit32 ecordFixedBytesPerFile %d\n", value);
       m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_RECORDFIXEDBYTES_PERFILE, &dvalue);
       if(failed(m_err)) {
         printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
       }
    }
    else if (index == hRecordFixedBytesPerSession) {
-      printf("[DEBUG]::function RecordFixedBytesPerSesion %d\n", value); 
+      printf("[DEBUG]::writeInit32 RecordFixedBytesPerSesion %d\n", value); 
       m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_RECORDFIXEDBYTES_PERSESSION, &dvalue);
       if(failed(m_err)) {
         printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
       }
    }
    else if (index == hRecordFixedBytesPerFrame) {
-      printf("[DEBUG]::function RecordFixedBytesPerFrame %d\n", value); 
+      printf("[DEBUG]::writeInit32 RecordFixedBytesPerFrame %d\n", value); 
       m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_RECORDFIXEDBYTES_PERFRAME, &dvalue);
       if(failed(m_err)) {
         printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
       }
    }
    else if (index == hNumberOfOutputTriggerConnector) {
-      printf("[DEBUG]::function NumberOutputTriggerConnector %d\n", value); 
+      printf("[DEBUG]::writeInit32 NumberOutputTriggerConnector %d\n", value); 
       m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_NUMBEROF_OUTPUTTRIGGERCONNECTOR, &dvalue);
       if(failed(m_err)) {
         printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
       }
    }
    else if (index == hOutputTriggerSource0) {
-      printf("[DEBUG]::function OutputTriggerSource0 %d\n", value); 
+      printf("[DEBUG]::writeInit32 OutputTriggerSource0 %d\n", value); 
       m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_SOURCE, &dvalue);
       if(failed(m_err)) {
         printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
       }
    }
    else if (index == hOutputTriggerPolarity0) {
-      printf("[DEBUG]::function OutputTriggerPolaroty0 %d\n", value); 
+      printf("[DEBUG]::writeInit32 OutputTriggerPolaroty0 %d\n", value); 
       m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_POLARITY, &dvalue);
       if(failed(m_err)) {
         printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
       }
    }
    else if (index == hOutputTriggerActive0) {
-      printf("[DEBUG]::function OutputTriggerActive0 %d\n", value); 
+      printf("[DEBUG]::writeInit32 OutputTriggerActive0 %d\n", value); 
       m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_ACTIVE, &dvalue);
       if(failed(m_err)) {
         printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
       }
    }
    else if (index == hOutputTriggerKind0) {
-      printf("[DEBUG]::function OutputTriggerKind0 %d\n", value); 
+      printf("[DEBUG]::writeInit32 OutputTriggerKind0 %d\n", value); 
       m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_KIND, &dvalue);
       if(failed(m_err)) {
         printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
       }
    }
    else if (index == hOutputTriggerBaseSensor0) {
-      printf("[DEBUG]::function OutputTriggerBaseSensor0 %d\n", value); 
+      printf("[DEBUG]::writeInit32 OutputTriggerBaseSensor0 %d\n", value); 
       m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_BASESENSOR, &dvalue);
       if(failed(m_err)) {
         printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
       }
    }
    else if (index == hOutputTriggerPreHsyncCount0) {
-      printf("[DEBUG]::function OutputTriggerPreHsynCount %d\n", value); 
+      printf("[DEBUG]::writeInit32 OutputTriggerPreHsynCount %d\n", value); 
       m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_PREHSYNCCOUNT, &dvalue);
       if(failed(m_err)) {
         printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
       }
    }
    else if (index == hMasterPulseMode) {
-      printf("[DEBUG]::function MasterPulseMode %d\n", value); 
+      printf("[DEBUG]::writeInit32 MasterPulseMode %d\n", value); 
       m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_MASTERPULSE_MODE, &dvalue);
       if(failed(m_err)) {
         printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
       }
    }
    else if (index == hMasterPulseTriggerSource) {
-      printf("[DEBUG]::function MasterPulseTriggerSource %d\n", value); 
+      printf("[DEBUG]::writeInit32 MasterPulseTriggerSource %d\n", value); 
       m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_MASTERPULSE_TRIGGERSOURCE, &dvalue);
       if(failed(m_err)) {
         printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
       }
    }
+   else if (index == hIntensityLutMode) {
+      printf("[DEBUG]::writeInit32 IntensityLutMode %d\n", value); 
+      m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_INTENSITYLUT_MODE, &dvalue);
+      if(failed(m_err)) {
+        printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
+      }
+   }
+ 
    else if (index == hMasterPulseBurstTimes) {
-      printf("[DEBUG]::function MasterPulseBurstTimes %d\n", value); 
+      printf("[DEBUG]::writeInit32 MasterPulseBurstTimes %d\n", value); 
       m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_MASTERPULSE_BURSTTIMES, &dvalue);
       if(failed(m_err)) {
         printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
       }
    }
    else if (index == hSystemAlive) {
-      printf("[DEBUG]::function SystemAlive %d\n", value); 
+      printf("[DEBUG]::writeInit32 SystemAlive %d\n", value); 
       m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SYSTEM_ALIVE, &dvalue);
       if(failed(m_err)) {
         printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
       }
    }
    else if (index == hNumberOfView) {
-      printf("[DEBUG]::function NumberOfView %d\n", value); 
+      printf("[DEBUG]::writeInit32 NumberOfView %d\n", value); 
       m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_NUMBEROF_VIEW, &dvalue);
       if(failed(m_err)) {
         printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
       }
    }
    else if (index == hImageDetectorPixelNumHorz) {
-      printf("[DEBUG]::function ImageDetectorPixelNumHorz %d\n", value); 
+      printf("[DEBUG]::writeInit32 ImageDetectorPixelNumHorz %d\n", value); 
       m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_IMAGEDETECTOR_PIXELHEIGHT, &dvalue);
       if(failed(m_err)) {
         printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
       }
    }
    else if (index == hImageDetectorPixelNumVert) {
-      printf("[DEBUG]::function ImageDetectorPixelNumVert %d\n", value); 
+      printf("[DEBUG]::writeInit32 ImageDetectorPixelNumVert %d\n", value); 
       m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_IMAGEDETECTOR_PIXELWIDTH, &dvalue);
       if(failed(m_err)) {
         printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
       }
    }
    else if (index == hTimeStampProducer) {
-      printf("[DEBUG]::function TimeStampProducer %d\n", value); 
+      printf("[DEBUG]::writeInit32 TimeStampProducer %d\n", value); 
       m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TIMESTAMP_PRODUCER, &dvalue);
       if(failed(m_err)) {
         printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
       }
    }
    else if (index == hFrameStampProducer) {
-      printf("[DEBUG]::function FrameStampProducer %d\n", value); 
+      printf("[DEBUG]::writeInit32 FrameStampProducer %d\n", value); 
       m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_FRAMESTAMP_PRODUCER, &dvalue);
       if(failed(m_err)) {
         printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
@@ -1273,7 +1327,7 @@ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value){
    else{
       if(index < FIRST_HAMA_PARAM){
           status = ADDriver::writeInt32(pasynUser, value);
-          printf("[+DEBUG]::function writeInt32 did not find a parameter, call ADDriver::writeInit32 %s\n", paramName); 
+          printf("[+DEBUG]:: ADDriver::writeInit32 %s\n", paramName); 
           ADDriver::writeInt32(pasynUser, value);
       }
       else{