diff --git a/ADHamaApp/Db/hama.template b/ADHamaApp/Db/hama.template
index 6a683be..ee2f2d0 100644
--- a/ADHamaApp/Db/hama.template
+++ b/ADHamaApp/Db/hama.template
@@ -102,49 +102,42 @@ record(longin, "$(P)$(R)ArrayCounter_RBV")
 ##########################################################################
 record(stringin, "$(P)$(R)Vendor-RB"){
    field(DESC, "")
-   field(PINI, "YES")
    field(DTYP, "asynOctetRead")
    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_VENDOR")
 }
 
 record(stringin, "$(P)$(R)Model-RB"){
    field(DESC, "")
-   field(PINI, "YES")
    field(DTYP, "asynOctetRead")
    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_MODEL")
 }
 
 record(stringin, "$(P)$(R)CameraID-RB"){
    field(DESC, "")
-   field(PINI, "YES")
    field(DTYP, "asynOctetRead")
    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_CAMERAID")
 }
 
 record(stringin, "$(P)$(R)Bus-RB"){
    field(DESC, "")
-   field(PINI, "YES")
    field(DTYP, "asynOctetRead")
    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_BUS")
 }
 
 record(stringin, "$(P)$(R)CameraVersion-RB"){
    field(DESC, "")
-   field(PINI, "YES")
    field(DTYP, "asynOctetRead")
    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_CAMERA_VERSION")
 }
 
 record(stringin, "$(P)$(R)DriverVersion-RB"){
    field(DESC, "")
-   field(PINI, "YES")
    field(DTYP, "asynOctetRead")
    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_DRIVER_VERSION")
 }
 
 record(stringin, "$(P)$(R)ModuleVersion-RB"){
    field(DESC, "")
-   field(PINI, "YES")
    field(DTYP, "asynOctetRead")
    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_MODULE_VERSION")
 }
