diff --git a/ADHamaApp/Db/hama.template b/ADHamaApp/Db/hama.template
index 469bdd5..42b71a8 100644
--- a/ADHamaApp/Db/hama.template
+++ b/ADHamaApp/Db/hama.template
@@ -123,58 +123,58 @@ record(ai, "$(P)$(R)TimeStamp-RB") {
 ##########################################################################
 record(stringin, "$(P)$(R)Vendor-RB"){
    field(DESC, "")
-#   field(PINI, "YES")
    field(DTYP, "asynOctetRead")
    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_VENDOR")
+   field(SCAN, "I/O Intr")
 }
 
 record(stringin, "$(P)$(R)Model-RB"){
    field(DESC, "")
-#   field(PINI, "YES")
    field(DTYP, "asynOctetRead")
    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_MODEL")
+   field(SCAN, "I/O Intr")
 }
 
 record(stringin, "$(P)$(R)CameraID-RB"){
    field(DESC, "")
-#   field(PINI, "YES")
    field(DTYP, "asynOctetRead")
    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_CAMERAID")
+   field(SCAN, "I/O Intr")
 }
 
 record(stringin, "$(P)$(R)Bus-RB"){
    field(DESC, "")
-#   field(PINI, "YES")
    field(DTYP, "asynOctetRead")
    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_BUS")
+   field(SCAN, "I/O Intr")
 }
 
 record(stringin, "$(P)$(R)CameraVersion-RB"){
    field(DESC, "")
-#   field(PINI, "YES")
    field(DTYP, "asynOctetRead")
    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_CAMERA_VERSION")
+   field(SCAN, "I/O Intr")
 }
 
 record(stringin, "$(P)$(R)DriverVersion-RB"){
    field(DESC, "")
-#   field(PINI, "YES")
    field(DTYP, "asynOctetRead")
    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_DRIVER_VERSION")
+   field(SCAN, "I/O Intr")
 }
 
 record(stringin, "$(P)$(R)ModuleVersion-RB"){
    field(DESC, "")
-#   field(PINI, "YES")
    field(DTYP, "asynOctetRead")
    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_MODULE_VERSION")
+   field(SCAN, "I/O Intr")
 }
 
 record(stringin, "$(P)$(R)DcamApiVersion-RB"){
    field(DESC, "")
-#   field(PINI, "YES")
    field(DTYP, "asynOctetRead")
    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_DCAM_API_VERSION")
+   field(SCAN, "I/O Intr")
 }
 
 
@@ -182,27 +182,27 @@ record(stringin, "$(P)$(R)DcamApiVersion-RB"){
 # Sensor Mode and Speed                                                  #
 ##########################################################################
 # Sensor Mode (mode 4)
-# record(mbbo, "$(P)$(R)SensorMode-S") {
-record(longout, "$(P)$(R)SensorMode-S") {
+#record(longout, "$(P)$(R)SensorMode-S") {
+ record(mbbo, "$(P)$(R)SensorMode-S") {
    field(DESC,"")
    field(PINI, "YES")
    field(DTYP, "asynInt32")
-   #field(ZRVL, "1")  field(ZRST, "Area")
-   #field(ONVL, "12") field(ONST, "Progressive")
-   #field(TWVL, "14") field(TWST, "Splitview")
-   #field(THVL, "16") field(THST, "Duallightsheet")
+   field(ZRVL, "1")  field(ZRST, "Area")
+   field(ONVL, "12") field(ONST, "Progressive")
+   field(TWVL, "14") field(TWST, "Splitview")
+   field(THVL, "16") field(THST, "Duallightsheet")
    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_SENSOR_MODE")  
    field(VAL,  "1")
 }
 
-#record(mbbi, "$(P)$(R)SensorMode-RB") {
-record(longin, "$(P)$(R)SensorMode-RB") {
+#record(longin, "$(P)$(R)SensorMode-RB") {
+record(mbbi, "$(P)$(R)SensorMode-RB") {
    field(DESC,"")
    field(DTYP, "asynInt32")
-   #field(ZRVL, "1")  field(ZRST, "Area")
-   #field(ONVL, "12") field(ONST, "Progressive")
-   #field(TWVL, "14") field(TWST, "Splitview")
-   #field(THVL, "16") field(THST, "Duallightsheet")
+   field(ZRVL, "1")  field(ZRST, "Area")
+   field(ONVL, "12") field(ONST, "Progressive")
+   field(TWVL, "14") field(TWST, "Splitview")
+   field(THVL, "16") field(THST, "Duallightsheet")
    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_SENSOR_MODE")
    field(SCAN, "I/O Intr")
 }
@@ -1284,13 +1284,27 @@ record(mbbi, "$(P)$(R)ColorType-R") {
    field(SCAN, "I/O Intr")
 }
 
-record(ai, "$(P)$(R)BitsPerChannel-R") {
+record(mbbo, "$(P)$(R)BitsPerChannel-S") {
+   field(DESC, "")
+   field(PINI, "YES")
+   field(DTYP, "asynInt32")  
+   field(ZRVL, "12")
+   field(ZRST, "12 bits")
+   field(ONVL, "16")
+   field(ONST, "16 bits")
+   field(VAL,  "16")
+   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_BIT_PER_CHANNEL")
+}
+record(mbbi, "$(P)$(R)BitsPerChannel-R") {
    field(DESC,"")
-   field(DTYP, "asynInt32")
+   field(DTYP, "asynInt32")  
+   field(ZRVL, "12")
+   field(ZRST, "12 bits")
+   field(ONVL, "16")
+   field(ONST, "16 bits")
    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_BIT_PER_CHANNEL")
    field(SCAN, "I/O Intr")
 }
-
 # implemented in ADBase as BINX_RBV
 #record(ai, "$(P)$(R)ImageWidth-R") {
 #   field(DESC,"")
@@ -1376,11 +1390,11 @@ record(ai, "$(P)$(R)BufTopOffsetBytes-R") {
 record(mbbi, "$(P)$(R)BufPixelType-R") {
    field(DESC,"")
    field(DTYP, "asynInt32")
-   field(ZRVL, "0")
+   field(ZRVL, "1")
    field(ZRST, "MONO8")
-   field(ONVL, "1")
+   field(ONVL, "2")
    field(ONST, "MONO16")
-   field(TWVL, "2")
+   field(TWVL, "3")
    field(TWST, "MONO12")
    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_BUFFER_PIXEL_TYPE")
    field(SCAN, "I/O Intr")
@@ -1410,25 +1424,25 @@ record(ai, "$(P)$(R)RecBytesPerFrame-R") {
 record(mbbi, "$(P)$(R)SystemAlive-R") {
    field(DESC,"")
    field(DTYP, "asynInt32")
-   field(ZRVL, "0")
+   field(ZRVL, "1")
    field(ZRST, "OFFLINE")
-   field(ONVL, "1")
+   field(ONVL, "2")
    field(ONST, "ONLINE")
    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_SYSTEM_ALIVE")
    field(SCAN, "I/O Intr")
 }
 
-record(ai, "$(P)$(R)ConversionOffset-R") {
+record(ai, "$(P)$(R)ConversionFactorOffset-R") {
    field(DESC,"")
    field(DTYP, "asynFloat64")
-   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_CONVERSION_FACTOR_OFFSET")
+   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_CONVERSIONFACTOR_OFFSET")
    field(SCAN, "I/O Intr")
 }
 
-record(ai, "$(P)$(R)ConversionCoef-R") {
+record(ai, "$(P)$(R)ConversionFactorCoeff-R") {
    field(DESC,"")
    field(DTYP, "asynFloat64")
-   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_CONVERSION_FACTOR_COEF")
+   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_CONVERSIONFACTOR_COEFF")
    field(SCAN, "I/O Intr")
 }
 
diff --git a/ADHamaApp/src/hama.cpp b/ADHamaApp/src/hama.cpp
index 5139f53..508e6d2 100644
--- a/ADHamaApp/src/hama.cpp
+++ b/ADHamaApp/src/hama.cpp
@@ -244,7 +244,6 @@ int Hama::initCamera(){
    err |= getParameter(DETECTOR_PIXEL_NUM_HORZ); 
    err |= getParameter(DETECTOR_PIXEL_NUM_VERT); 
 
-
    err |= getParameter( DCAM_IDPROP_IMAGE_PIXELTYPE);
 	err |= getParameter( DCAM_IDPROP_IMAGE_WIDTH);
 	err |= getParameter( DCAM_IDPROP_IMAGE_ROWBYTES);
@@ -256,7 +255,6 @@ int Hama::initCamera(){
 	err |= getParameter( DCAM_IDPROP_SUBARRAYHSIZE);
 	err |= getParameter( DCAM_IDPROP_SUBARRAYVSIZE);
 
-
    err |= getParameter(DCAM_IDPROP_TRIGGERSOURCE);
    err |= getParameter(DCAM_IDPROP_TRIGGER_MODE);
    err |= getParameter(DCAM_IDPROP_TRIGGERACTIVE);
@@ -267,11 +265,23 @@ int Hama::initCamera(){
    err |= getParameter(DCAM_IDPROP_TRIGGERDELAY);
    err |= getParameter(DCAM_IDPROP_INTERNALTRIGGER_HANDLING);
 
-    err |= getParameter(DCAM_IDPROP_TIMESTAMP_PRODUCER);
+   err |= getParameter(DCAM_IDPROP_IMAGE_TOPOFFSETBYTES);
+   err |= getParameter(DCAM_IDPROP_BUFFER_ROWBYTES);
+   err |= getParameter(DCAM_IDPROP_BUFFER_FRAMEBYTES);
+   err |= getParameter(DCAM_IDPROP_BUFFER_TOPOFFSETBYTES);
+   err |= getParameter(DCAM_IDPROP_BUFFER_PIXELTYPE);
+   err |= getParameter(DCAM_IDPROP_RECORDFIXEDBYTES_PERFILE);
+   err |= getParameter(DCAM_IDPROP_RECORDFIXEDBYTES_PERSESSION);
+   err |= getParameter(DCAM_IDPROP_RECORDFIXEDBYTES_PERFRAME);
+   err |= getParameter(DCAM_IDPROP_SYSTEM_ALIVE);
+   err |= getParameter(DCAM_IDPROP_CONVERSIONFACTOR_COEFF);
+   err |= getParameter(DCAM_IDPROP_CONVERSIONFACTOR_OFFSET);
+   err |= getParameter(DCAM_IDPROP_NUMBEROF_VIEW);
+   err |= getParameter(DCAM_IDPROP_TIMESTAMP_PRODUCER);
+   err |= getParameter(DCAM_IDPROP_FRAMESTAMP_PRODUCER);
 
 
 
-    callParamCallbacks();
    if(err){
    // asynPrint(pasynUser, ASYN_TRACEIO_DRIVER, "%s:%s: port=%s, value=%d, status=%d\n",
    //         driverName, functionName, this->portName, value, (int)status);
@@ -339,6 +349,7 @@ int Hama::getParameterStr(int propertyID){
 
    }
 
+   callParamCallbacks();
 
 return int(status);
 }
@@ -494,10 +505,67 @@ asynStatus Hama::getParameter(int propertyID){
       status = setIntegerParam(hInternalTriggerHandling, dvalue);
    break;
 
-    case DCAM_IDPROP_TIMESTAMP_PRODUCER:
+   case DCAM_IDPROP_COLORTYPE:
+      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_COLORTYPE, &dvalue);
+      status = setIntegerParam(hColorType, dvalue);
+   break;
+
+   case DCAM_IDPROP_IMAGE_TOPOFFSETBYTES:
+      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_TOPOFFSETBYTES, &dvalue);
+      status = setIntegerParam(hImageTopOffsetBytes, dvalue);
+   break;   
+   case DCAM_IDPROP_BUFFER_ROWBYTES:
+      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_BUFFER_ROWBYTES, &dvalue);
+      status = setIntegerParam(hBufferRowbytes, dvalue);
+   break;   
+   case DCAM_IDPROP_BUFFER_FRAMEBYTES:
+      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_BUFFER_FRAMEBYTES, &dvalue);
+      status = setIntegerParam(hBufferFramebytes, dvalue);
+   break;   
+   case DCAM_IDPROP_BUFFER_TOPOFFSETBYTES:
+      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_BUFFER_TOPOFFSETBYTES, &dvalue);
+      status = setIntegerParam(hBufferTopOffsetBytes, dvalue);
+   break;   
+   case DCAM_IDPROP_BUFFER_PIXELTYPE:
+      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_BUFFER_PIXELTYPE, &dvalue);
+      status = setIntegerParam(hBufferPixelType, dvalue);
+   break;   
+   case DCAM_IDPROP_RECORDFIXEDBYTES_PERFILE:
+      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_RECORDFIXEDBYTES_PERFILE, &dvalue);
+      status = setIntegerParam(hRecordFixedBytesPerFile, dvalue);
+   break;   
+   case DCAM_IDPROP_RECORDFIXEDBYTES_PERSESSION:
+      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_RECORDFIXEDBYTES_PERSESSION, &dvalue);
+      status = setIntegerParam(hRecordFixedBytesPerSession, dvalue);
+   break;   
+   case DCAM_IDPROP_RECORDFIXEDBYTES_PERFRAME:
+      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_RECORDFIXEDBYTES_PERFRAME, &dvalue);
+      status = setIntegerParam(hRecordFixedBytesPerFrame, dvalue);
+   break;   
+   case DCAM_IDPROP_SYSTEM_ALIVE:
+      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SYSTEM_ALIVE, &dvalue);
+      status = setIntegerParam(hSystemAlive, dvalue);
+   break;   
+   case DCAM_IDPROP_CONVERSIONFACTOR_COEFF:
+      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_CONVERSIONFACTOR_COEFF, &dvalue);
+      status = setDoubleParam(hConversionFactorCoeff, dvalue);
+   break;   
+   case DCAM_IDPROP_CONVERSIONFACTOR_OFFSET:
+      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_CONVERSIONFACTOR_OFFSET, &dvalue);
+      status = setDoubleParam(hConversionFactorOffset, dvalue);
+   break;   
+   case DCAM_IDPROP_NUMBEROF_VIEW:
+      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_NUMBEROF_VIEW, &dvalue);
+      status = setIntegerParam(hNumberOfView, dvalue);
+   break;   
+   case DCAM_IDPROP_TIMESTAMP_PRODUCER:
       m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TIMESTAMP_PRODUCER, &dvalue);
