#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <wchar.h>
#include <stdarg.h>

#include <epicsEvent.h>
#include <epicsTime.h>
#include <epicsThread.h>
#include <iocsh.h>
#include <epicsString.h>
#include <epicsExit.h>
#include <epicsExport.h>

#include "hama.h"
// --- includes from DCMAPI ----
#include "dcamprop.h"
//
#include <unistd.h>

#include <iostream>
using namespace std;

//#define NUM_HAMA_PARAMS ((int)(&LAST_HAMA_PARAM - &FIRST_HAMA_PARAM + 1))

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, 
           int priority, int stackSize, int maxFrames)
    : ADDriver(portName, 1, 0, maxBuffers, maxMemory,
               asynEnumMask, asynEnumMask, 
               ASYN_CANBLOCK,  /* ASYN_CANBLOCK=1 ASYN_MULTIDEVICE=0 */
               1,              /* autoConnect=1 */
               priority, stackSize),
    m_hdcam(NULL), m_id(0)
    
{
    const char *functionName = "hamaDetector::hamaDetector";

    printf("[DEBUG] === Constructor ADHama ===\n");
    printf("[DEBUG]     driverName: %s\n", driverName);

    stopThread = 0;

    /* Create the epicsEvents for signaling to task when acquisition starts and stops */
    startEvent_ = epicsEventCreate(epicsEventEmpty);
    if (!startEvent_) {
        printf("%s:%s epicsEventCreate failure for acquire start event\n",
            driverName, functionName);
        return;
    }

//General
    createParam( hFrameRateString,              asynParamFloat64,    &hFrameRate);
    createParam( hHamaNameString,               asynParamOctet,      &hHamaName);
    createParam( hVendorString,                 asynParamOctet,      &hVendor);
    createParam( hModelString,                  asynParamOctet,      &hModel);
    createParam( hCameraIDString,               asynParamOctet,      &hCameraID);
    createParam( hBusString,                    asynParamOctet,      &hBus);
    createParam( hCameraVersionString,          asynParamOctet,      &hCameraVersion);
    createParam( hDriverVersionString,          asynParamOctet,      &hDriverVersion);
    createParam( hModuleVersionString,          asynParamOctet,      &hModuleVersion);
    createParam( hDcamApiVersionString,         asynParamOctet,      &hDcamApiVersion);

//Sensor Mode and Speed
    createParam( hSensorModeString,             asynParamInt32,      &hSensorMode);	 			
    createParam( hReadoutSpeedString,           asynParamInt32,      &hReadoutSpeed);
    createParam( hReadoutDirectionString,       asynParamInt32,      &hReadoutDirection);

//Trigger
    createParam( hTriggerSourceString,           asynParamInt32,     &hTriggerSource);             
    createParam( hTriggerModeString,             asynParamInt32,     &hTriggerMode);             
    createParam( hTriggerActiveString,           asynParamInt32,     &hTriggerActive);          
    createParam( hTriggerGlobalExposureString,   asynParamInt32,     &hTriggerGlobalExposure);  
    createParam( hTriggerPolarityString,         asynParamInt32,     &hTriggerPolarity);        
    createParam( hTriggerConnectorString,        asynParamInt32,     &hTriggerConnector);       
    createParam( hTriggerTimesString,            asynParamInt32,     &hTriggerTimes);           
    createParam( hTriggerDelayString,            asynParamFloat64,   &hTriggerDelay);           
    createParam( hInternalTriggerHandlingString, asynParamInt32,     &hInternalTriggerHandling);  

//Sensor cooler
    createParam( hSensorTemperatureString,       asynParamFloat64,   &hSensorTemperature);
    createParam( hSensorCoolerString,            asynParamInt32,     &hSensorCooler);
    createParam( hSensorCoolerStatusString,      asynParamInt32,     &hSensorCoolerStatus);

//Binning and ROI
    createParam( hBinningString,                asynParamInt32,   &hBinning);
    createParam( hSubarrayHPosString,           asynParamInt32,   &hSubarrayHPos);
    createParam( hSubarrayHSizeString,          asynParamInt32,   &hSubarrayHSize);
    createParam( hSubarrayVPosString,           asynParamInt32,   &hSubarrayVPos);
    createParam( hSubarrayVSizeString,          asynParamInt32,   &hSubarrayVSize);
    createParam( hSubarrayModeString,           asynParamInt32,   &hSubarrayMode);

//Feature
    createParam( hExposureTimeString,           asynParamFloat64, &hExposureTime);

//ALU
    createParam( hDefectCorrectModeString,      asynParamInt32,   &hDefectCorrectMode); 
    createParam( hHotPixelCorrectLevelString,   asynParamInt32,   &hHotPixelCorrectLevel);
    createParam( hIntensityLutModeString,       asynParamInt32,   &hIntensityLutMode);
    createParam( hIntensityLutPageString,       asynParamInt32,   &hIntensityLutPage);
    createParam( hExtractionModeString,         asynParamInt32,   &hExtractionMode);

//output trigger
    createParam( hNumberOfOutputTriggerConnectorString, asynParamInt32, &hNumberOfOutputTriggerConnector); 
    createParam( hOutputTriggerSource0String,     asynParamInt32,   &hOutputTriggerSource0), 	  
    createParam( hOutputTriggerSource1String,     asynParamInt32,   &hOutputTriggerSource1); 	  
    createParam( hOutputTriggerSource2String,     asynParamInt32,   &hOutputTriggerSource2);	   
    createParam( hOutputTriggerPolarity0String,   asynParamInt32,   &hOutputTriggerPolarity0);
    createParam( hOutputTriggerPolarity1String,   asynParamInt32,   &hOutputTriggerPolarity1);
    createParam( hOutputTriggerPolarity2String,   asynParamInt32,   &hOutputTriggerPolarity2);
    createParam( hOutputTriggerActive0String,     asynParamInt32,   &hOutputTriggerActive0); 	
    createParam( hOutputTriggerActive1String,     asynParamInt32,   &hOutputTriggerActive1);	 
    createParam( hOutputTriggerActive2String,     asynParamInt32,   &hOutputTriggerActive2);	 
    createParam( hOutputTriggerDelay0String,      asynParamFloat64, &hOutputTriggerDelay0);		
    createParam( hOutputTriggerDelay1String,      asynParamFloat64, &hOutputTriggerDelay1);	 
    createParam( hOutputTriggerDelay2String,      asynParamFloat64, &hOutputTriggerDelay2);	 
    createParam( hOutputTriggerPeriod0String,     asynParamFloat64, &hOutputTriggerPeriod0);
    createParam( hOutputTriggerPeriod1String,     asynParamFloat64, &hOutputTriggerPeriod1);
    createParam( hOutputTriggerPeriod2String,     asynParamFloat64, &hOutputTriggerPeriod2);
    createParam( hOutputTriggerKind0String,       asynParamInt32,   &hOutputTriggerKind0);
    createParam( hOutputTriggerKind1String,       asynParamInt32,   &hOutputTriggerKind1);
    createParam( hOutputTriggerKind2String,       asynParamInt32,   &hOutputTriggerKind2);
    createParam( hOutputTriggerBaseSensor0String, asynParamInt32,   &hOutputTriggerBaseSensor0); 
    createParam( hOutputTriggerBaseSensor1String, asynParamInt32,   &hOutputTriggerBaseSensor1); 
    createParam( hOutputTriggerBaseSensor2String, asynParamInt32,   &hOutputTriggerBaseSensor2); 
    createParam( hOutputTriggerPreHsyncCountString, asynParamInt32, &hOutputTriggerPreHsyncCount);
 
//Master Puls
    createParam( hMasterPulseModeString,          asynParamInt32,   &hMasterPulseMode);
    createParam( hMasterPulseTriggerSourceString, asynParamInt32,   &hMasterPulseTriggerSource);
    createParam( hMasterPulseIntervalString,      asynParamFloat64, &hMasterPulseInterval);
    createParam( hMasterPulseBurstTimesString,    asynParamInt32,   &hMasterPulseBurstTimes);
    
//Synchronious Timing
    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);			
    //createParam( hImageHeightString,                asynParamInt32,   &hImageHeight);		
    createParam( hImageRowBytesString,              asynParamInt32,   &hImageRowbytes);	
    createParam( hImageFrameBytesString,            asynParamInt32,   &hImageFramebytes);
    createParam( hImageTopOffsetBytesString,        asynParamInt32,   &hImageTopOffsetBytes);	
    createParam( hImagePixelTypeString,             asynParamInt32,   &hImagePixelType);		
    createParam( hBufferRowbytesString,             asynParamInt32,   &hBufferRowbytes);		
    createParam( hBufferFramebytesString,           asynParamInt32,   &hBufferFramebytes);	
    createParam( hBufferTopOffsetBytesString,       asynParamInt32,   &hBufferTopOffsetBytes);
    createParam( hBufferPixelTypeString,            asynParamInt32,   &hBufferPixelType);	
    createParam( hRecordFixedBytesPerFileString,    asynParamInt32,   &hRecordFixedBytesPerFile);
    createParam( hRecordFixedBytesPerSessionString, asynParamInt32,   &hRecordFixedBytesPerSession);	
    createParam( hRecordFixedBytesPerFrameString,   asynParamInt32,   &hRecordFixedBytesPerFrame);
    createParam( hSystemAliveString,                asynParamInt32,   &hSystemAlive);			  
    createParam( hConversionFactorCoeffString,      asynParamFloat64, &hConversionFactorCoeff);
    createParam( hConversionFactorOffsetString,     asynParamFloat64, &hConversionFactorOffset);
    createParam( hNumberOfViewString,               asynParamInt32,   &hNumberOfView);			  
    createParam( hImageDetectorPixelWidthString,    asynParamFloat64, &hImageDetectorPixelWidth);
    createParam( hImageDetectorPixelHeightString,   asynParamFloat64, &hImageDetectorPixelHeight); 
    createParam( hImageDetectorPixelNumHorzString,  asynParamInt32,   &hImageDetectorPixelNumHorz);
    createParam( hImageDetectorPixelNumVertString,  asynParamInt32,   &hImageDetectorPixelNumVert);
    createParam( hTimeStampProducerString,          asynParamInt32,   &hTimeStampProducer);
    createParam( hFrameStampProducerString,         asynParamInt32,   &hFrameStampProducer);
    createParam( hTimeStampString,                  asynParamFloat64, &hTimeStamp);


    setIntegerParam(NDArrayCallbacks, 1);
    callParamCallbacks();

   connectCamera();
   printf("\n\n============================ Init Camera =========================\n");
   initCamera();

   printf("\n\n============================ Start Threads =======================\n");
   /* 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("\n\n=== END Constructor ADHama ===\n");
   printf("===================================================================\n");
}
//============================================================================
//Hama::~Hama(){
//    // not sure if the destructor has to be define here...
//    printf("[DEBUG] === Destructor ADHama ===\n");
//}

//========================================================================================================
int Hama::initCamera(){

   int err = 0;

   err |= readParameterStr(DCAM_IDSTR_VENDOR); 
   err |= readParameterStr(DCAM_IDSTR_MODEL); 
   err |= readParameterStr(DCAM_IDSTR_CAMERAID); 
   err |= readParameterStr(DCAM_IDSTR_BUS); 
   err |= readParameterStr(DCAM_IDSTR_CAMERAVERSION); 
   err |= readParameterStr(DCAM_IDSTR_DRIVERVERSION); 
   err |= readParameterStr(DCAM_IDSTR_MODULEVERSION); 
   err |= readParameterStr(DCAM_IDSTR_DCAMAPIVERSION); 

   // SENSOR MODE AND SPEED ------------------------
   err |= readParameter(DCAM_IDPROP_SENSORMODE);
   err |= readParameter(DCAM_IDPROP_READOUTSPEED);
   err |= readParameter(DCAM_IDPROP_READOUT_DIRECTION);

   // TRIGGER --------------------------------------
   err |= readParameter(DCAM_IDPROP_TRIGGERSOURCE);
   err |= readParameter(DCAM_IDPROP_TRIGGER_MODE);
   err |= readParameter(DCAM_IDPROP_TRIGGERACTIVE);
   err |= readParameter(DCAM_IDPROP_TRIGGER_GLOBALEXPOSURE);
   err |= readParameter(DCAM_IDPROP_TRIGGERPOLARITY);
   err |= readParameter(DCAM_IDPROP_TRIGGER_CONNECTOR);
   err |= readParameter(DCAM_IDPROP_TRIGGERTIMES);
   err |= readParameter(DCAM_IDPROP_TRIGGERDELAY);
   err |= readParameter(DCAM_IDPROP_INTERNALTRIGGER_HANDLING);

   // BINNING AND ROI ------------------------------
	err |= readParameter( DCAM_IDPROP_BINNING);
	err |= readParameter( DCAM_IDPROP_SUBARRAYHPOS);
	err |= readParameter( DCAM_IDPROP_SUBARRAYVPOS);
	err |= readParameter( DCAM_IDPROP_SUBARRAYHSIZE);
	err |= readParameter( DCAM_IDPROP_SUBARRAYVSIZE);
	err |= readParameter( DCAM_IDPROP_IMAGE_FRAMEBYTES);
   err |= readParameter( DCAM_IDPROP_IMAGE_PIXELTYPE);
	err |= readParameter( DCAM_IDPROP_IMAGE_WIDTH);
	err |= readParameter( DCAM_IDPROP_IMAGE_ROWBYTES);
	err |= readParameter( DCAM_IDPROP_IMAGE_HEIGHT);

   // SUBARRAYMODE ------------------------------------------
   
   // FEATURE -----------------------------------------------
   
   // EXPOSURETIME ------------------------------------------

   // ALU ---------------------------------------------------
	err |= readParameter( DCAM_IDPROP_DEFECTCORRECT_MODE);
	err |= readParameter( DCAM_IDPROP_HOTPIXELCORRECT_LEVEL);
	err |= readParameter( DCAM_IDPROP_INTENSITYLUT_MODE);
	err |= readParameter( DCAM_IDPROP_INTENSITYLUT_PAGE);
	err |= readParameter( DCAM_IDPROP_EXTRACTION_MODE);

   // OUTPUT TRIGGER ---------------------------------------- 
   err |= readParameter(DCAM_IDPROP_OUTPUTTRIGGER_ACTIVE);
   err |= readParameter(DCAM_IDPROP_NUMBEROF_OUTPUTTRIGGERCONNECTOR);
   // MASTER PULSE ------------------------------------------ 
   // SYNCHRONOUS TIMING ------------------------------------ 

   err |= readParameter( DCAM_IDPROP_TIMING_READOUTTIME);
   err |= readParameter( DCAM_IDPROP_TIMING_CYCLICTRIGGERPERIOD);
   err |= readParameter( DCAM_IDPROP_TIMING_MINTRIGGERBLANKING);
   err |= readParameter( DCAM_IDPROP_TIMING_MINTRIGGERINTERVAL);
   err |= readParameter( DCAM_IDPROP_TIMING_GLOBALEXPOSUREDELAY);
   err |= readParameter( DCAM_IDPROP_TIMING_EXPOSURE);
   err |= readParameter( DCAM_IDPROP_TIMING_INVALIDEXPOSUREPERIOD);
   err |= readParameter( DCAM_IDPROP_INTERNALFRAMERATE);
   err |= readParameter( DCAM_IDPROP_INTERNAL_FRAMEINTERVAL);
   err |= readParameter( DCAM_IDPROP_INTERNALLINESPEED);
   err |= readParameter( DCAM_IDPROP_INTERNAL_LINEINTERVAL);

   // SYSTEM INFORMATION ------------------------------------ 
   err |= readParameter(DCAM_IDPROP_COLORTYPE);
   err |= readParameter(DCAM_IDPROP_BITSPERCHANNEL);
   err |= readParameter(DCAM_IDPROP_IMAGE_TOPOFFSETBYTES);
   err |= readParameter(DCAM_IDPROP_BUFFER_ROWBYTES);
   err |= readParameter(DCAM_IDPROP_BUFFER_FRAMEBYTES);
   err |= readParameter(DCAM_IDPROP_BUFFER_TOPOFFSETBYTES);
   err |= readParameter(DCAM_IDPROP_BUFFER_PIXELTYPE);
   err |= readParameter(DCAM_IDPROP_RECORDFIXEDBYTES_PERFILE);
   err |= readParameter(DCAM_IDPROP_RECORDFIXEDBYTES_PERSESSION);
   err |= readParameter(DCAM_IDPROP_RECORDFIXEDBYTES_PERFRAME);
   err |= readParameter(DCAM_IDPROP_SYSTEM_ALIVE);
   err |= readParameter(DCAM_IDPROP_CONVERSIONFACTOR_COEFF);
   err |= readParameter(DCAM_IDPROP_CONVERSIONFACTOR_OFFSET);
   err |= readParameter(DCAM_IDPROP_NUMBEROF_VIEW);
   err |= readParameter(DCAM_IDPROP_TIMESTAMP_PRODUCER);
   err |= readParameter(DCAM_IDPROP_FRAMESTAMP_PRODUCER);

   err |= readParameter(DETECTOR_PIXEL_NUM_HORZ); 
   err |= readParameter(DETECTOR_PIXEL_NUM_VERT); 


   if(err){
   // asynPrint(pasynUser, ASYN_TRACEIO_DRIVER, "%s:%s: port=%s, value=%d, status=%d\n",
   //         driverName, functionName, this->portName, value, (int)status);
   }
return err;
}

//============================================================================
int Hama::readParameterStr(int propertyID){

   asynStatus status = asynSuccess;

   char text[256];
   DCAMDEV_STRING param;
   memset( &param, 0, sizeof(param) );
   param.size              = sizeof(param);
   param.text              = text;
   param.textbytes         = sizeof(text);
   param.iString           = propertyID;
        
   switch (propertyID){
   case DCAM_IDSTR_VENDOR:
       dcamdev_getstring(m_hdcam, &param);
       status = setStringParam(hVendor, text);
       printf("[DEBUG]::VENDOR %s\n", text);
   break;
   case DCAM_IDSTR_MODEL:
       dcamdev_getstring(m_hdcam, &param);
       status = setStringParam(hModel, text);
       printf("[DEBUG]::MODEL %s\n", text);
   break;
   case DCAM_IDSTR_CAMERAID:
       dcamdev_getstring(m_hdcam, &param);
       status = setStringParam(hCameraID, text);
       printf("[DEBUG]::CAMERAID %s\n", text);
   break;
   case DCAM_IDSTR_BUS:
       dcamdev_getstring(m_hdcam, &param);
       status = setStringParam(hBus, text);
       printf("[DEBUG]::BUS %s\n", text);
   break;
   case DCAM_IDSTR_CAMERAVERSION:
       dcamdev_getstring(m_hdcam, &param);
       status = setStringParam(hCameraVersion, text);
       printf("[DEBUG]::CAMERAVERSION %s\n", text);
   break;
   case DCAM_IDSTR_DRIVERVERSION:
       dcamdev_getstring(m_hdcam, &param);
       status = setStringParam(hDriverVersion, text);
       printf("[DEBUG]::DRIVERVERSION %s\n", text);
   break;
   case DCAM_IDSTR_MODULEVERSION:
       dcamdev_getstring(m_hdcam, &param);
       status = setStringParam(hModuleVersion, text);
       printf("[DEBUG]::MODULEVERSION %s\n", text);
   break;
   case DCAM_IDSTR_DCAMAPIVERSION:
       dcamdev_getstring(m_hdcam, &param);
       status = setStringParam(hDcamApiVersion, text);
       printf("[DEBUG]::DCAMPVERSION %s\n", text);
   break;
   default:
       printf("[DEBUG]::NOT SUPPORTED\n");
   break;    

   }

   callParamCallbacks();

return status;
}


//============================================================================
int Hama::readParameter(int propertyID){

   asynStatus status = asynSuccess;
   double dvalue = 0;

   switch (propertyID){
   // - sensor mode and speed 
   case DCAM_IDPROP_SENSORMODE:  //(RW1--)
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SENSORMODE, &dvalue);
      status = setIntegerParam(hSensorMode, dvalue);
   break;
   case DCAM_IDPROP_READOUTSPEED:   //(RW1--)
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_READOUTSPEED, &dvalue);
      status = setIntegerParam(hReadoutSpeed, dvalue);
   break;
   case DCAM_IDPROP_READOUT_DIRECTION:   // (RW1--)
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_READOUT_DIRECTION, &dvalue);
      status = setIntegerParam(hReadoutDirection, dvalue);
   break;
   // - trigger 
   case DCAM_IDPROP_TRIGGERSOURCE:   // (RW123)
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGERSOURCE, &dvalue);
      status = setIntegerParam(hTriggerSource, dvalue);
   break;
   case DCAM_IDPROP_TRIGGER_MODE:   // (RW123)
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGER_MODE, &dvalue);
      status = setIntegerParam(hTriggerMode, dvalue);
   break;
   case DCAM_IDPROP_TRIGGERACTIVE:   //(RW123)
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGERACTIVE, &dvalue);
      status = setIntegerParam(hTriggerActive, dvalue);
   break;
   case DCAM_IDPROP_TRIGGER_GLOBALEXPOSURE:   //(RW1--)
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGER_GLOBALEXPOSURE, &dvalue);
      status = setIntegerParam(hTriggerGlobalExposure, dvalue);
   break;
   case DCAM_IDPROP_TRIGGERPOLARITY:   //(RW123)
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGERPOLARITY, &dvalue);
      status = setIntegerParam(hTriggerPolarity, dvalue);
   break;
   case DCAM_IDPROP_TRIGGER_CONNECTOR:   //(RW123)
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGER_CONNECTOR, &dvalue);
      status = setIntegerParam(hTriggerConnector, dvalue);
   break;
   case DCAM_IDPROP_TRIGGERTIMES:    //(RW123)
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGERTIMES, &dvalue);
      status = setIntegerParam(hTriggerTimes, dvalue);
   break;
   case DCAM_IDPROP_TRIGGERDELAY:    //(RW123)
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGERDELAY, &dvalue);
      status = setDoubleParam(hTriggerDelay, dvalue);
   break;
   case DCAM_IDPROP_INTERNALTRIGGER_HANDLING:   //(RW12-)
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_INTERNALTRIGGER_HANDLING, &dvalue);
      status = setIntegerParam(hInternalTriggerHandling, dvalue);
   break;
   // - sensor cooler
   case DCAM_IDPROP_SENSORCOOLERSTATUS:   //(R)
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SENSORCOOLERSTATUS, &dvalue);
      status = setIntegerParam(hSensorCoolerStatus, dvalue);
   break;
   // - sensor temperature in a thread

   // - binning and roi
   case DCAM_IDPROP_BINNING:   //(RW1--)   
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_BINNING, &dvalue);
      status = setIntegerParam(hBinning, dvalue);
   break;

   case DCAM_IDPROP_SUBARRAYHSIZE:   //(RW1--)
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHSIZE, &dvalue);
      status = setIntegerParam(ADSizeX, dvalue);
   break;

   case DCAM_IDPROP_SUBARRAYVSIZE:   //(RW1--)
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVSIZE, &dvalue);
      status = setIntegerParam(ADSizeY, dvalue);
   break;

   case DCAM_IDPROP_SUBARRAYHPOS:   //(RW---)
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHPOS, &dvalue);
      status = setIntegerParam(ADMinX, dvalue);
   break;

   case DCAM_IDPROP_SUBARRAYVPOS:    //(RW1--)
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVPOS, &dvalue);
      status = setIntegerParam(ADMinY, dvalue);
   break;

   case DCAM_IDPROP_SUBARRAYMODE:    //(RW1--)
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYMODE, &dvalue);
      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;

   // - alu
   case DCAM_IDPROP_DEFECTCORRECT_MODE:   //(RW123)
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_DEFECTCORRECT_MODE, &dvalue);
      status = setIntegerParam(hDefectCorrectMode, dvalue);
   break;
   case DCAM_IDPROP_HOTPIXELCORRECT_LEVEL:   //(RW123)
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_HOTPIXELCORRECT_LEVEL, &dvalue);
      status = setIntegerParam(hHotPixelCorrectLevel, dvalue);
   break;
   case DCAM_IDPROP_INTENSITYLUT_MODE:   //(RW123)
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_INTENSITYLUT_MODE, &dvalue);
      status = setIntegerParam(hIntensityLutMode, dvalue);
   break;
   case DCAM_IDPROP_INTENSITYLUT_PAGE:   //(RW1--)
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_INTENSITYLUT_PAGE, &dvalue);
      status = setIntegerParam(hIntensityLutPage, dvalue);
   break;
   case DCAM_IDPROP_EXTRACTION_MODE:   //(RW1--)
      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_SOURCE:
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_SOURCE, &dvalue);
      status = setIntegerParam(hOutputTriggerSource0, dvalue);
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_SOURCE+0x100, &dvalue);
      status = setIntegerParam(hOutputTriggerSource1, dvalue);
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_SOURCE+0x200, &dvalue);
      status = setIntegerParam(hOutputTriggerSource2, dvalue);
   break;

   case DCAM_IDPROP_OUTPUTTRIGGER_POLARITY:
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_POLARITY, &dvalue);
      status = setIntegerParam(hOutputTriggerPolarity0, dvalue);
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_POLARITY+0x100, &dvalue);
      status = setIntegerParam(hOutputTriggerPolarity1, dvalue);
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_POLARITY+0x200, &dvalue);
      status = setIntegerParam(hOutputTriggerPolarity2, dvalue);
   break;

   case DCAM_IDPROP_OUTPUTTRIGGER_ACTIVE:
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_ACTIVE, &dvalue);
      status = setIntegerParam(hOutputTriggerActive0, dvalue);
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_ACTIVE+0x100, &dvalue);
      status = setIntegerParam(hOutputTriggerActive1, dvalue);
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_ACTIVE+0x200, &dvalue);
      status = setIntegerParam(hOutputTriggerActive2, dvalue);
   break;

   case DCAM_IDPROP_OUTPUTTRIGGER_DELAY:
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_DELAY, &dvalue);
      status = setIntegerParam(hOutputTriggerDelay0, dvalue);
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_DELAY+0x100, &dvalue);
      status = setIntegerParam(hOutputTriggerDelay1, dvalue);
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_DELAY+0x200, &dvalue);
      status = setIntegerParam(hOutputTriggerDelay2, dvalue);
   break;

   case DCAM_IDPROP_OUTPUTTRIGGER_PERIOD:
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_PERIOD, &dvalue);
      status = setIntegerParam(hOutputTriggerPeriod0, dvalue);
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_PERIOD+0x100, &dvalue);
      status = setIntegerParam(hOutputTriggerPeriod1, dvalue);
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_PERIOD+0x200, &dvalue);
      status = setIntegerParam(hOutputTriggerPeriod2, dvalue);
   break;

   case DCAM_IDPROP_OUTPUTTRIGGER_KIND:
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_KIND, &dvalue);
      status = setIntegerParam(hOutputTriggerKind0, dvalue);
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_KIND+0x100, &dvalue);
      status = setIntegerParam(hOutputTriggerKind1, dvalue);
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_KIND+0x200, &dvalue);
      status = setIntegerParam(hOutputTriggerKind2, dvalue);
   break;

   case DCAM_IDPROP_OUTPUTTRIGGER_BASESENSOR:
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_BASESENSOR, &dvalue);
      status = setIntegerParam(hOutputTriggerBaseSensor0, dvalue);
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_BASESENSOR+0x100, &dvalue);
      status = setIntegerParam(hOutputTriggerBaseSensor1, dvalue);
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_BASESENSOR+0x200, &dvalue);
      status = setIntegerParam(hOutputTriggerBaseSensor2, dvalue);
   break;
 
   case DCAM_IDPROP_OUTPUTTRIGGER_PREHSYNCCOUNT:
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_PREHSYNCCOUNT, &dvalue);
      status = setIntegerParam(hOutputTriggerPreHsyncCount, dvalue);
   break;
  

   // - master pulse
   case DCAM_IDPROP_MASTERPULSE_MODE:
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_MASTERPULSE_MODE, &dvalue);
      status = setIntegerParam(hMasterPulseMode, dvalue);
   break;

   case DCAM_IDPROP_MASTERPULSE_TRIGGERSOURCE:
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_MASTERPULSE_TRIGGERSOURCE, &dvalue);
      status = setIntegerParam(hMasterPulseTriggerSource, dvalue);
   break;

   case DCAM_IDPROP_MASTERPULSE_INTERVAL:
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_MASTERPULSE_INTERVAL, &dvalue);
      status = setIntegerParam(hMasterPulseInterval, dvalue);
   break;

   case DCAM_IDPROP_MASTERPULSE_BURSTTIMES:
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_MASTERPULSE_BURSTTIMES, &dvalue);
      status = setIntegerParam(hMasterPulseBurstTimes, dvalue);
   break;


   // - synchronous timing
   case DCAM_IDPROP_TIMING_READOUTTIME:
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TIMING_READOUTTIME, &dvalue);
      status = setDoubleParam(hTimingReadoutTime, dvalue);
   break;
    case DCAM_IDPROP_TIMING_CYCLICTRIGGERPERIOD:
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TIMING_CYCLICTRIGGERPERIOD, &dvalue);
      status = setDoubleParam(hTimingCyclicTriggerPeriod, dvalue);
   break;
    case DCAM_IDPROP_TIMING_MINTRIGGERBLANKING:
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TIMING_MINTRIGGERBLANKING, &dvalue);
      status = setDoubleParam(hTimingMinTriggerBlanking, dvalue);
   break;
    case DCAM_IDPROP_TIMING_MINTRIGGERINTERVAL:
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TIMING_MINTRIGGERINTERVAL, &dvalue);
      status = setDoubleParam(hTimingMinTriggerInterval, dvalue);
   break;
    case DCAM_IDPROP_TIMING_GLOBALEXPOSUREDELAY:
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TIMING_GLOBALEXPOSUREDELAY, &dvalue);
      status = setDoubleParam(hTimingGlobalExposureDelay, dvalue);
   break;
    case DCAM_IDPROP_TIMING_EXPOSURE:
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TIMING_EXPOSURE, &dvalue);
      status = setIntegerParam(hTimingExposure, dvalue);
   break;
    case DCAM_IDPROP_TIMING_INVALIDEXPOSUREPERIOD:
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TIMING_INVALIDEXPOSUREPERIOD, &dvalue);
      status = setDoubleParam(hTimingInvalidExposurePeriod, dvalue);
   break;
   case DCAM_IDPROP_INTERNALFRAMERATE:
      m_err = dcamprop_getvalue( m_hdcam, DCAM_IDPROP_INTERNALFRAMERATE, &dvalue);
      status = setDoubleParam(hInternalFrameRate, dvalue);
   break;
   case DCAM_IDPROP_INTERNAL_FRAMEINTERVAL:
      m_err = dcamprop_getvalue( m_hdcam, DCAM_IDPROP_INTERNAL_FRAMEINTERVAL, &dvalue);
      status = setDoubleParam(hInternalFrameInterval, dvalue);
   break;
   case DCAM_IDPROP_INTERNALLINESPEED:
      m_err = dcamprop_getvalue( m_hdcam, DCAM_IDPROP_INTERNALLINESPEED, &dvalue);
      status = setDoubleParam(hInternalLineSpeed, dvalue);
   break;
   case DCAM_IDPROP_INTERNAL_LINEINTERVAL:
      m_err = dcamprop_getvalue( m_hdcam, DCAM_IDPROP_INTERNAL_LINEINTERVAL, &dvalue);
      status = setDoubleParam(hInternalLineInterval, dvalue);
   break;

   // - system information
   case DCAM_IDPROP_COLORTYPE:
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_COLORTYPE, &dvalue);
      status = setIntegerParam(hColorType, dvalue);
   break;
    case DCAM_IDPROP_BITSPERCHANNEL:
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_BITSPERCHANNEL, &dvalue);
      status = setIntegerParam(hBitPerChannel, dvalue);
   break;
   case DCAM_IDPROP_IMAGE_ROWBYTES:
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_ROWBYTES, &dvalue);
      status = setIntegerParam(hImageRowbytes, dvalue);
   break;
   case DCAM_IDPROP_IMAGE_FRAMEBYTES:
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &dvalue);
      status = setIntegerParam(hImageFramebytes, 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_IMAGE_PIXELTYPE:
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_PIXELTYPE, &dvalue);
      status = setIntegerParam(hImagePixelType, 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_IMAGE_WIDTH:
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_WIDTH, &dvalue);
      status = setIntegerParam(ADBinX, dvalue);
   break;
   case DCAM_IDPROP_IMAGE_HEIGHT:
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_HEIGHT, &dvalue);
      status = setIntegerParam(ADBinY, (int)dvalue);
   break;
   case DETECTOR_PIXEL_NUM_HORZ:
      m_err = dcamprop_getvalue(m_hdcam, DETECTOR_PIXEL_NUM_HORZ, &dvalue);
      status = setIntegerParam(ADMaxSizeX, dvalue);
   break;   
   case DETECTOR_PIXEL_NUM_VERT:
      m_err = dcamprop_getvalue(m_hdcam, DETECTOR_PIXEL_NUM_VERT, &dvalue);
      status = setIntegerParam(ADMaxSizeY, dvalue);
   break;
   case DCAM_IDPROP_TIMESTAMP_PRODUCER:
      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TIMESTAMP_PRODUCER, &dvalue);
      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];
      dcamprop_getname(m_hdcam, propertyID, text, sizeof(text));
      printf("Parameter not recognised, IDPROP:0x%08x, NAME:%s\n", propertyID, text);
   break;
   }

   if(failed(m_err)) {
      char text[256];
      dcamprop_getname(m_hdcam, propertyID, text, sizeof(text));
      printError(m_hdcam, m_err, "+dcamprop_getvalue()", "IDPROP:0x%08x, VALUE:%s\n", propertyID, text);
   }

    /* Do callbacks so higher layers see any changes */
    status = callParamCallbacks();
   /*
   if (status)
        asynPrint(0, ASYN_TRACE_ERROR,
              "%s:%s: error, status=%d function=%d, paramName=%s, value=%d\n",
              driverName, functionName, status, index, paramName, value);
   else
        asynPrint(NULL, ASYN_TRACEIO_DRIVER,
              "%s:%s: function=%d, paramName=%s, value=%d\n",
              driverName, functionName, index, paramName, value);
*/
return status;
}


