diff --git a/ADHamaApp/src/hama.cpp b/ADHamaApp/src/hama.cpp
index 61ad70a..aeb4833 100644
--- a/ADHamaApp/src/hama.cpp
+++ b/ADHamaApp/src/hama.cpp
@@ -625,17 +625,17 @@ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value){
    const char* paramName;
 
    int index = pasynUser->reason;
-    int adstatus;
+   int adstatus;
 
    getParamName(index, &paramName);
 
-    /* Ensure that ADStatus is set correctly before we set ADAcquire.*/
-    getIntegerParam(ADStatus, &adstatus);
+   /* Ensure that ADStatus is set correctly before we set ADAcquire.*/
+   getIntegerParam(ADStatus, &adstatus);
 
    double value_d = 0; 
    //getIntegerParam(index, &value);
 
-    if (index == ADAcquire) {
+   if (index == ADAcquire) {
         printf("function ADAcquire\n"); 
         if (value) {
             /* Send an event to wake up the acq task.*/
@@ -687,270 +687,278 @@ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value){
    else if (index == hSensorMode) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_SENSORMODE, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SENSORMODE, &value_d);
-      printf("function SensorMode\n"); 
+      printf("function SensorMode %d\n", value); 
    }
    else if (index == hReadoutSpeed) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_READOUTSPEED, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_READOUTSPEED, &value_d);
-      printf("function ReadoutSpeed\n"); 
+      printf("function ReadoutSpeed %d\n", value); 
 
    }
    else if (index == hReadoutDirection) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_READOUT_DIRECTION, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_READOUT_DIRECTION, &value_d);
-      printf("function ReadoutDirection\n"); 
+      printf("function ReadoutDirection %d\n", value); 
    }
    else if (index == hColorType) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_COLORTYPE, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_COLORTYPE, &value_d);
-      printf("function ColorType\n"); 
+      printf("function ColorType %d\n", value); 
    }
    else if (index == hBitPerChannel) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_BITSPERCHANNEL, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_BITSPERCHANNEL, &value_d);
-      printf("function BitPerChannel\n"); 
+      printf("function BitPerChannel %d\n", value); 
    }
    else if (index == hTriggerSource) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_TRIGGERSOURCE, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGERSOURCE, &value_d);
+      printf("function TriggerSource %d\n", value); 
       }
    else if (index == hTriggerMode) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_TRIGGER_MODE, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGER_MODE, &value_d);
+      printf("function TriggerMode %d\n", value); 
    }
    else if (index == hTriggerActive) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_TRIGGERACTIVE, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGERACTIVE, &value_d);
+      printf("function TriggerActive %d\n", value); 
    }
    else if (index == hTriggerGlobalExposure) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_TRIGGER_GLOBALEXPOSURE, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGER_GLOBALEXPOSURE, &value_d);
+      printf("function TriggerGlobalExposure %d\n, value"); 
    }
    else if (index == hTriggerPolarity) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_TRIGGERPOLARITY, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGERPOLARITY, &value_d);
+      printf("function TriggerPolarity %d\n", value);
    }
    else if (index == hTriggerConnector) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_TRIGGER_CONNECTOR, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGER_CONNECTOR, &value_d);
+      printf("function TriggerConnector %d\n", value); 
    }
    else if (index == hTriggerTimes) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_TRIGGERTIMES, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGERTIMES, &value_d);
+      printf("function TriggerTimes %d\n", value); 
    }
    else if (index == hInternalTriggerHandling) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_INTERNALTRIGGER_HANDLING, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_INTERNALTRIGGER_HANDLING, &value_d);
+      printf("function TriggerHandling %d\n", value); 
    } 
    else if (index == hSensorCoolerStatus) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_SENSORCOOLERSTATUS, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SENSORCOOLERSTATUS, &value_d);
-      printf("function BitPerChannel\n"); 
+      printf("function SensorCoolerStatus %d\n, value"); 
    }
    else if (index == hDefectCorrectMode) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_DEFECTCORRECT_MODE, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_DEFECTCORRECT_MODE, &value_d);
-      printf("function BitPerChannel\n"); 
+      printf("function DefectCorrerMode %d\n", value); 
    }
    else if (index == hHotPixelCorrectLevel) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_HOTPIXELCORRECT_LEVEL, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_HOTPIXELCORRECT_LEVEL, &value_d);
-      printf("function BitPerChannel\n"); 
+      printf("function HotPixelCorrectLevel %d\n", value); 
    }
    else if (index == hBinning) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_BINNING, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_BINNING, &value_d);
-      printf("function BitPerChannel\n"); 
+      printf("function Binning %d\n", value); 
    }
    else if (index == hSubarrayHPos) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHPOS, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHPOS, &value_d);