@@ -466,8 +459,9 @@ record(mbbi, "$(P)$(R)InternalTriggerHandling-RB") {
 record(ai, "$(P)$(R)Temperature-R") {
    field(DESC, "")
    field(DTYP, "asynFloat64")
-   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_SENSOR_COOLER_STATUS")
+   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_SENSOR_TEMPERATURE")
    field(SCAN, "I/O Intr")
+   field(TPRO, "1")
 }
 
 record(mbbo, "$(P)$(R)Cooler-S") {
@@ -1028,7 +1022,7 @@ record(ai, "$(P)$(R)TimingReadoutTime-RB") {
 record(ai, "$(P)$(R)TimingCyclicTriggerPeriod-RB") {
    field(DESC, "")
    field(DTYP, "asynFloat64")
-   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TIMING_CYCLING_TRIGGER_PERIOD")  
+   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TIMING_CYCLICTRIGGERPERIOD")  
    field(EGU,  "Sec")
    field(SCAN, "I/O Intr")
 }
@@ -1038,7 +1032,7 @@ record(ai, "$(P)$(R)TimingCyclicTriggerPeriod-RB") {
 record(ai, "$(P)$(R)TimingMinTriggerBlanking-RB") {
    field(DESC, "")
    field(DTYP, "asynFloat64")
-   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H__TIMING_MIN_TRIGGER_BLANKING")  
+   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TIMING_MIN_TRIGGER_BLANKING")  
    field(EGU,  "Sec")
    field(SCAN, "I/O Intr")
 }
@@ -1048,7 +1042,7 @@ record(ai, "$(P)$(R)TimingMinTriggerBlanking-RB") {
 record(ai, "$(P)$(R)TimingMinTriggerInterval-RB") {
    field(DESC, "")
    field(DTYP, "asynFloat64")
-   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H__TIMING_MIN_TRIGGER_INTERVAL")  
+   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TIMING_MIN_TRIGGER_INTERVAL")  
    field(EGU,  "Sec")
    field(SCAN, "I/O Intr")
 }
@@ -1058,7 +1052,7 @@ record(ai, "$(P)$(R)TimingMinTriggerInterval-RB") {
 record(ai, "$(P)$(R)TimingGlobalExposureDelay-RB") {
    field(DESC, "")
    field(DTYP, "asynFloat64")
-   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H__TIMING_MIN_TRIGGER_INTERVAL")  
+   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TIMING_MIN_TRIGGER_INTERVAL")  
    field(EGU,  "Sec")
    field(SCAN, "I/O Intr")
 }
@@ -1081,14 +1075,14 @@ record(ao, "$(P)$(R)InternalFrameRate-S") {
    field(DTYP, "asynFloat64")
    field(DRVL, "20.035817413")
    field(DRVH, "49.865614232")
-   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_H_INTERNAL_FRAME_RATE")  
+   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_INTERNAL_FRAME_RATE")  
    field(EGU,  "Hz")
 }
 
 record(ai, "$(P)$(R)InternalFrameRate-RB") {
    field(DESC, "")
    field(DTYP, "asynFloat64")
-   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_H_INTERNAL_FRAME_RATE")  
+   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_INTERNAL_FRAME_RATE")  
    field(EGU,  "Hz")
    field(SCAN, "I/O Intr")
 }
@@ -1366,140 +1360,3 @@ record(mbbi, "$(P)$(R)FrameStampProd-R") {
    field(SCAN, "I/O Intr")
 }
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-# (mode)
-#record(ao, "$(P)$(R)") {
-#   field(DESC,"")
-#   field(PINI, "YES")
-#   field(DTYP, "asynInt32")
-#   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))")  
-#   field(VAL,  "1")
-#}
-#
-#record(ai, "$(P)$(R)") {
-#   field(DESC,"")
-#   field(DTYP, "asynInt32")
-#   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))")
-#   field(SCAN, "I/O Intr")
-#}
-
-#
-#"H_SENSOR_TEMPERATURE"		/* asynFloat64 ro */
-#"H_SENSOR_COOLER"		    /* asynInt32  rw */
-#"H_SENSOR_COOLER_STATUS"	/* asynInt32  ro */
-#
-#
-#BINNING"			        /* asynInt32  rw */
-#"H_SUBARRAY_HPOST"	        /* asynInt32  rw */
-#_SUBARRAY_HSIZE"		    /* asynInt32  rw */
-#"H_SUBARRAY_VPOS"		    /* asynInt32  rw */
-#_SUBARRAY_VPOS"		        /* asynInt32  rw */
-#"H_SUBARRAY_MODE"		    /* asynInt32  rw */
-#b3 only not implemented) 
-#b3 only not implemented)
-#
-#
-#"H_EXPOSURE_TIME"	    	    /* asynFloat64  rw */
-#
-#
-#"H_DEFECT_CORRECT_MODE"		    /* asynInt32  rw */
-#"H_HOT_PIXEL_CORRECT_LEVEL" 	/* asynInt32  rw */
-#"H_INTENSITY_LUT_MODE"  		/* asynInt32  rw */
-#"H_INTENSITY_LUT_PAGE"  		/* asynInt32  ro */
-#H_EXTRACTION_MODE"	    	    /* asynInt32  ro */
-#
-#
-#"H_NUMBER_OUTPUT_TRIGGER_CONNECTORS"/* asynInt3
-#"H_OUTPUT_TRIGGER_SOURCE0"		    /* asynInt32  rw */
-#"H_OUTPUT_TRIGGER_SOURCE1"		    /* asynInt32  rw */
-#"H_OUTPUT_TRIGGER_SOURCE2"		    /* asynInt32  rw */
-#"H_OUTPUT_TRIGGER_POLARITY0"	    /* asynInt32  rw */
-#"H_OUTPUT_TRIGGER_POLARITY1"	    /* asynInt32  rw */
-#"H_OUTPUT_TRIGGER_POLARITY2"    	/* asynInt32  rw */
-#"H_OUTPUT_TRIGGER_ACTIVE0"  		/* asynInt32  ro */
-#"H_OUTPUT_TRIGGER_ACTIVE1"  		/* asynInt32  ro */
-#"H_OUTPUT_TRIGGER_ACTIVE2"  		/* asynInt32  ro */	
-#"H_OUTPUT_TRIGGER_DELAY0"	    	/* asynFloat64  rw */
-#"H_OUTPUT_TRIGGER_DELAY1"	    	/* asynFloat64  rw */
-#"H_OUTPUT_TRIGGER_DELAY2"	    	/* asynFloat64  rw */
-#"H_OUTPUT_TRIGGER_PERIOD0"  		/* asynFloat64  rw */
-#"H_OUTPUT_TRIGGER_PERIOD1"  		/* asynFloat64  rw */
-#"H_OUTPUT_TRIGGER_PERIOD2"  		/* asynFloat64  rw */
-#"H_OUTPUT_TRIGGER_KIND0"		    /* asynInt32  rw */
-#"H_OUTPUT_TRIGGER_KIND1"		    /* asynInt32  rw */
-#"H_OUTPUT_TRIGGER_KIND2"		    /* asynInt32  rw */	
-#"H_OUTPUT_TRIGGER_BASE_SENSOR0"	    /* asynInt32  rw */
-#"H_OUTPUT_TRIGGER_BASE_SENSOR1"	    /* asynInt32  rw */
-#"H_OUTPUT_TRIGGER_BASE_SENSOR2"	    /* asynInt32  rw */
-#"H_OUTPUT_TRIGGER_PRE_HSYNC_COUNT"	/* asynInt32  rw */	
-#
-#
-#"H_MASTERPULSE_MODE"			    /* asynInt32  rw */
-#"H_MASTERPULSE_TRIGGER_SOURCE"		/* asynInt32  rw */
-#"H_MASTERPULSE_INTERVAL"		    /* asynFloat64  rw */
-#"H_MASTERPULSE_BURST_TIMES"		    /* asynInt32  rw */
-#
-#
-#"H_TIMING_READOUT_TIME"			    /* asynFloat64  ro */
-#"H_TIMING_CYCLIC_TRIGGER_PERIOD"	/* asynFloat64  ro */
-#"H_TIMING_MIN_TRIGGER_BLANKING"		/* asynFloat64  ro */
-#"H_TIMING_MIN_TRIGGER_INTERVAL"		/* asynFloat64  ro */
-#"H_TIMING_GLOBAL_EXPOSURE_DELAY"	/* asynFloat64  ro */
-#"H_TIMING_EXPOSURE"			        /* asynInt32  ro */
-#"H_TIMING_INVALID_EXPOSURE_PERIOD"	/* asynFloat64  r
-#"H_INTERNAL_FRAME_RATE"		        /* asynFloat64  rw */
-#"H_INTERNAL_FRAME_INTERVAL"	        /* asynFloat64  rw */
-#"H_INTERNAL_LINE_SPEED"		        /* asynFloat64  rw */
-#"H_INTERNAL_LINE_INTERVAL"          /* asynFloat64  rw */
-#
-#
-#"H_COLOR_TYPE"		              	/* asynInt32  ro */
-#"H_BIT_PER_CHANNEL                  /* asynInt32  rw */
-#"H_IMAGE_WIDTH"				        /* asynInt32  ro */
-#"H_IMAGE_HEIGHT"			        /* asynInt32  ro */	
-#"H_IMAGE_ROWBYTES"	        		/* asynInt32  ro */
-#"H_IMAGE_FRAMEBYTES"        		/* asynInt32  ro */
-#"H_IMAGE_TOP_OFFSETBYTES"       	/* asynInt32  ro */
-#"H_IMAGE_PIXEL_TYPE"		        /* asynInt32  rw */
-#"H_BUFFER_ROWBYTES"		        	/* asynInt32  ro */
-#"H_BUFFER_FRAMEBYTES"	        	/* asynInt32  ro */
-#"H_BUFFER_TOP_OFFSETBYTES"      	/* asynInt32  ro */
-#"H_BUFFER_PIXEL_TYPE"		        /* asynInt32  ro */
-#"H_RECORD_FIXED_BYTES_PER_FILE"		/* asynInt32  ro */
-#"H_RECORD_FIXED_BYTES_PER_SESION"	/* asynInt32  ro */
-#"H_RECORD_FIXED_BYTES_PER_FRAME"	/* asynInt32  ro */
-#"H_SYSTEM_ALIVE"			        /* asynInt32  ro */
-#"H_CONVERSION_FACTOR_COEF"	        /* asynFloat64  ro */
-#"H_CONVERSION_FACTOR_OFFSET"        /* asynFloat64  ro */
-#"H_NUMBER_OF_VIEW"			        /* asynInt32  ro */
-#"H_IMAGE_DETECTOR_PIXEL_WIDTH"		/* asynFloat64  ro */
-#"H_IMAGE_DETECTOR_PIXEL_HEIGHT"		/* asynFloat64  ro */
-#"H_IMAGE_DETECTOR_PIXEL_NUM_HORZ"	/* asynInt32  ro */
-#"H_IMAGE_DETECTOR_PIXEL_NUM_VERT"	/* asynInt32  ro */
\ No newline at end of file
diff --git a/ADHamaApp/src/hama.cpp b/ADHamaApp/src/hama.cpp
index 3ef1ffb..868bff7 100644
--- a/ADHamaApp/src/hama.cpp
+++ b/ADHamaApp/src/hama.cpp
@@ -22,6 +22,16 @@
 
 static const char *driverName="drvHama";
 
+static void c_imagetask(void *arg) {
+  Hama *p = (Hama *)arg;
+  p->imageTask();
+}
+
+static void c_temperaturetask(void *arg) {
+  Hama *p = (Hama *)arg;
+  p->temperatureTask();
+}
+
 
 //============================================================================
 Hama::Hama(const char* portName, int cameraId, int maxBuffers, size_t maxMemory, 
@@ -36,7 +46,7 @@ Hama::Hama(const char* portName, int cameraId, int maxBuffers, size_t maxMemory,
     printf("[DEBUG] === Constructor ADHama ===\n");
     printf("[DEBUG]     driverName: %s\n", driverName);
 
-
+    stopThread = 0;
 //General
 
     createParam( HamaName,                      asynParamOctet,      &hHamaName);
@@ -86,6 +96,7 @@ Hama::Hama(const char* portName, int cameraId, int maxBuffers, size_t maxMemory,
     createParam( hHotPixelCorrectLevelString,   asynParamInt32,   &hHotPixelCorrectLevel);
     createParam( hIntensityLutModeString,       asynParamInt32,   &hIntensityLutMode);
     createParam( hIntensityLutPageString,       asynParamInt32,   &hIntensityLutPage);
+    createParam( hExtractionModeString,         asynParamInt32,   &hExtractionMode);
 
 //output trigger
     createParam( hNrOutputTriggerConnectorsString, asynParamInt32, &hNrOutputTriggerConnectors); 
@@ -113,9 +124,25 @@ Hama::Hama(const char* portName, int cameraId, int maxBuffers, size_t maxMemory,
     createParam( hOutTriggerPreHsyncCountString,  asynParamInt32,   &hOutTriggerPreHsyncCount);
  
 //Master Puls
+    createParam( hMasterPulseModeString,          asynParamInt32,   &hMasterPulseMode);
+    createParam( hMasterPulseTriggerSourceString, asynParamInt32,   &hMasterPulseTriggerSource);
+    createParam( hMasterPulseIntervalString,      asynParamFloat64, &hMasterPulseInterval);
+    createParam( hMasterPulseBurstTimesString,    asynParamInt32,   &hMasterPulseBurstTimes);
+    
 //Synchronious Timing
-//System Information
+    createParam( hTimingReadoutTimeString,           asynParamFloat64, &hTimingReadoutTime);
+    createParam( hTimingCyclicTriggerPeriodString,   asynParamFloat64, &hTimingCyclicTriggerPeriod);
+    createParam( hTimingMinTriggerBlankingString,    asynParamFloat64, &hTimingMinTriggerBlanking);
+    createParam( hTimingMinTriggerIntervalString,    asynParamFloat64, &hTimingMinTriggerInterval);
+    createParam( hTimingGlobalExposureDelayString,   asynParamFloat64, &hTimingGlobalExposureDelay);
+    createParam( hTimingExposureString,              asynParamInt32,   &hTimingExposure);
+    createParam( hTimingInvalidExposurePeriodString, asynParamFloat64, &hTimingInvalidExposurePeriod);
+    createParam( hInternalFrameRateString,           asynParamFloat64, &hInternalFrameRate);
+    createParam( hInternalFrameIntervalString,       asynParamFloat64, &hInternalFrameInterval);
+    createParam( hInternalLineSpeedString,           asynParamFloat64, &hInternalLineSpeed);
+    createParam( hInternalLineIntervalString,        asynParamFloat64, &hInternalLineInterval);
 
+//System Information
     createParam( hColorTypeString,                  asynParamInt32,   &hColorType);		 
     createParam( hBitPerChannelString,              asynParamInt32,   &hBitPerChannel);
     createParam( hImageWidthString,                 asynParamInt32,   &hImageWidth);			
@@ -146,9 +173,9 @@ Hama::Hama(const char* portName, int cameraId, int maxBuffers, size_t maxMemory,
 
    connectCamera();
 
-/*
    int err = 0;
    
+/*
    err |= getParameter(DCAM_IDPROP_SENSORMODE); 
    err |= getParameter(DCAM_IDPROP_READOUTSPEED); 
    err |= getParameter(DCAM_IDPROP_READOUT_DIRECTION); 
@@ -161,6 +188,8 @@ Hama::Hama(const char* portName, int cameraId, int maxBuffers, size_t maxMemory,
    err |= getParameter(DCAM_IDPROP_TRIGGERTIMES); 
    err |= getParameter(DCAM_IDPROP_TRIGGERDELAY); 
    err |= getParameter(DCAM_IDPROP_INTERNALTRIGGER_HANDLING); 
+   */
+
 
    err |= getParameterStr(DCAM_IDSTR_VENDOR); 
    err |= getParameterStr(DCAM_IDSTR_MODEL); 
@@ -170,9 +199,26 @@ Hama::Hama(const char* portName, int cameraId, int maxBuffers, size_t maxMemory,
    err |= getParameterStr(DCAM_IDSTR_DRIVERVERSION); 
    err |= getParameterStr(DCAM_IDSTR_MODULEVERSION); 
    err |= getParameterStr(DCAM_IDSTR_DCAMAPIVERSION); 
+   
+   if(err){
+      printf("[DEBUG] Error = %d\n", err);
+   }
+
+   /* launch image read task */
+   epicsThreadCreate("HamaImageTask", 
+                      epicsThreadPriorityMedium,
+                      epicsThreadGetStackSize(epicsThreadStackMedium),
+                      c_imagetask, this);
+
+   /* launch temp read task */
+   epicsThreadCreate("HamaTemperatureTask", 
+                      epicsThreadPriorityMedium,
+                      epicsThreadGetStackSize(epicsThreadStackMedium),
+                      c_temperaturetask, this);
+
+   /* shutdown on exit */
+   //epicsAtExit(c_shutdown, this);
 
-   printf("[DEBUG] Error = %d\n", err);
-   */
    printf("[DEBUG] === END Constructor ADHama ===\n");
 }
 //============================================================================
@@ -402,6 +448,36 @@ int Hama::getProperties(){
 return 0;   
 }
 //============================================================================
+void Hama::imageTask(){
+
+
+}
+//============================================================================
+void Hama::temperatureTask(){
+   static const char *functionName = "tempTask";
+   asynStatus  status = asynSuccess;
+   double value = 0;
+
+   while( !stopThread ) {
+      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SENSORTEMPERATURE, &value);
+
+      if(m_err != DCAMERR_SUCCESS){
+         asynPrint(pasynUserSelf, ASYN_TRACE_ERROR,
+                "%s:%s: temperature read error = %d\n", 
+                driverName, functionName, m_err);
+      }
+      else{
+        setDoubleParam(hSensorTemperature, value);
+        //printf("Temperature = %f\n",value);
+      }
+
+      status = (asynStatus) callParamCallbacks();
+      epicsThreadSleep(1.0);
+
+   }
+
+}
+//============================================================================
 
 asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value){
 
diff --git a/ADHamaApp/src/hama.h b/ADHamaApp/src/hama.h
index b75ebf3..04269cd 100644
--- a/ADHamaApp/src/hama.h
+++ b/ADHamaApp/src/hama.h
@@ -52,7 +52,7 @@
 #define hExposureTimeString			    "H_EXPOSURE_TIME"		    /* asynFloat64  rw */
 
 // ALU
-#define hDefectCorrectModeString		"H_DEFECT_CORRECT_MODE"		/* asynInt32  rw */
+#define hDefectCorrectModeString		"H_DEFECTCORRECT_MODE"		/* asynInt32  rw */
 #define hHotPixelCorrectLevelString		"H_HOT_PIXEL_CORRECT_LEVEL"	/* asynInt32  rw */
 #define hIntensityLutModeString			"H_INTENSITY_LUT_MODE"		/* asynInt32  rw */
 #define hIntensityLutPageString			"H_INTENSITY_LUT_PAGE"		/* asynInt32  ro */
@@ -91,7 +91,7 @@
 
 // Synchronious Timing
 #define hTimingReadoutTimeString		"H_TIMING_READOUT_TIME"			/* asynFloat64  ro */
-#define hTimingCyclicTriggerPeriodString "H_TIMING_CYCLIC_TRIGGER_PERIOD"	/* asynFloat64  ro */
+#define hTimingCyclicTriggerPeriodString "H_TIMING_CYCLICTRIGGERPERIOD"	/* asynFloat64  ro */
 #define hTimingMinTriggerBlankingString	"H_TIMING_MIN_TRIGGER_BLANKING"		/* asynFloat64  ro */
 #define hTimingMinTriggerIntervalString	"H_TIMING_MIN_TRIGGER_INTERVAL"		/* asynFloat64  ro */
 #define hTimingGlobalExposureDelayString "H_TIMING_GLOBAL_EXPOSURE_DELAY"	/* asynFloat64  ro */
@@ -143,6 +143,8 @@ public:
     //virtual asynStatus readEnum(asynUser *pasynUser, char *strings[], int values[], 
     //        int severities[], size_t nElements, size_t *nIn);
     virtual void report(FILE *fp, int details);
+    void imageTask();
+    void temperatureTask();
 
 protected:
     int hFrameRate;
@@ -252,11 +254,12 @@ protected:
 private: 
 
     
-    HDCAM		m_hdcam;
+    HDCAM   		m_hdcam;
     DCAMAPI_INIT	m_apiInit;
     DCAMDEV_OPEN	m_devOpen;
     DCAMERR 		m_err;
-    int			m_id;
+    int	    		m_id;
+    int             stopThread;
 
     // wrapper functions for dcamapi
     int allocateBuffers(unsigned int);