//============================================================================
void Hama::imageTask(){
    int status;
    unsigned char *image;
    int acquire;
    int count = 0;
    int callback;
    //int acquireStatusError = 0;
    int imageMode=0;
    int totalImages=0;
    uint64_t prevAcquisitionCount = 0;
    DCAMCAP_TRANSFERINFO captransferinfo;
    epicsTimeStamp prevAcqTime, currentAcqTime;
    double elapsedTime;

    //static const char *functionName = "imageTask";

    lock();

    while(1) {
        getIntegerParam(ADAcquire, &acquire);
        if(!acquire) { 
            puts("Waiting start");

            unlock();
            status = epicsEventWait(startEvent_);
            puts("Starting request received");
            lock();

            /* We are acquiring. */
            //acquireStatusError = 0;
            setIntegerParam(ADStatus, ADStatusAcquire);

            status = startAcquire();
            epicsTimeGetCurrent(&prevAcqTime);
            printf("Status: %d\n", status);
            if (status != asynSuccess) {
                //acquireStatusError = 1;
                epicsThreadSleep(.1);
            }
            else {
                acquire = 1;
                /* Get the current time */
                prevAcquisitionCount = 0;
            }
        }

        /* Added this delay for the thread not to hog the processor. No need to run on full speed. */
        //epicsThreadSleep(0.001);

        // get image transfer status.
        unlock();
        imageTransferStatus(m_hdcam, captransferinfo);
        lock();

        if (prevAcquisitionCount < (uint64_t)captransferinfo.nFrameCount) {
            //printf("nFrameCount: %d, nNewestFrameIndex: %d\n", captransferinfo.nFrameCount, captransferinfo.nNewestFrameIndex);
            prevAcquisitionCount = captransferinfo.nFrameCount;

            // get image information
            int32 pixeltype = 0, width = 0, rowbytes = 0, height = 0, framebytes = 0;
            getImageInformation(m_hdcam, pixeltype, width, rowbytes, height, framebytes);

            if( pixeltype != DCAM_PIXELTYPE_MONO16 ) {
                printf( "not implement\n" );
                return;
            }
        
            setIntegerParam(NDArraySizeX, (int)width);
            setIntegerParam(NDArraySizeY, (int)height);
            /* Do callbacks so higher layers see any changes */
            callParamCallbacks();
            
            image = new unsigned char[width * 2 * height];
            memset(image, 0, width * 2 * height);

            getIntegerParam(NDArrayCounter, &count);
            count++;
            setIntegerParam(NDArrayCounter, count);

            int32 ts_sec = 0, ts_microsec = 0;
            accessCapturedImage(m_hdcam, captransferinfo.nNewestFrameIndex, image,
                                width * 2, width, height, ts_sec, ts_microsec);

            double exposure_time, readout_time, timestamp;

			//double _readouttime, _internal_frameinternal, _cyclictriggerperiod, _mintriggerblanking;
			//dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TIMING_READOUTTIME, &_readouttime);
			//dcamprop_getvalue(m_hdcam, DCAM_IDPROP_INTERNAL_FRAMEINTERVAL, &_internal_frameinternal);
			//dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TIMING_CYCLICTRIGGERPERIOD, &_cyclictriggerperiod);
			//dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TIMING_MINTRIGGERBLANKING, &_mintriggerblanking);
			//printf("DCAM_IDPROP_TIMING_READOUTTIME: %f\n", _readouttime);
			//printf("DCAM_IDPROP_INTERNAL_FRAMEINTERVAL: %f\n", _internal_frameinternal);
			//printf("DCAM_IDPROP_TIMING_CYCLICTRIGGERPERIOD: %f\n", _cyclictriggerperiod);
			//printf("DCAM_IDPROP_TIMING_MINTRIGGERBLANKING: %f\n", _mintriggerblanking);


            dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TIMING_READOUTTIME, &readout_time);
            dcamprop_getvalue(m_hdcam, DCAM_IDPROP_EXPOSURETIME, &exposure_time);
            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 with correction: %f\n", timestamp);

            epicsTimeGetCurrent(&currentAcqTime);
            elapsedTime = epicsTimeDiffInSeconds(&currentAcqTime, &prevAcqTime);
            prevAcqTime = currentAcqTime;

            status = setDoubleParam(hFrameRate, (double)(1 / elapsedTime));

            getIntegerParam(NDArrayCallbacks, &callback);
            if(callback) {

                NDArray *pImage;
                size_t dims[2];
                int itemp=0;

                getIntegerParam(NDArraySizeX, &itemp); dims[0] = itemp;
                getIntegerParam(NDArraySizeY, &itemp); dims[1] = itemp;
                pImage = pNDArrayPool->alloc(2, dims, NDUInt16, 0, 0);

                if(pImage) {
                    pImage->uniqueId = count;
                    pImage->timeStamp = ts_sec + (ts_microsec / 1.0e6);
                    updateTimeStamp(&pImage->epicsTS);

                    memcpy(pImage->pData, (epicsUInt16 *)image, pImage->dataSize);

                    getAttributes(pImage->pAttributeList);
                    doCallbacksGenericPointer(pImage, NDArrayData, 0);
                    pImage->release();
                }
            }

            delete[] image;
        }

        getIntegerParam(ADNumImages, &totalImages);
        getIntegerParam(ADImageMode, &imageMode);

        if ((imageMode == ADImageMultiple && totalImages == captransferinfo.nFrameCount) || 
            (imageMode == ADImageSingle && captransferinfo.nFrameCount == 1)) {
            setShutter(0);
            stopAcquire();
            setIntegerParam(ADAcquire, 0);
        }

        callParamCallbacks();
    }
}
//============================================================================
void Hama::temperatureTask(){
   static const char *functionName = "tempTask";
   asynStatus  status = asynSuccess;
   double dvalue = 0;

   while( !stopThread ) {

      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SENSORTEMPERATURE, &dvalue);
      if(failed(m_err)) {
        printError(m_hdcam, m_err, "dcamprop_SensorTemperature()", " VALUE:%f\n", dvalue);
      }
      status = setDoubleParam(hSensorTemperature, dvalue);

      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SENSORCOOLERSTATUS, &dvalue);
      if(failed(m_err)) {
        printError(m_hdcam, m_err, "dcamprop_SensorCoolerStatus()", "VALUE:%f\n", dvalue);
      }
      status = setIntegerParam(hSensorCoolerStatus, dvalue);

      if(status){
         asynPrint(pasynUserSelf, ASYN_TRACE_ERROR,
                "%s:%s: temperature read error = %d\n", 
                driverName, functionName, m_err);
      }

      callParamCallbacks();
      epicsThreadSleep(1.0);
   }

}