-        status = setIntegerParam(hTimeStampProducer, dvalue);
-    break;
+      status = setIntegerParam(hTimeStampProducer, dvalue);
+   break;   
+   case DCAM_IDPROP_FRAMESTAMP_PRODUCER:
+      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_FRAMESTAMP_PRODUCER, &dvalue);
+      status = setIntegerParam(hFrameStampProducer, dvalue);
+   break;   
 
    default:
       char text[256];
@@ -813,13 +881,7 @@ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value){
         printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
       }
    } 
-   else if (index == hColorType) {
-      printf("[DEBUG]::function ColorType %d\n", value);
-      m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_COLORTYPE, &dvalue);
-      if(failed(m_err)) {
-        printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
-      }
-   }
+   
    else if (index == hBitPerChannel) {
       printf("[DEBUG]::function BitPerChannel %d\n", value); 
       m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_BITSPERCHANNEL, &dvalue);
@@ -891,8 +953,8 @@ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value){
       }
    }
    else if (index == hDefectCorrectMode) {
-      printf("[DEBUG]::function DefectCorrerMode %d\n", value); 
       m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_DEFECTCORRECT_MODE, &dvalue);
+      printf("[DEBUG]::function DefectCorrerMode %f\n", dvalue); 
       if(failed(m_err)) {
         printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
       }
