Add linux library to local repo

ADHama.Makefile

@@ -133,7 +133,8 @@ USR_DBFLAGS += -I $(E3_ADCORE_LOCATION)/db
 USR_DBFLAGS += -I $(EPICS_BASE)/db
 USR_DBFLAGS += -I $(APPDB)
 
-USR_LDFLAGS += -L/usr/local/lib -ldcamapi 
+USR_LDFLAGS += -L$(PWD)/support/dcamsdk4/lib/linux -ldcamapi 
+#USR_LDFLAGS += -L/usr/local/lib -ldcamapi 
 
 db: $(SUBS) $(TMPS)
 

ADHamaApp/Db/hama.template

@@ -961,7 +961,7 @@ record(mbbi, "$(P)$(R)OutputTriggerKind0-RB") {
 }
 
 ##########################################################################
-# Output Trigger PreHsyncCount
+# Output Trigger PreHsyncCount0
 record(ao, "$(P)$(R)OutputTriggerPreHsyncCount-S") {
    field(DESC, "")
    field(PINI, "YES")
@@ -1165,13 +1165,23 @@ record(ai, "$(P)$(R)TimingGlobalExposureDelay-RB") {
 }
 
 ##########################################################################
-# Timing Invalid Exposure Period
-record(mbbi, "$(P)$(R)TimingInvalidExposurePeriod-RB") {
+# Timing Global Exposure Delay
+record(mbbi, "$(P)$(R)TimingExposure-RB") {
    field(DESC, "")
    field(DTYP, "asynInt32")
-   field(ZRVL, "1")
-   field(ZRST, "Exposure Roling")
+   field(ZRVL, "3")
+   field(ZRST, "Roling")
+   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TIMING_EXPOSURE")  
+   field(SCAN, "I/O Intr")
+}
+
+##########################################################################
+# Timing Invalid Exposure Period
+record(ai, "$(P)$(R)TimingInvalidExposurePeriod-RB") {
+   field(DESC, "")
+   field(DTYP, "asynFloat64")
    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TIMING_INVALID_EXPOSURE_PERIOD")  
+   field(EGU,  "Sec")
    field(SCAN, "I/O Intr")
 }
 
@@ -1214,7 +1224,7 @@ record(ai, "$(P)$(R)InternalFrameInternal-RB") {
 }
 
 ##########################################################################
-# Internal Line Interval
+# Internal Line Speed
 record(ao, "$(P)$(R)InternalLineSpeed-S") {
    field(DESC, "")
    field(DTYP, "asynFloat64")

ADHamaApp/src/hama.cpp

@@ -134,9 +134,7 @@ Hama::Hama(const char* portName, int cameraId, int maxBuffers, size_t maxMemory,
     createParam( hOutputTriggerBaseSensor0String, asynParamInt32,   &hOutputTriggerBaseSensor0); 
     createParam( hOutputTriggerBaseSensor1String, asynParamInt32,   &hOutputTriggerBaseSensor1); 
     createParam( hOutputTriggerBaseSensor2String, asynParamInt32,   &hOutputTriggerBaseSensor2); 
-    createParam( hOutputTriggerPreHsyncCount0String, asynParamInt32, &hOutputTriggerPreHsyncCount0);
-    createParam( hOutputTriggerPreHsyncCount1String, asynParamInt32, &hOutputTriggerPreHsyncCount1);
-    createParam( hOutputTriggerPreHsyncCount2String, asynParamInt32, &hOutputTriggerPreHsyncCount2);
+    createParam( hOutputTriggerPreHsyncCountString, asynParamInt32, &hOutputTriggerPreHsyncCount);
  
 //Master Puls
     createParam( hMasterPulseModeString,          asynParamInt32,   &hMasterPulseMode);
@@ -285,6 +283,19 @@ int Hama::initCamera(){
 
    // MASTER PULSE ------------------------------------------ 
    // SYNCHRONOUS TIMING ------------------------------------ 
+
+   err |= getParameter( DCAM_IDPROP_TIMING_READOUTTIME);
+   err |= getParameter( DCAM_IDPROP_TIMING_CYCLICTRIGGERPERIOD);
+   err |= getParameter( DCAM_IDPROP_TIMING_MINTRIGGERBLANKING);
+   err |= getParameter( DCAM_IDPROP_TIMING_MINTRIGGERINTERVAL);
+   err |= getParameter( DCAM_IDPROP_TIMING_GLOBALEXPOSUREDELAY);
+   err |= getParameter( DCAM_IDPROP_TIMING_EXPOSURE);
+   err |= getParameter( DCAM_IDPROP_TIMING_INVALIDEXPOSUREPERIOD);
+   err |= getParameter( DCAM_IDPROP_INTERNALFRAMERATE);
+   err |= getParameter( DCAM_IDPROP_INTERNAL_FRAMEINTERVAL);
+   err |= getParameter( DCAM_IDPROP_INTERNALLINESPEED);
+   err |= getParameter( DCAM_IDPROP_INTERNAL_LINEINTERVAL);
+
    // SYSTEM INFORMATION ------------------------------------ 
    err |= getParameter(DCAM_IDPROP_COLORTYPE);
    err |= getParameter(DCAM_IDPROP_BITSPERCHANNEL);
@@ -539,6 +550,50 @@ asynStatus Hama::getParameter(int propertyID){
    // - master pulse
 
    // - 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:
@@ -765,6 +820,18 @@ void Hama::imageTask(){
                                 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);
@@ -816,21 +883,28 @@ void Hama::imageTask(){
 //============================================================================
 void Hama::temperatureTask(){
    static const char *functionName = "tempTask";
-//   asynStatus  status = asynSuccess;
-   double value = 0;
+   asynStatus  status = asynSuccess;
+   double dvalue = 0;
 
    while( !stopThread ) {
-      m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SENSORTEMPERATURE, &value);
 
-      if(m_err != DCAMERR_SUCCESS){
+      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);
       }
-      else{
-        setDoubleParam(hSensorTemperature, value);
-        //printf("Temperature = %f\n",value);
-      }
 
       callParamCallbacks();
       epicsThreadSleep(1.0);
@@ -1246,13 +1320,14 @@ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value){
         printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
       }
    }
-   else if (index == hOutputTriggerPreHsyncCount0) {
+   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);
       }
    }
+
    else if (index == hMasterPulseMode) {
       printf("[DEBUG]::writeInit32 MasterPulseMode %d\n", value); 
       m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_MASTERPULSE_MODE, &dvalue);
@@ -1274,7 +1349,6 @@ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value){
         printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
       }
    }
- 
    else if (index == hMasterPulseBurstTimes) {
       printf("[DEBUG]::writeInit32 MasterPulseBurstTimes %d\n", value); 
       m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_MASTERPULSE_BURSTTIMES, &dvalue);
@@ -1282,6 +1356,7 @@ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value){
         printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
       }
    }