//============================================================================
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;

   getIntegerParam(ADMinX,  &minH);
   getIntegerParam(ADMinY,  &minV);
   getIntegerParam(ADSizeX, &sizeH);
   getIntegerParam(ADSizeY, &sizeV);
   getIntegerParam(hBinning, &binning);
   getIntegerParam(hBitPerChannel, &bitPerChannel);
 
   dbinning = binning;
   dminH = minH;
   dminV = minV;
   dsizeH = sizeH;
   dsizeV = sizeV;
   double modeON = DCAMPROP_MODE__ON; 
   double modeOFF = DCAMPROP_MODE__OFF; 

   m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYMODE, &modeOFF);
   m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_BINNING,   &dbinning);
   m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHPOS,  &dminH);
   m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVPOS,  &dminV);
   m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHSIZE, &dsizeH);
   m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVSIZE, &dsizeV);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_WIDTH, &dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_HEIGHT, &dvalue);
   status = setIntegerParam(ADBinX, dvalue);
   status = setIntegerParam(ADBinY, dvalue);
   
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_ROWBYTES, &dRowBytes);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &dFrameBytes);
   //m_err = dcamprop_getvalue(m_hdcam, , &dvalue);
   
   status = setIntegerParam(hBinning, dbinning);
   status = setIntegerParam(hImageFramebytes, dFrameBytes);
   status = setIntegerParam(hImageRowbytes, dRowBytes);

   unsigned long size = (dsizeH - dminH) * (dsizeV - dminV) * dbinning;
   printf("[DEBUG::readSensor] BitPerChannel = %d\n", bitPerChannel);
   printf("[DEBUG::readSensor] ImageSize     = %ld\n", size);


   m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYMODE, &modeON);


   callParamCallbacks();
   