@@ -1176,6 +1238,8 @@ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value){
    }
    else{
       if(index < FIRST_HAMA_PARAM){
+          status = ADDriver::writeInt32(pasynUser, value);
+          printf("Call function ADDriver::writeInt32\n");
           printf("[DEBUG]::function writeInt32 did not find a parameter, call ADDriver::writeInit32 %s\n", paramName); 
           printf("[DEBUG]::function writeInt32 FIRST = %d / LAST = %d, %d)\n", 
           FIRST_HAMA_PARAM, LAST_HAMA_PARAM, LAST_HAMA_PARAM-FIRST_HAMA_PARAM); 
@@ -1365,6 +1429,8 @@ asynStatus Hama::writeFloat64(asynUser *pasynUser, epicsFloat64 value){
       }
     }
     else{
+      status = ADDriver::writeFloat64(pasynUser, value);
+      printf("Call function ADDriver::writeFloat64\n");
       printf("[DEBUG]::function writeFloat64 did not find a parameter\n"); 
     }
 
diff --git a/ADHamaApp/src/hama.h b/ADHamaApp/src/hama.h
index 17dfff2..f2bb217 100644
--- a/ADHamaApp/src/hama.h
+++ b/ADHamaApp/src/hama.h
@@ -103,31 +103,31 @@
 #define hInternalLineIntervalString		"H_INTERNAL_LINE_INTERVAL"  /* asynFloat64  rw */
 
 // System information
-#define hColorTypeString		        "H_COLOR_TYPE"		    	/* asynInt32  ro */
-#define hBitPerChannelString			"H_BIT_PER_CHANNEL"         /* asynInt32  rw */
-//#define hImageWidthString			    "H_IMAGE_WIDTH"				/* asynInt32  ro */
-//#define hImageHeightString		    	"H_IMAGE_HEIGHT"			/* asynInt32  ro */	
-#define hImageRowBytesString			"H_IMAGE_ROWBYTES"			/* asynInt32  ro */
-#define hImageFrameBytesString			"H_IMAGE_FRAMEBYTES"		/* asynInt32  ro */
-#define hImageTopOffsetBytesString		"H_IMAGE_TOP_OFFSETBYTES"	/* asynInt32  ro */
-#define hImagePixelTypeString			"H_IMAGE_PIXEL_TYPE"		/* asynInt32  rw */
-#define hBufferRowbytesString			"H_BUFFER_ROWBYTES"			/* asynInt32  ro */
-#define hBufferFramebytesString			"H_BUFFER_FRAMEBYTES"		/* asynInt32  ro */
-#define hBufferTopOffsetBytesString		"H_BUFFER_TOP_OFFSETBYTES"	/* asynInt32  ro */
-#define hBufferPixelTypeString			"H_BUFFER_PIXEL_TYPE"		/* asynInt32  ro */
-#define hRecordFixedBytesPerFileString	"H_RECORD_FIXED_BYTES_PER_FILE"		/* asynInt32  ro */
-#define hRecordFixedBytesPerSessionString	"H_RECORD_FIXED_BYTES_PER_SESION"	/* asynInt32  ro */
-#define hRecordFixedBytesPerFrameString	"H_RECORD_FIXED_BYTES_PER_FRAME"	/* asynInt32  ro */
-#define hSystemAliveString			    "H_SYSTEM_ALIVE"			/* asynInt32  ro */
-#define hConversionFactorCoeffString	"H_CONVERSION_FACTOR_COEF"	/* asynFloat64  ro */
-#define hConversionFactorOffsetString	"H_CONVERSION_FACTOR_OFFSET"/* asynFloat64  ro */
-#define hNumberOfViewString			    "H_NUMBER_OF_VIEW"			/* asynInt32  ro */
-#define hImageDetectorPixelWidthString	"H_IMAGE_DETECTOR_PIXEL_WIDTH"		/* asynFloat64  ro */
-#define hImageDetectorPixelHeightString	"H_IMAGE_DETECTOR_PIXEL_HEIGHT"		/* asynFloat64  ro */
-#define hImageDetectorPixelNumHorzString "H_IMAGE_DETECTOR_PIXEL_NUM_HORZ"	/* asynInt32  ro */
-#define hImageDetectorPixelNumVertString "H_IMAGE_DETECTOR_PIXEL_NUM_VERT"	/* asynInt32  ro */
-#define hTimeStampProducerString         "H_TIMESTAMP_PRODUCER"	            /* asynInt32  ro */
-#define hFrameStampProducerString        "H_FRAMESTAMP_PRODUCER"	        /* asynInt32  ro */
+#define hColorTypeString		          "H_COLOR_TYPE"		    	    /* asynInt32  ro */
+#define hBitPerChannelString			  "H_BIT_PER_CHANNEL"               /* asynInt32  rw */
+//#define hImageWidthString			      "H_IMAGE_WIDTH"				    /* asynInt32  ro */
+//#define hImageHeightString		   	  "H_IMAGE_HEIGHT"			        /* asynInt32  ro */	
+#define hImageRowBytesString			  "H_IMAGE_ROWBYTES"			    /* asynInt32  ro */
+#define hImageFrameBytesString			  "H_IMAGE_FRAMEBYTES"		        /* asynInt32  ro */
+#define hImageTopOffsetBytesString		  "H_IMAGE_TOP_OFFSETBYTES"	        /* asynInt32  ro */
+#define hImagePixelTypeString			  "H_IMAGE_PIXEL_TYPE"		        /* asynInt32  rw */
+#define hBufferRowbytesString			  "H_BUFFER_ROWBYTES"			    /* asynInt32  ro */
+#define hBufferFramebytesString			  "H_BUFFER_FRAMEBYTES"		        /* asynInt32  ro */
+#define hBufferTopOffsetBytesString		  "H_BUFFER_TOP_OFFSETBYTES"	    /* asynInt32  ro */
+#define hBufferPixelTypeString			  "H_BUFFER_PIXEL_TYPE"		        /* asynInt32  ro */
+#define hRecordFixedBytesPerFileString	  "H_RECORD_FIXED_BYTES_PER_FILE"	/* asynInt32  ro */
+#define hRecordFixedBytesPerSessionString "H_RECORD_FIXED_BYTES_PER_SESION" /* asynInt32  ro */
+#define hRecordFixedBytesPerFrameString	  "H_RECORD_FIXED_BYTES_PER_FRAME"	/* asynInt32  ro */
+#define hSystemAliveString			      "H_SYSTEM_ALIVE"			        /* asynInt32  ro */
+#define hConversionFactorCoeffString	  "H_CONVERSIONFACTOR_COEFF"	     /* asynFloat64  ro */
+#define hConversionFactorOffsetString	  "H_CONVERSIONFACTOR_OFFSET"       /* asynFloat64  ro */
+#define hNumberOfViewString			      "H_NUMBER_OF_VIEW"			    /* asynInt32  ro */
+#define hImageDetectorPixelWidthString	  "H_IMAGE_DETECTOR_PIXEL_WIDTH"	/* asynFloat64  ro */
+#define hImageDetectorPixelHeightString	  "H_IMAGE_DETECTOR_PIXEL_HEIGHT"	/* asynFloat64  ro */
+#define hImageDetectorPixelNumHorzString  "H_IMAGE_DETECTOR_PIXEL_NUM_HORZ"	/* asynInt32  ro */
+#define hImageDetectorPixelNumVertString  "H_IMAGE_DETECTOR_PIXEL_NUM_VERT"	/* asynInt32  ro */
+#define hTimeStampProducerString          "H_TIMESTAMP_PRODUCER"	        /* asynInt32  ro */
+#define hFrameStampProducerString         "H_FRAMESTAMP_PRODUCER"	        /* asynInt32  ro */
 #define hTimeStampString                  "H_TIMESTAMP"	                    /* asynFloat64  ro */
 
 // For some reason these two addresses are not defined in the dcamapi4 neither in dcamprop.h