+
    else if (index == hSystemAlive) {
       printf("[DEBUG]::writeInit32 SystemAlive %d\n", value); 
       m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SYSTEM_ALIVE, &dvalue);
@@ -1328,7 +1403,7 @@ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value){
       if(index < FIRST_HAMA_PARAM){
           status = ADDriver::writeInt32(pasynUser, value);
           printf("[+DEBUG]:: ADDriver::writeInit32 %s\n", paramName); 
-          ADDriver::writeInt32(pasynUser, value);
+          //ADDriver::writeInt32(pasynUser, value);
       }
       else{
           printf("[-DEBUG]::function writeInt32 did not find a parameter index = %d, %s\n", index, paramName); 
@@ -1336,9 +1411,8 @@ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value){
    }
 
    setIntegerParam(index, value);
-
     /* Do callbacks so higher layers see any changes */
-   //status = (asynStatus) callParamCallbacks();
+   status = (asynStatus) callParamCallbacks();
 
    if (status)
         asynPrint(pasynUser, ASYN_TRACE_ERROR,
@@ -1435,10 +1509,19 @@ asynStatus Hama::writeFloat64(asynUser *pasynUser, epicsFloat64 value){
       }
     }
     else if (index == hInternalFrameRate) {
-      printf("[DEBUG]::function InternalFrameRate %f\n", value); 
-      m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_INTERNALFRAMERATE, &dvalue);
-      if(failed(m_err)) {
+      int sensorMode = 0;
+      getIntegerParam(hSensorMode, &sensorMode);
+      printf("[DEBUG]::function InternalFrameRate %f, %d, %d\n", value, hSensorMode, sensorMode); 
+      printf("[DEBUG]::DCAMPROP_SENSORMODE__AREA = %d, DCAMPROP_SENSORMODE__SPLITVIEW = %d\n", 
+                                      DCAMPROP_SENSORMODE__AREA, DCAMPROP_SENSORMODE__SPLITVIEW); 
+      if((sensorMode != DCAMPROP_SENSORMODE__AREA) && (sensorMode != DCAMPROP_SENSORMODE__SPLITVIEW)){  
+         m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_INTERNALFRAMERATE, &dvalue);
+         if(failed(m_err)) {
            printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
+         }
+      }
+      else{
+         m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_INTERNALFRAMERATE, &dvalue);
       }
     }
     else if (index == hInternalFrameInterval) {
@@ -1512,9 +1595,13 @@ asynStatus Hama::writeFloat64(asynUser *pasynUser, epicsFloat64 value){
       }
     }
     else{
-      status = ADDriver::writeFloat64(pasynUser, value);
-      printf("Call function ADDriver::writeFloat64\n");
-      printf("[DEBUG]::function writeFloat64 did not find a parameter\n"); 
+       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); 
+      }
     }
 
    setDoubleParam(index, value);