return status;
}



//============================================================================
asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value){


   //printf("[DEBUG]::writeInt32\t");
   asynStatus  status = asynSuccess;
   const char* functionName = "writeInt32";
   const char* paramName;

   int index = pasynUser->reason;
   int adstatus;
   // the setget function required double parameter
   double dvalue = double(value);

   getParamName(index, &paramName);

   /* Ensure that ADStatus is set correctly before we set ADAcquire.*/
   getIntegerParam(ADStatus, &adstatus);

   status = setIntegerParam(index, value);

   if (index == ADAcquire) {
        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");
            epicsEventSignal(this->startEvent_);
        }
        else if (!value && (adstatus == ADStatusAcquire || adstatus == ADStatusError)) {
            /* This was a command to stop acquisition */
            setShutter(0);
            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);
      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]::writeInit32 ADNumExposures\n"); 
   }
   else if (index == ADMinX) {
      readSensor();
   }
   else if (index == ADMinY) {
      readSensor();
   }
   else if (index == ADSizeX) {
      readSensor();
   }
   else if (index == ADSizeY) {
      readSensor();
   }
   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 == hReadoutDirection) {
      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);
      }
   } 
   //-- Trigger 
   else if (index == hTriggerSource) {
      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]::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]::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]::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]::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]::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]::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]::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);
      }
   } 

   //-- binning and ROI
   else if (index == hBinning) {
      readSensor();
      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);
      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]::function 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 == hIntensityLutPage) {
      printf("[DEBUG]::function IntensityLutPage %d\n", value); 
      m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_INTENSITYLUT_PAGE, &dvalue);
      if(failed(m_err)) {
        printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
      }
   }
   */
   //-- ALU
   else if (index == hDefectCorrectMode) {
      m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_DEFECTCORRECT_MODE, &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]::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);
      }
   }
   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 == hExtractionMode) {
      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);
      }
   }
   */
   //-- Output trigger
   else if (index == hOutputTriggerSource0) {
      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 == hOutputTriggerSource1) {
      printf("[DEBUG]::writeInit32 OutputTriggerSource1 %d\n", value); 
      m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_SOURCE+0x100, &dvalue);
      if(failed(m_err)) {
        printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
      }
   }
   else if (index == hOutputTriggerSource2) {
      printf("[DEBUG]::writeInit32 OutputTriggerSource2 %d\n", value); 
      m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_SOURCE+0x200, &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]::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 == hOutputTriggerPolarity1) {
      printf("[DEBUG]::writeInit32 OutputTriggerPolaroty1 %d\n", value); 
      m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_POLARITY+0x100, &dvalue);
      if(failed(m_err)) {
        printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
      }
   }
   else if (index == hOutputTriggerPolarity2) {
      printf("[DEBUG]::writeInit32 OutputTriggerPolaroty2 %d\n", value); 
      m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_POLARITY+0x200, &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]::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 == hOutputTriggerKind1) {
      printf("[DEBUG]::writeInit32 OutputTriggerKind1 %d\n", value); 
      m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_KIND+0x100, &dvalue);
      if(failed(m_err)) {
        printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
      }
   }
   else if (index == hOutputTriggerKind2) {
      printf("[DEBUG]::writeInit32 OutputTriggerKind2 %d\n", value); 
      m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_KIND+0x200, &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]::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 == hOutputTriggerBaseSensor1) {
      printf("[DEBUG]::writeInit32 OutputTriggerBaseSensor1 %d\n", value); 
      m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_BASESENSOR+0x100, &dvalue);
      if(failed(m_err)) {
        printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
      }
   }
   else if (index == hOutputTriggerBaseSensor2) {
      printf("[DEBUG]::writeInit32 OutputTriggerBaseSensor2 %d\n", value); 
      m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_BASESENSOR+0x200, &dvalue);
      if(failed(m_err)) {
        printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
      }
   }
   else if (index == hOutputTriggerPreHsyncCount) {
      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);
      }
   }
   
   //-- Master pulse
   else if (index == hMasterPulseMode) {
      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]::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 == hMasterPulseBurstTimes) {
      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);
      }
   }
   //-- Synchronous timing - nothing to implement either is in writeFloat64
   //-- System information  
   else if (index == hBitPerChannel) {
      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 == hImagePixelType) {
      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 < FIRST_HAMA_PARAM){
          status = ADDriver::writeInt32(pasynUser, value);
          printf("[+DEBUG]:: ADDriver::writeInit32 %s\n", paramName); 
          //ADDriver::writeInt32(pasynUser, value);
      }
      else{
          printf("[-DEBUG]::function writeInt32 did not find a parameter index = %d, %s\n", index, paramName); 
      }
   }

   setIntegerParam(index, value);
    /* Do callbacks so higher layers see any changes */
   status = (asynStatus) callParamCallbacks();

   if (status)
        asynPrint(pasynUser, ASYN_TRACE_ERROR,
              "%s:%s: error, status=%d function=%d, paramName=%s, value=%d\n",
              driverName, functionName, status, index, paramName, value);
   else
        asynPrint(pasynUser, ASYN_TRACEIO_DRIVER,
              "%s:%s: function=%d, paramName=%s, value=%d\n",
              driverName, functionName, index, paramName, value);