-      printf("function BitPerChannel\n"); 
+      printf("function SubArrayHPos %d\n", value); 
    }
    else if (index == hSubarrayHSize) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHSIZE, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHSIZE, &value_d);
-      printf("function BitPerChannel\n"); 
+      printf("function SubarrayHSize %d\n", value); 
    }
    else if (index == hSubarrayVPos) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVPOS, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVPOS, &value_d);
-      printf("function BitPerChannel\n"); 
+      printf("function SubarrayVPos %d\n", value); 
    }
    else if (index == hSubarrayVSize) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVSIZE, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVSIZE, &value_d);
-      printf("function BitPerChannel\n"); 
+      printf("function SubarrayVSize %d\n", value); 
    }
    else if (index == hSubarrayMode) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_SUBARRAYMODE, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYMODE, &value_d);
-      printf("function BitPerChannel\n"); 
+      printf("function SubarrayMode %d\n", value); 
    }
    else if (index == hIntensityLutMode) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_INTENSITYLUT_MODE, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_INTENSITYLUT_MODE, &value_d);
-      printf("function BitPerChannel\n"); 
+      printf("function IntensityLutMode %d\n", value); 
    }
    else if (index == hIntensityLutPage) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_INTENSITYLUT_PAGE, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_INTENSITYLUT_PAGE, &value_d);
-      printf("function BitPerChannel\n"); 
+      printf("function IntensityLutPage %d\n", value); 
    }
    else if (index == hExtractionMode) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_EXTRACTION_MODE, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_EXTRACTION_MODE, &value_d);
-      printf("function BitPerChannel\n"); 
+      printf("function ExtractionMode %d\n", value); 
    }
    else if (index == hTimingExposure) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_TIMING_EXPOSURE, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TIMING_EXPOSURE, &value_d);
-      printf("function BitPerChannel\n"); 
+      printf("function TimingExposure %d\n", value); 
    }
    else if (index == hImageWidth) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_IMAGE_WIDTH, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_WIDTH, &value_d);
-      printf("function BitPerChannel\n"); 
+      printf("function ImageWidth %d\n", value); 
    }
    else if (index == hImageHeight) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_IMAGE_HEIGHT, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_HEIGHT, &value_d);
-      printf("function BitPerChannel\n"); 
+      printf("function ImageHeight %d\n", value); 
    }
    else if (index == hImageRowbytes) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_IMAGE_ROWBYTES, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_ROWBYTES, &value_d);
-      printf("function BitPerChannel\n"); 
+      printf("function ImageRowBytes %d\n", value); 
    }
    else if (index == hImageFramebytes) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &value_d);
-      printf("function BitPerChannel\n"); 
+      printf("function ImageFramBytes %d\n", value); 
    }
    else if (index == hImageTopOffsetBytes) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_IMAGE_TOPOFFSETBYTES, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_TOPOFFSETBYTES, &value_d);
-      printf("function BitPerChannel\n"); 
+      printf("function ImageTopOffsetBytes %d\n", value); 
    }
    else if (index == hImagePixelType) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_IMAGE_PIXELTYPE, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_PIXELTYPE, &value_d);
-      printf("function BitPerChannel\n"); 
+      printf("function ImagePixelType %d\n", value); 
    }
    else if (index == hBufferRowbytes) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_BUFFER_ROWBYTES, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_BUFFER_ROWBYTES, &value_d);
-      printf("function BitPerChannel\n"); 
+      printf("function BufferRowBytes %d\n", value); 
    }
    else if (index == hBufferFramebytes) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_BUFFER_FRAMEBYTES, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_BUFFER_FRAMEBYTES, &value_d);
-      printf("function BitPerChannel\n"); 
+      printf("function BufferFrameBytes %d\n", value); 
    }
    else if (index == hBufferTopOffsetBytes) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_BUFFER_TOPOFFSETBYTES, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_BUFFER_TOPOFFSETBYTES, &value_d);
-      printf("function BitPerChannel\n"); 
+      printf("function BufferTopOffsetBytes %d\n", value); 
    }
    else if (index == hBufferPixelType) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_BUFFER_PIXELTYPE, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_BUFFER_PIXELTYPE, &value_d);
-      printf("function BitPerChannel\n"); 
+      printf("function BufferPixelType %d\n", value); 
    }
    else if (index == hRecordFixedBytesPerFile) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_RECORDFIXEDBYTES_PERFILE, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_RECORDFIXEDBYTES_PERFILE, &value_d);
-      printf("function BitPerChannel\n"); 
+      printf("function ecordFixedBytesPerFile %d\n", value);
    }
    else if (index == hRecordFixedBytesPerSession) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_RECORDFIXEDBYTES_PERSESSION, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_RECORDFIXEDBYTES_PERSESSION, &value_d);