@@ -1528,8 +1615,6 @@ asynStatus Hama::writeFloat64(asynUser *pasynUser, epicsFloat64 value){
         asynPrint(pasynUser, ASYN_TRACEIO_DRIVER,
               "%s:%s: function=%d, paramName=%s, value=%f\n",
               driverName, functionName, index, paramName, value);
-
-
     
 return(asynSuccess);
 }

ADHamaApp/src/hama.h

@@ -81,9 +81,7 @@
 #define hOutputTriggerBaseSensor0String	"H_OUTPUT_TRIGGER_BASE_SENSOR0"	/* asynInt32  rw */
 #define hOutputTriggerBaseSensor1String	"H_OUTPUT_TRIGGER_BASE_SENSOR1"	/* asynInt32  rw */
 #define hOutputTriggerBaseSensor2String	"H_OUTPUT_TRIGGER_BASE_SENSOR2"	/* asynInt32  rw */
-#define hOutputTriggerPreHsyncCount0String	"H_OUTPUT_TRIGGER_PRE_HSYNC_COUNT0"	/* asynInt32  rw */	
-#define hOutputTriggerPreHsyncCount1String	"H_OUTPUT_TRIGGER_PRE_HSYNC_COUNT1"	/* asynInt32  rw */	
-#define hOutputTriggerPreHsyncCount2String	"H_OUTPUT_TRIGGER_PRE_HSYNC_COUNT2"	/* asynInt32  rw */	
+#define hOutputTriggerPreHsyncCountString	"H_OUTPUT_TRIGGER_PRE_HSYNC_COUNT"	/* asynInt32  rw */	
 
 // Master Puls
 #define hMasterPulseModeString			"H_MASTERPULSE_MODE"			/* asynInt32  rw */
@@ -220,9 +218,7 @@ protected:
     int hOutputTriggerBaseSensor0;
     int hOutputTriggerBaseSensor1;
     int hOutputTriggerBaseSensor2;
-    int hOutputTriggerPreHsyncCount0;
-    int hOutputTriggerPreHsyncCount1;
-    int hOutputTriggerPreHsyncCount2;
+    int hOutputTriggerPreHsyncCount;
     // - master pulse
     int hMasterPulseMode;
     int hMasterPulseTriggerSource;