return status;
}

//============================================================================

asynStatus Hama::writeFloat64(asynUser *pasynUser, epicsFloat64 value){

   asynStatus status = asynSuccess;
   const char* functionName = "writeFloat64";
   const char* paramName;

    int index = pasynUser->reason;

    double dvalue = value; 

   getParamName(index, &paramName);
    //-- Sensor mode and speed
    //-- Feature 
    if(index == ADAcquireTime) {
        printf("[DEBUG]::function ADAcquireTime from camera: %f\n", value);

        int trigger_mode = 0;
        getIntegerParam(hTriggerSource, &trigger_mode);

        if (trigger_mode != DCAMPROP_TRIGGERSOURCE__EXTERNAL) {
            status = setFeature(DCAM_IDPROP_EXPOSURETIME, value);
            m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_EXPOSURETIME, &dvalue);
            if(failed(m_err)) {
            printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
            }

            double acquire_period = 0;
            status = getDoubleParam(ADAcquirePeriod, &acquire_period);
            if (value >= acquire_period) {
                status = setDoubleParam(ADAcquirePeriod, 0);
                status = setFeature(DCAM_IDPROP_TRIGGERSOURCE, DCAMPROP_TRIGGERSOURCE__INTERNAL);
                status = setIntegerParam(hTriggerSource, DCAMPROP_TRIGGERSOURCE__INTERNAL);
                callParamCallbacks();
            }
        }

        else status = asynError;
    }

    else if(index == ADAcquirePeriod) {
        printf("[DEBUG]::function ADAcquirePeriod from camera: %f\n", value);

        int trigger_mode = 0;
        getIntegerParam(hTriggerSource, &trigger_mode);

        if (trigger_mode != DCAMPROP_TRIGGERSOURCE__EXTERNAL) {
            m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_EXPOSURETIME, &dvalue);

            if (value <= dvalue) {
                status = setFeature(DCAM_IDPROP_TRIGGERSOURCE, DCAMPROP_TRIGGERSOURCE__INTERNAL);
                status = setIntegerParam(hTriggerSource, DCAMPROP_TRIGGERSOURCE__INTERNAL);
                value = 0;
            }
            else {
                status = setFeature(DCAM_IDPROP_TRIGGERSOURCE, DCAMPROP_TRIGGERSOURCE__MASTERPULSE);
                status = setIntegerParam(hTriggerSource, DCAMPROP_TRIGGERSOURCE__MASTERPULSE);

                status = setFeature(DCAM_IDPROP_MASTERPULSE_INTERVAL, value);
                status = setDoubleParam(hMasterPulseInterval, value);

                status = setFeature(DCAM_IDPROP_MASTERPULSE_MODE, DCAMPROP_MASTERPULSE_MODE__CONTINUOUS);
                status = setIntegerParam(hMasterPulseMode, DCAMPROP_MASTERPULSE_MODE__CONTINUOUS);
            }
        }
        else status = asynError;
    }

    //-- Trigger
    else if (index == hTriggerDelay) {
      printf("[DEBUG]::function TriggerDelay %f\n", value); 
      m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TRIGGERDELAY, &dvalue);
      if(failed(m_err)) {
           printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
      }
    }
    //-- Sensor cooler   - nothing
    //-- Binning and ROI - nothing
    //-- ALU             - nothing
    //-- Output trigger
   else if (index == hOutputTriggerDelay0) {
      printf("[DEBUG]::function OutputTriggerDelay0 %f\n", value); 
      m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_DELAY, &dvalue);
      if(failed(m_err)) {
           printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
      }
    }
   else if (index == hOutputTriggerDelay1) {
      printf("[DEBUG]::function OutputTriggerDelay1 %f\n", value); 
      m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_DELAY+0x100, &dvalue);
      if(failed(m_err)) {
           printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
      }
    }
   else if (index == hOutputTriggerDelay2) {
      printf("[DEBUG]::function OutputTriggerDelay2 %f\n", value); 
      m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_DELAY+0x200, &dvalue);
      if(failed(m_err)) {
           printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
      }
    }

   else if (index == hOutputTriggerPeriod0) {
      printf("[DEBUG]::function OutputTriggerPeriod0 %f\n", value); 
      m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_PERIOD, &dvalue);
      if(failed(m_err)) {
           printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
      }
    }
   else if (index == hOutputTriggerPeriod1) {
      printf("[DEBUG]::function OutputTriggerPeriod1 %f\n", value); 
      m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_PERIOD+0x100, &dvalue);
      if(failed(m_err)) {
           printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
      }
   }
    else if (index == hOutputTriggerPeriod2) {
      printf("[DEBUG]::function OutputTriggerPeriod2 %f\n", value); 
      m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_PERIOD+0x200, &dvalue);
      if(failed(m_err)) {
           printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
      }
    }
    //-- Master Pulse
    else if (index == hMasterPulseInterval) {
      printf("[DEBUG]::function MasterPulseInterval %f\n", value); 
      m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_MASTERPULSE_INTERVAL, &dvalue);
      if(failed(m_err)) {
           printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
      }
   }
    //-- Synchronous timing

    else if (index == hInternalLineSpeed) {
      printf("[DEBUG]::function InternalLineSpeed %f\n", value); 
      m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_INTERNALLINESPEED, &dvalue);
      if(failed(m_err)) {
           printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
      }
    }
    else if (index == hInternalLineInterval) {
      printf("[DEBUG]::function InternalLineInterupt %f\n", value); 
      m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_INTERNAL_LINEINTERVAL, &dvalue);
      if(failed(m_err)) {
           printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
      }
    }
    else{
       if(index < FIRST_HAMA_PARAM){
          status = ADDriver::writeFloat64(pasynUser, value);
          printf("[+DEBUG]:: ADDriver::writeInit32 %s\n", paramName); 
      }
      else{
          printf("[-DEBUG]::function writeInt32 did not find a parameter index = %d, %s\n", index, paramName); 
      }
    }

    if (status)
        asynPrint(pasynUser, ASYN_TRACE_ERROR,
              "%s:%s: error, status=%d function=%d, paramName=%s, value=%f\n",
              driverName, functionName, status, index, paramName, value);
    else {
        setDoubleParam(index, value);
        callParamCallbacks();
        asynPrint(pasynUser, ASYN_TRACEIO_DRIVER,
              "%s:%s: function=%d, paramName=%s, value=%f\n",
              driverName, functionName, index, paramName, value);
    }
    
    return status;
}