-      printf("function BitPerChannel\n"); 
+      printf("function RecordFixedBytesPerSesion %d\n", value); 
    }
    else if (index == hRecordFixedBytesPerFrame) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_RECORDFIXEDBYTES_PERFRAME, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_RECORDFIXEDBYTES_PERFRAME, &value_d);
-      printf("function BitPerChannel\n"); 
+      printf("function RecordFixedBytesPerFrame %d\n", value); 
    }
    else if (index == hNumberOutputTriggerConnector) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_NUMBEROF_OUTPUTTRIGGERCONNECTOR, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_NUMBEROF_OUTPUTTRIGGERCONNECTOR, &value_d);
-      printf("function BitPerChannel\n"); 
+      printf("function NumberOutputTriggerConnector %d\n", value); 
    }
    else if (index == hOutputTriggerSource0) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_SOURCE, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_SOURCE, &value_d);
-      printf("function BitPerChannel\n"); 
+      printf("function OutputTriggerSource0 %d\n", value); 
    }
    else if (index == hOutputTriggerPolarity0) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_POLARITY, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_PERIOD, &value_d);
-      printf("function BitPerChannel\n"); 
+      printf("function OutputTriggerPolaroty0 %d\n", value); 
    }
    else if (index == hOutputTriggerActive0) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_ACTIVE, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_ACTIVE, &value_d);
-      printf("function BitPerChannel\n"); 
+      printf("function OutputTriggerActive0 %d\n", value); 
    }
    else if (index == hOutputTriggerKind0) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_KIND, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_KIND, &value_d);
-      printf("function BitPerChannel\n"); 
+      printf("function OutputTriggerKind0 %d\n", value); 
    }
    else if (index == hOutputTriggerBaseSensor0) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_BASESENSOR, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_BASESENSOR, &value_d);
-      printf("function BitPerChannel\n"); 
+      printf("function OutputTriggerBaseSensor0 %d\n", value); 
    }
    else if (index == hOutputTriggerPreHsyncCount) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_PREHSYNCCOUNT, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_PREHSYNCCOUNT, &value_d);
-      printf("function BitPerChannel\n"); 
+      printf("function OutputTriggerPreHsynCount %d\n", value); 
    }
    else if (index == hMasterPulseMode) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_MASTERPULSE_MODE, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_MASTERPULSE_MODE, &value_d);
-      printf("function BitPerChannel\n"); 
+      printf("function MasterPulseMode %d\n", value); 
    }
    else if (index == hMasterPulseTriggerSource) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_MASTERPULSE_TRIGGERSOURCE, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_MASTERPULSE_TRIGGERSOURCE, &value_d);
-      printf("function BitPerChannel\n"); 
+      printf("function MasterPulseTriggerSource %d\n", value); 
    }
    else if (index == hMasterPulseBurstTimes) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_MASTERPULSE_BURSTTIMES, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_MASTERPULSE_BURSTTIMES, &value_d);
-      printf("function BitPerChannel\n"); 
+      printf("function MasterPulseBurstTimes %d\n", value); 
    }
    else if (index == hSystemAlive) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_SYSTEM_ALIVE, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SYSTEM_ALIVE, &value_d);
-      printf("function BitPerChannel\n"); 
+      printf("function SystemAlive %d\n", value); 
    }
    else if (index == hNumberOfView) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_NUMBEROF_VIEW, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_NUMBEROF_VIEW, &value_d);
-      printf("function BitPerChannel\n"); 
+      printf("function NumberOfView %d\n", value); 
    }
    else if (index == hImageDetectorPixelNumHorz) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_IMAGEDETECTOR_PIXELHEIGHT, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGEDETECTOR_PIXELHEIGHT, &value_d);
-      printf("function BitPerChannel\n"); 
+      printf("function ImageDetectorPixelNumHorz %d\n", value); 
    }
    else if (index == hImageDetectorPixelNumVert) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_IMAGEDETECTOR_PIXELWIDTH, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGEDETECTOR_PIXELWIDTH, &value_d);
-      printf("function BitPerChannel\n"); 
+      printf("function ImageDetectorPixelNumVert %d\n", value); 
    }
    else if (index == hTimeStampProducer) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_TIMESTAMP_PRODUCER, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TIMESTAMP_PRODUCER, &value_d);
-      printf("function BitPerChannel\n"); 
+      printf("function TimeStampProducer %d\n", value); 
    }
    else if (index == hFrameStampProducer) {
       dcamprop_setvalue(m_hdcam, DCAM_IDPROP_FRAMESTAMP_PRODUCER, value);
       dcamprop_getvalue(m_hdcam, DCAM_IDPROP_FRAMESTAMP_PRODUCER, &value_d);
-      printf("function BitPerChannel\n"); 
+      printf("function FrameStampProducer %d\n", value); 
    }
    else{
       printf("function ELSE.... \n");