//============================================================================
void Hama::report(FILE *fp, int details){
   double dvalue = 0;
   fprintf(fp, "Hamamatsu Orca Flash4.0 driver\n");
   if (details < 1) return;

   // Sensor mode and speed
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SENSORMODE, &dvalue);
   fprintf(fp, "SENSOR MODE:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_READOUTSPEED, &dvalue);
   fprintf(fp, "READOUT SPEED:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_READOUT_DIRECTION, &dvalue);
   fprintf(fp, "READOUT DIRECTION:\t%f\n", dvalue);
   // Trigger
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGERSOURCE, &dvalue);
   fprintf(fp, "TRIGGER SOURCE:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGER_MODE, &dvalue);
   fprintf(fp, "TRIGGER MODE:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGERACTIVE, &dvalue);
   fprintf(fp, "TRIGGER ACTIVE:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGER_GLOBALEXPOSURE, &dvalue);
   fprintf(fp, "TRIGGER GLOBAL EXPOSURE:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGERPOLARITY, &dvalue);
   fprintf(fp, "TRIGGER POLARITY:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGER_CONNECTOR, &dvalue);
   fprintf(fp, "TRIGGER CONNECTOR:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGERTIMES, &dvalue);
   fprintf(fp, "TRIGGER TIMES:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGERDELAY, &dvalue);
   fprintf(fp, "TRIGGER DELAY:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_INTERNALTRIGGER_HANDLING, &dvalue);
   fprintf(fp, "TRIGGER HANDLING:\t%f\n", dvalue);
   // Sensor cooler
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SENSORCOOLERSTATUS, &dvalue);
   fprintf(fp, "SENSOR COOLER STATUS:\t%f\n", dvalue);
   // Binning and ROI
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_BINNING, &dvalue);
   fprintf(fp, "BINNING:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHSIZE, &dvalue);
   fprintf(fp, "SUBARRAY HSIZE:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVSIZE, &dvalue);
   fprintf(fp, "SUBARRAY VSIZE:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHPOS, &dvalue);
   fprintf(fp, "SUBARRAY HPOS:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVPOS, &dvalue);
   fprintf(fp, "SUBARRAY MODE:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYMODE, &dvalue);
   fprintf(fp, "SUBARRAY MODE:\t%f\n", dvalue);
   // Feature
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_EXPOSURETIME, &dvalue);
   fprintf(fp, "EXPOSURE TIME:\t%f\n", dvalue);
   // ALU
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_DEFECTCORRECT_MODE, &dvalue);
   fprintf(fp, "DEFECT CORRETION MODE:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_HOTPIXELCORRECT_LEVEL, &dvalue);
   fprintf(fp, "HOT PIXEL CORRECTION LEVEL:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_INTENSITYLUT_MODE, &dvalue);
   fprintf(fp, "INTENSITY LUT MODE:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_INTENSITYLUT_PAGE, &dvalue);
   fprintf(fp, "INTENSITY LUT PAGE:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_EXTRACTION_MODE, &dvalue);
   fprintf(fp, "EXTRACTION MODE:\t%f\n", dvalue);
   // Output Trigger
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_NUMBEROF_OUTPUTTRIGGERCONNECTOR, &dvalue);
   fprintf(fp, "OUTPUT TRIGGER CONNECTOR:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_ACTIVE, &dvalue);
   fprintf(fp, "OUTPUT TRIGGER ACTIVE:\t%f\n", dvalue);
   //m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_ACTIVE+4, &dvalue);
   //fprintf(fp, ":\t%f\n", dvalue);
   //m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_ACTIVE+6, &dvalue);
   //fprintf(fp, ":\t%f\n", dvalue);

   // - master pulse
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_MASTERPULSE_MODE, &dvalue);
   fprintf(fp, "MASTER PULSE MODE:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_MASTERPULSE_TRIGGERSOURCE, &dvalue);
   fprintf(fp, "MASTER MODE TRIGGERSOURCE:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_MASTERPULSE_INTERVAL, &dvalue);
   fprintf(fp, "MASTER MODE INTERVAL:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_MASTERPULSE_BURSTTIMES, &dvalue);
   fprintf(fp, "MASTER MODE BURSTTIMES:\t%f\n", dvalue);

   // - synchronous timing
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TIMING_READOUTTIME, &dvalue);
   fprintf(fp, "TIMING READOUT TIME:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TIMING_CYCLICTRIGGERPERIOD, &dvalue);
   fprintf(fp, "TIMING CYCLIN TRIGGER PERIOD:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TIMING_MINTRIGGERBLANKING, &dvalue);
   fprintf(fp, "TIMING MIN TRIGGER BLANKING:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TIMING_MINTRIGGERINTERVAL, &dvalue);
   fprintf(fp, "TIMING MIN TRIGGER INTERVAL:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TIMING_GLOBALEXPOSUREDELAY, &dvalue);
   fprintf(fp, "TIMING GLOBAL EXPOSURE DELAY:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TIMING_EXPOSURE, &dvalue);
   fprintf(fp, "TIMING EXPOSURE:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TIMING_INVALIDEXPOSUREPERIOD, &dvalue);
   fprintf(fp, "TIMING INVALID EXPOSURE PERIOD:\t%f\n", dvalue);
   m_err = dcamprop_getvalue( m_hdcam, DCAM_IDPROP_INTERNALFRAMERATE, &dvalue);
   fprintf(fp, "INTERNAL FRAME RATE:\t%f\n", dvalue);
   m_err = dcamprop_getvalue( m_hdcam, DCAM_IDPROP_INTERNAL_FRAMEINTERVAL, &dvalue);
   fprintf(fp, "INTERNAL FRAME INTERVAL:\t%f\n", dvalue);
   m_err = dcamprop_getvalue( m_hdcam, DCAM_IDPROP_INTERNALLINESPEED, &dvalue);
   fprintf(fp, "INTERNAL LINE SPEED:\t%f\n", dvalue);
   m_err = dcamprop_getvalue( m_hdcam, DCAM_IDPROP_INTERNAL_LINEINTERVAL, &dvalue);
   fprintf(fp, "INTERNAL LINE INTERVAL:\t%f\n", dvalue);
   // - system information
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_COLORTYPE, &dvalue);
   fprintf(fp, "COLOR TYPE:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_BITSPERCHANNEL, &dvalue);
   fprintf(fp, "BITS PER CHANNEL:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_ROWBYTES, &dvalue);
   fprintf(fp, "IMAGE ROW BYTES:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &dvalue);
   fprintf(fp, "IMAGE FRAME BYTES:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_TOPOFFSETBYTES, &dvalue);
   fprintf(fp, "IMAGE TOP OFFSET BYTES:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_PIXELTYPE, &dvalue);
   fprintf(fp, "IMAGE PIXEL TYPE:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_BUFFER_ROWBYTES, &dvalue);
   fprintf(fp, "BUFFER ROW BYTES:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_BUFFER_FRAMEBYTES, &dvalue);
   fprintf(fp, "BUFER FRAME BYTES:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_BUFFER_TOPOFFSETBYTES, &dvalue);
   fprintf(fp, "BUFFER TOP OFFSET BYTES:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_BUFFER_PIXELTYPE, &dvalue);
   fprintf(fp, "BUFFER PIXEL TYPE:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_RECORDFIXEDBYTES_PERFILE, &dvalue);
   fprintf(fp, "RECORD FIXED BYTES PER FILE:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_RECORDFIXEDBYTES_PERSESSION, &dvalue);
   fprintf(fp, "RECORD FIXED BYTES PER SESSION:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_RECORDFIXEDBYTES_PERFRAME, &dvalue);
   fprintf(fp, "RECORD FIXED BYTES PER FRAME:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SYSTEM_ALIVE, &dvalue);
   fprintf(fp, "SYSTEM ALIVE:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_CONVERSIONFACTOR_COEFF, &dvalue);
   fprintf(fp, "CONVERSION FACTOR COEFFICIENT:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_CONVERSIONFACTOR_OFFSET, &dvalue);
   fprintf(fp, "CONVERSION FACTOR OFFSET:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_NUMBEROF_VIEW, &dvalue);
   fprintf(fp, "NUMBER OF VIEW:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_WIDTH, &dvalue);
   fprintf(fp, "IMAGE WIDTH:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_HEIGHT, &dvalue);
   fprintf(fp, "IMAGE HEIGHT:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DETECTOR_PIXEL_NUM_HORZ, &dvalue);
   fprintf(fp, "PIXEL NUM HORZ:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DETECTOR_PIXEL_NUM_VERT, &dvalue);
   fprintf(fp, "PIXEL NUM VERT:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TIMESTAMP_PRODUCER, &dvalue);
   fprintf(fp, "TIMESTAMP PRODUCER:\t%f\n", dvalue);
   m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_FRAMESTAMP_PRODUCER, &dvalue);
   fprintf(fp, "FRAMESTAMP PRODUCER:\t%f\n", dvalue);

   ADDriver::report(fp, details);
}

//============================================================================
int Hama::connectCamera(void){
 
    static const char *functionName = "connectCamera";
    int nDevices = 0;
    int iDevice = 0;
    /* disconnect any connected camera first */
    disconnectCamera();

    /* initialize api */   
    memset(&m_apiInit, 0, sizeof(m_apiInit));
    m_apiInit.size = sizeof(m_apiInit);

    asynPrint(pasynUserSelf, ASYN_TRACE_FLOW,
        "%s:%s: connecting camera %d\n",
        driverName, functionName, m_id);
 
    m_err = dcamapi_init( &m_apiInit);
    if( failed(m_err) ){
      printError( m_hdcam, m_err, "dcamapi_init()", NULL );
    } else {
      nDevices = m_apiInit.iDeviceCount;
      printf("dcamapi_init() found %d device(s). \n", nDevices);
      printf("camera with index 0 will be used\n");
      iDevice = 0;
    }

    /* open handle to camera */
    memset( &m_devOpen, 0, sizeof(m_devOpen) );
    m_devOpen.size    = sizeof(m_devOpen);
    m_devOpen.index   = iDevice;
    m_err = dcamdev_open( &m_devOpen );

    if( failed(m_err) ){
      printError( m_hdcam, m_err, "dcamapi_init()" );

    } else {
      m_hdcam = m_devOpen.hdcam;
      printInfo( m_hdcam );
    }

    // open wait handle
	DCAMWAIT_OPEN	waitopen;
	memset( &waitopen, 0, sizeof(waitopen) );
	waitopen.size	= sizeof(waitopen);
	waitopen.hdcam	= m_hdcam;

	m_err = dcamwait_open( &waitopen );
	if( failed(m_err) ) {
	    printError( m_hdcam, m_err, "dcamwait_open()" );
	}
    else {
		hwait = waitopen.hwait;
    }
  
    /* close api */ //- it should be here??????????????
//    dcamapi_uninit();
//    return status;
    return 0;
}

//============================================================================
int Hama::disconnectCamera(void){
   
    static const char *functionName = "disconnectCamera";

    int status = 0;


    if(m_hdcam == NULL) {
        return status;
    }

    asynPrint(pasynUserSelf, ASYN_TRACE_FLOW,
        "%s:%s: disconnecting camera %d\n",
        driverName, functionName, m_id);

//    status = AT_GetBool(handle_, L"CameraAcquiring", &acquiring);
//    if(status == AT_SUCCESS && acquiring) {
//        status |= AT_Command(handle_, L"Acquisition Stop");
//    }

//    status |= freeBuffers();
    dcamdev_close( m_hdcam );

    if(status) {
        asynPrint(pasynUserSelf, ASYN_TRACE_ERROR,
            "%s:%s: error closing camera %d\n",
            driverName, functionName, m_id);
    }

    m_hdcam = NULL;
    return status;


}
//============================================================================
int Hama::allocateBuffers(unsigned int nBuffers) {
    m_err = dcambuf_alloc(m_hdcam, nBuffers);
    if(failed(m_err)) {
        puts("banana");
        printError(m_hdcam, m_err, "dcambuf_alloc()");
        return asynError;
    }
    return asynSuccess;
}

//============================================================================
int Hama::freeBuffers(){
  m_err = dcambuf_release( m_hdcam );
  if( failed(m_err) )
      printError( m_hdcam, m_err, "dcambuf_release()" );

return 0;
}

//============================================================================
asynStatus Hama::stopAcquire(void)
{
    asynStatus status = asynSuccess;
	dcamcap_stop(m_hdcam);
	printf("Stop Capture\n");
    return status;
}

//============================================================================
asynStatus Hama::startAcquire(void)
{
    asynStatus status = asynSuccess;

    // release buffer
	freeBuffers();

    // allocate buffer
    allocateBuffers(1);

    // start capture
    m_err = dcamcap_start(m_hdcam, DCAMCAP_START_SEQUENCE);
    if(failed(m_err)) {
		printError(m_hdcam, m_err, "dcamcap_start()");
        status = asynError;
	}
	else {
		printf( "\nStart Capture\n" );
		// set wait param
		DCAMWAIT_START waitstart;
		memset( &waitstart, 0, sizeof(waitstart) );
		waitstart.size		= sizeof(waitstart);
		waitstart.eventmask	= DCAMWAIT_CAPEVENT_FRAMEREADY;
		waitstart.timeout	= DCAMWAIT_TIMEOUT_INFINITE;

		m_err = dcamwait_start(hwait, &waitstart);
		if(failed(m_err)) {
            printError(m_hdcam, m_err, "dcamwait_start()");
            status = asynError;
        }
    }
    return status;
}

//============================================================================
inline void* memcpy_s( void* dst, size_t dstsize, const void* src, size_t srclen )
{
	if( dstsize < srclen )
		return memcpy( dst, src, dstsize );
	else
		return memcpy( dst, src, srclen );
}

//============================================================================
asynStatus Hama::accessCapturedImage(HDCAM hdcam, int32 iFrame, void* buf,
                                     int32 rowbytes, int32 cx, int32 cy,
                                     int32& ts_sec, int32& ts_microsec)
{
	DCAMERR err;

	// prepare frame param
	DCAMBUF_FRAME bufframe;
	memset( &bufframe, 0, sizeof(bufframe) );
	bufframe.size	= sizeof(bufframe);
	bufframe.iFrame	= iFrame;

	// access image
	err = dcambuf_lockframe( hdcam, &bufframe );
	if(failed(err)) {
		printError(hdcam, err, "dcambuf_lockframe()");
		return asynError;
	}

	if( bufframe.type != DCAM_PIXELTYPE_MONO16 ) {
		printf("not implement pixel type\n");
		return asynError;
	}

    // Get timestamp from the the frame
    ts_sec = bufframe.timestamp.sec;
    ts_microsec = bufframe.timestamp.microsec;

	// copy target ROI
	int32 copyrowbytes = cx * 2;
	char* pSrc = (char*)bufframe.buf;
	char* pDst = (char*)buf;

	for(int y = 0; y < cy; y++ ) {
		memcpy_s( pDst, rowbytes, pSrc, copyrowbytes);
		pSrc += bufframe.rowbytes;
		pDst += rowbytes;
	}

	return asynSuccess;
}


//========================================================================================================


void Hama::getImageInformation(HDCAM hdcam, int32& pixeltype, int32& width, int32& rowbytes, int32& height, int32& framebytes)
{
	DCAMERR err;
	double property_value;

	// image pixel type(DCAM_PIXELTYPE_MONO16, MONO8, ... )
	err = dcamprop_getvalue(hdcam, DCAM_IDPROP_IMAGE_PIXELTYPE, &property_value);
	if( failed(err) )
	{
		printError( hdcam, err, "dcamprop_getvalue()", "IDPROP:IMAGE_PIXELTYPE" );
		return;
	}
	else
		pixeltype = (int32) property_value;

	// image width
	err = dcamprop_getvalue( hdcam, DCAM_IDPROP_IMAGE_WIDTH, &property_value );
	if( failed(err) )
	{
		printError( hdcam, err, "dcamprop_getvalue()", "IDPROP:IMAGE_WIDTH" );
		return;
	}
	else
		width = (int32)property_value;

	// image row bytes
	err = dcamprop_getvalue( hdcam, DCAM_IDPROP_IMAGE_ROWBYTES, &property_value );
	if( failed(err) )
	{
		printError( hdcam, err, "dcamprop_getvalue()", "IDPROP:IMAGE_ROWBYTES" );
		return;
	}
	else
		rowbytes = (int32)property_value;

	// image height
	err = dcamprop_getvalue( hdcam, DCAM_IDPROP_IMAGE_HEIGHT, &property_value );
	if( failed(err) )
	{
		printError( hdcam, err, "dcamprop_getvalue()", "IDPROP:IMAGE_HEIGHT" );
		return;
	}
	else
		height = (int32)property_value;


    // image framebytes
	err = dcamprop_getvalue( hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &property_value );
	if( failed(err) )
	{
		printError( hdcam, err, "dcamprop_getvalue()", "IDPROP:IMAGE_FRAMEBYTES" );
		return;
	}
	else
		framebytes = (int32)property_value;
}

//============================================================================
asynStatus Hama::imageTransferStatus(HDCAM hdcam, DCAMCAP_TRANSFERINFO &captransferinfo)
{
    DCAMERR err;
    // transferinfo param
    memset(&captransferinfo, 0, sizeof(captransferinfo));
    captransferinfo.size = sizeof(captransferinfo);

    // get number of captured image
    err = dcamcap_transferinfo(m_hdcam, &captransferinfo );
    if( failed(err) ) {
        printError( m_hdcam, err, "dcamcap_transferinfo()" );
        return asynError;
    }

    if(captransferinfo.nFrameCount < 1) {
        printf( "not capture image\n" );
        return asynError;
    }

    return asynSuccess;
}

//============================================================================
void Hama::printError(HDCAM hdcam, DCAMERR errid, const char* apiname, const char* fmt, ...){

   char errtext[ 256 ];

   DCAMERR err;
   dcamdev_string( err, hdcam, errid, errtext, sizeof(errtext) );

   printf( "-[ERROR]- -(DCAMERR)- -0x%08X- -%s- -%s-\n", errid, errtext, apiname );

   if( fmt != NULL ) {
     printf( " : " );

     va_list	arg;
     va_start(arg,fmt);
     vprintf( fmt, arg );
     va_end(arg);
   }

   
}

//============================================================================

void Hama::printInfo(HDCAM hdcam){

   char model[ 256 ];
   char cameraid[ 64 ];
   char bus[ 64 ];

   DCAMERR err;
   if( ! dcamdev_string( err, hdcam, DCAM_IDSTR_MODEL,    model,    sizeof(model)   ) ) {
     printError( hdcam, err, "dcamdev_getstring(DCAM_IDSTR_MODEL)\n" );
   }
   else if( ! dcamdev_string( err, hdcam, DCAM_IDSTR_CAMERAID, cameraid, sizeof(cameraid)) ) {
     printError( hdcam, err, "dcamdev_getstring(DCAM_IDSTR_CAMERAID)\n" );
   }
   else if( ! dcamdev_string( err, hdcam, DCAM_IDSTR_BUS,      bus,      sizeof(bus)     ) ) {
     printError( hdcam, err, "dcamdev_getstring(DCAM_IDSTR_BUS)\n" );
   }
   else {
     printf( "%s (%s) on %s\n", model, cameraid, bus );
   }

}


//============================================================================

int Hama::dcamdev_string( DCAMERR& err, HDCAM hdcam, int32 idStr, char* text, int32 textbytes ) {

   DCAMDEV_STRING	param;
   memset( &param, 0, sizeof(param) );
   param.size		= sizeof(param);
   param.text		= text;
   param.textbytes	= textbytes;
   param.iString	= idStr;
	
   err = dcamdev_getstring( hdcam, &param );
return ! failed( err );
}

//============================================================================
asynStatus Hama::setFeature(int featureIndex, double value) {
    DCAMERR err;
    err = dcamprop_setvalue(m_hdcam, featureIndex, value);
    if(failed(err)) {
        printError(m_hdcam, err, "dcamprop_setvalue()", "IDPROP:0x%08x, VALUE:%f\n", featureIndex, value);
		return asynError;
	}
	return asynSuccess;
}

//============================================================================
int Hama::getProperties(){
   printf("\n[DEBUG] Function:getProperties\n");

   int32   iProp = 0;      // property IDs

   double value = 50;
   dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SENSORTEMPERATURE, &value);
   printf("The SENSOR TEMPERATURE = %f\n", value);

   DCAMERR err;
   err = dcamprop_getnextid( m_hdcam, &iProp, DCAMPROP_OPTION_SUPPORT );
   if( failed(err) ) {
      printError( m_hdcam, err, "dcamprop_getnextid()", "IDPROP:0x%08x, OPTION:SUPPORT", 0 );
      return err;
   }
    
   do{
      // get property name
      char    text[ 64 ];
      err = dcamprop_getname( m_hdcam, iProp, text, sizeof(text) );
      if( failed(err) ) {
         printError( m_hdcam, err, "dcamprop_getname()", "IDPROP:0x%08x", iProp );
         return err;
      }

      printf( "0x%08x: %s\n", iProp, text );

      // get property attribute
      DCAMPROP_ATTR   basepropattr;
      memset( &basepropattr, 0, sizeof(basepropattr) );
      basepropattr.cbSize     = sizeof(basepropattr);
      basepropattr.iProp      = iProp;

      err = dcamprop_getattr( m_hdcam, &basepropattr );
      if( !failed(err) ) {

         #if SHOW_PROPERTY_ATTRIBUTE
         // show property attribute
         //dcamcon_show_propertyattr( basepropattr );
         #endif

         #if SHOW_PROPERTY_MODEVALUELIST
         // show mode value list of property
         //if( (basepropattr.attribute & DCAMPROP_TYPE_MASK) == DCAMPROP_TYPE_MODE )
         //   dcamcon_show_supportmodevalues( m_hdcam, iProp, basepropattr.valuemin );
         #endif

         #if SHOW_PROPERTY_ARRAYELEMENT
         // show array element
         //if( basepropattr.attribute2 & DCAMPROP_ATTR2_ARRAYBASE )
         //   dcamcon_show_arrayelement( m_hdcam, basepropattr );
         #endif
         }

      // get next property id
      err = dcamprop_getnextid( m_hdcam, &iProp, DCAMPROP_OPTION_SUPPORT );
      if( failed(err) ) {
         // no more supported property id
         return err;
      }

   } while( iProp != 0 );
   
return 0;   
}



//============================================================================
//============================================================================
/* Code for iocsh registration */



extern "C" int HamaConfig(const char *portName, int cameraId, int maxBuffers,
                            size_t maxMemory, int priority, int stackSize,
                            int maxFrames) {
    new Hama(portName, cameraId, maxBuffers, maxMemory, priority, stackSize,
               maxFrames);

    return(asynSuccess);
}

//============================================================================
static const iocshArg HamaConfigArg0 = {"Port name",  iocshArgString};
static const iocshArg HamaConfigArg1 = {"CameraId",   iocshArgInt};
static const iocshArg HamaConfigArg2 = {"maxBuffers", iocshArgInt};
static const iocshArg HamaConfigArg3 = {"maxMemory",  iocshArgInt};
static const iocshArg HamaConfigArg4 = {"priority",   iocshArgInt};
static const iocshArg HamaConfigArg5 = {"stackSize",  iocshArgInt};
static const iocshArg HamaConfigArg6 = {"maxFrames",  iocshArgInt};
static const iocshArg * const HamaConfigArgs[] =  {  &HamaConfigArg0,
                                                     &HamaConfigArg1,
                                                     &HamaConfigArg2,
                                                     &HamaConfigArg3,
                                                     &HamaConfigArg4,
                                                     &HamaConfigArg5,
                                                     &HamaConfigArg6 };
//============================================================================
static const iocshFuncDef confighama = {"devHamamatsuConfig", 7, HamaConfigArgs};

//============================================================================
static void confighamaCallFunc(const iocshArgBuf *args) {
    HamaConfig(args[0].sval, args[1].ival, args[2].ival,  args[3].ival,
                 args[4].ival, args[5].ival, args[6].ival);
}

//============================================================================
static void hamaRegister(void) {

    iocshRegister(&confighama, confighamaCallFunc);
}

//============================================================================
extern "C" {

epicsExportRegistrar(hamaRegister);
}