From 90d571bb43bd9a3fc52a91774f2754cf5df8c183 Mon Sep 17 00:00:00 2001 From: Iocuser Date: Thu, 2 Feb 2023 17:21:27 +0100 Subject: [PATCH 1/9] add readAtributes, readSensor functions --- ADHamaApp/src/hama.cpp | 133 ++++++++++++++++++++++++++--------------- ADHamaApp/src/hama.h | 8 ++- 2 files changed, 92 insertions(+), 49 deletions(-) diff --git a/ADHamaApp/src/hama.cpp b/ADHamaApp/src/hama.cpp index 3525d4d..7694367 100644 --- a/ADHamaApp/src/hama.cpp +++ b/ADHamaApp/src/hama.cpp @@ -393,6 +393,86 @@ int Hama::getParameterStr(int propertyID){ return int(status); } + +//============================================================================ +asynStatus Hama::readAttributes(){ + + asynStatus status = asynSuccess; + + getParameter( DCAM_IDPROP_COLORTYPE ); + //status |= getParameter( DCAM_IDPROP_BITSPERCHANNEL ); + status = getParameter( DCAM_IDPROP_IMAGE_ROWBYTES ); + status = getParameter( DCAM_IDPROP_IMAGE_FRAMEBYTES ); + status = getParameter( DCAM_IDPROP_IMAGE_TOPOFFSETBYTES ); + //status |= getParameter( DCAM_IDPROP_IMAGE_PIXELTYPE ); + status = getParameter( DCAM_IDPROP_BUFFER_ROWBYTES ); + status = getParameter( DCAM_IDPROP_BUFFER_FRAMEBYTES ); + status = getParameter( DCAM_IDPROP_BUFFER_TOPOFFSETBYTES ); + status = getParameter( DCAM_IDPROP_BUFFER_PIXELTYPE ); + status = getParameter( DCAM_IDPROP_RECORDFIXEDBYTES_PERFILE ); + status = getParameter( DCAM_IDPROP_RECORDFIXEDBYTES_PERSESSION ); + status = getParameter( DCAM_IDPROP_RECORDFIXEDBYTES_PERFRAME ); + status = getParameter( DCAM_IDPROP_SYSTEM_ALIVE ); + status = getParameter( DCAM_IDPROP_CONVERSIONFACTOR_COEFF ); + status = getParameter( DCAM_IDPROP_CONVERSIONFACTOR_OFFSET ); + status = getParameter( DCAM_IDPROP_NUMBEROF_VIEW ); + +return status; +} + + +//============================================================================ +asynStatus Hama::readSensor(){ + + + asynStatus status = asynSuccess; + + int minH=0, minV=0, sizeH=0, sizeV=0, binning=1; + double dminH=0, dminV=0, dsizeH=0, dsizeV=0, dbinning=1; + double dvalue = 0; + + getIntegerParam(ADMinX, &minH); + getIntegerParam(ADMinY, &minV); + getIntegerParam(ADSizeX, &sizeH); + getIntegerParam(ADSizeY, &sizeV); + getIntegerParam(hBinning, &binning); + + + 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, &dvalue); + m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &dvalue); + //m_err = dcamprop_getvalue(m_hdcam, , &dvalue); + + + + + m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYMODE, &modeON); + + + callParamCallbacks(); + +return status; +} + + //============================================================================ asynStatus Hama::getParameter(int propertyID){ @@ -959,16 +1039,16 @@ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value){ printf("[DEBUG]::writeInit32 ADNumExposures\n"); } else if (index == ADMinX) { - updateSensorSize(); + readSensor(); } else if (index == ADMinY) { - updateSensorSize(); + readSensor(); } else if (index == ADSizeX) { - updateSensorSize(); + readSensor(); } else if (index == ADSizeY) { - updateSensorSize(); + readSensor(); } else if (index == ADReadStatus) { // dcamprop_setvalue(m_hdcam, DCAM_IDPROP_, value); @@ -1066,7 +1146,7 @@ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value){ */ //-- binning and ROI else if (index == hBinning) { - updateSensorSize(); + readSensor(); printf("[DEBUG]::writeInit32 Binning %d\n", value); } else if (index == hSubarrayHPos) { @@ -1746,49 +1826,6 @@ asynStatus Hama::writeFloat64(asynUser *pasynUser, epicsFloat64 value){ return status; } -//============================================================================ -asynStatus Hama::updateSensorSize(){ - - - asynStatus status = asynSuccess; - - int minH=0, minV=0, sizeH=0, sizeV=0, binning=1; - double dminH=0, dminV=0, dsizeH=0, dsizeV=0, dbinning=1; - double dvalue = 0; - - getIntegerParam(ADMinX, &minH); - getIntegerParam(ADMinY, &minV); - getIntegerParam(ADSizeX, &sizeH); - getIntegerParam(ADSizeY, &sizeV); - getIntegerParam(hBinning, &binning); - - - 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_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYMODE, &modeON); - - - callParamCallbacks(); - -return status; -} //============================================================================ void Hama::report(FILE *fp, int details){ diff --git a/ADHamaApp/src/hama.h b/ADHamaApp/src/hama.h index 1132aa0..9e5bfda 100644 --- a/ADHamaApp/src/hama.h +++ b/ADHamaApp/src/hama.h @@ -289,10 +289,15 @@ private: int allocateBuffers(unsigned int); int freeBuffers(); + // These function will be read only once int connectCamera(); int disconnectCamera(); int initCamera(); - asynStatus updateSensorSize(); + + // These function can be read more than once + asynStatus readAttributes(); + asynStatus readSensor(); + asynStatus getParameter(int paramIndex); @@ -303,6 +308,7 @@ private: int setParameter(int paramIndex); int getParameterStr(int paramIndex); int getProperties(); + asynStatus setFeature(int featureIndex, double value); }; From 37607c5f23a6a22b83205873882eb5690b15436d Mon Sep 17 00:00:00 2001 From: Iocuser Date: Mon, 6 Feb 2023 13:20:07 +0100 Subject: [PATCH 2/9] Add adpluginkafka --- cmds/st.cmd | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/cmds/st.cmd b/cmds/st.cmd index ac29702..b693a0f 100644 --- a/cmds/st.cmd +++ b/cmds/st.cmd @@ -1,5 +1,6 @@ # This should be a test startup script require adhama +require adpluginkafka epicsEnvSet("PREFIX", "Hama:") @@ -36,6 +37,15 @@ dbLoadRecords("$(adcore_DIR)/db/NDPva.template", "P=$(PREFIX),R=Pva1:, PORT=PVA NDStdArraysConfigure("Image1", "$(QSIZE)", 0, "$(PORT)", 0, 0) dbLoadRecords("NDStdArrays.template", "P=$(PREFIX),R=image1:,PORT=Image1,ADDR=0,TIMEOUT=1,NDARRAY_PORT=$(PORT),TYPE=Int32,FTVL=LONG,NELEMENTS=$(NELEMENTS)") +# Create a kafka plugin, set it to get data from hama driver. +epicsEnvSet("KFK_SERVER_IP", "10.100.1.19") +epicsEnvSet("KFK_SERVER_PORT", "9092") +epicsEnvSet("KFK_TOPIC", "ymir_camera") + +KafkaPluginConfigure("KFK1", 3, 1, "$(PORT)", 0, -1, "$(KFK_SERVER_IP):$(KFK_SERVER_PORT)", "$(KFK_TOPIC)", "hama_source") +dbLoadRecords("$(adpluginkafka_DIR)db/adpluginkafka.db", "P=$(PREFIX), R=Kfk1:, PORT=KFK1, ADDR=0, TIMEOUT=1, NDARRAY_PORT=$(PORT)") + + startPVAServer # @@ -49,6 +59,7 @@ iocInit() dbpf Hama:cam1:PoolUsedMem.SCAN 0 dbpf Hama:image1:EnableCallbacks 1 +dbpf Hama:Kfk1:EnableCallbacks 1 epicsThreadSleep(1.0) From 7dc9fd7cb332a3bd0bc4fd809241316bd26a2edf Mon Sep 17 00:00:00 2001 From: Iocuser Date: Thu, 2 Feb 2023 17:21:27 +0100 Subject: [PATCH 3/9] add readAtributes, readSensor functions --- ADHamaApp/src/hama.cpp | 133 ++++++++++++++++++++++++++--------------- ADHamaApp/src/hama.h | 8 ++- 2 files changed, 92 insertions(+), 49 deletions(-) diff --git a/ADHamaApp/src/hama.cpp b/ADHamaApp/src/hama.cpp index 3525d4d..7694367 100644 --- a/ADHamaApp/src/hama.cpp +++ b/ADHamaApp/src/hama.cpp @@ -393,6 +393,86 @@ int Hama::getParameterStr(int propertyID){ return int(status); } + +//============================================================================ +asynStatus Hama::readAttributes(){ + + asynStatus status = asynSuccess; + + getParameter( DCAM_IDPROP_COLORTYPE ); + //status |= getParameter( DCAM_IDPROP_BITSPERCHANNEL ); + status = getParameter( DCAM_IDPROP_IMAGE_ROWBYTES ); + status = getParameter( DCAM_IDPROP_IMAGE_FRAMEBYTES ); + status = getParameter( DCAM_IDPROP_IMAGE_TOPOFFSETBYTES ); + //status |= getParameter( DCAM_IDPROP_IMAGE_PIXELTYPE ); + status = getParameter( DCAM_IDPROP_BUFFER_ROWBYTES ); + status = getParameter( DCAM_IDPROP_BUFFER_FRAMEBYTES ); + status = getParameter( DCAM_IDPROP_BUFFER_TOPOFFSETBYTES ); + status = getParameter( DCAM_IDPROP_BUFFER_PIXELTYPE ); + status = getParameter( DCAM_IDPROP_RECORDFIXEDBYTES_PERFILE ); + status = getParameter( DCAM_IDPROP_RECORDFIXEDBYTES_PERSESSION ); + status = getParameter( DCAM_IDPROP_RECORDFIXEDBYTES_PERFRAME ); + status = getParameter( DCAM_IDPROP_SYSTEM_ALIVE ); + status = getParameter( DCAM_IDPROP_CONVERSIONFACTOR_COEFF ); + status = getParameter( DCAM_IDPROP_CONVERSIONFACTOR_OFFSET ); + status = getParameter( DCAM_IDPROP_NUMBEROF_VIEW ); + +return status; +} + + +//============================================================================ +asynStatus Hama::readSensor(){ + + + asynStatus status = asynSuccess; + + int minH=0, minV=0, sizeH=0, sizeV=0, binning=1; + double dminH=0, dminV=0, dsizeH=0, dsizeV=0, dbinning=1; + double dvalue = 0; + + getIntegerParam(ADMinX, &minH); + getIntegerParam(ADMinY, &minV); + getIntegerParam(ADSizeX, &sizeH); + getIntegerParam(ADSizeY, &sizeV); + getIntegerParam(hBinning, &binning); + + + 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, &dvalue); + m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &dvalue); + //m_err = dcamprop_getvalue(m_hdcam, , &dvalue); + + + + + m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYMODE, &modeON); + + + callParamCallbacks(); + +return status; +} + + //============================================================================ asynStatus Hama::getParameter(int propertyID){ @@ -959,16 +1039,16 @@ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value){ printf("[DEBUG]::writeInit32 ADNumExposures\n"); } else if (index == ADMinX) { - updateSensorSize(); + readSensor(); } else if (index == ADMinY) { - updateSensorSize(); + readSensor(); } else if (index == ADSizeX) { - updateSensorSize(); + readSensor(); } else if (index == ADSizeY) { - updateSensorSize(); + readSensor(); } else if (index == ADReadStatus) { // dcamprop_setvalue(m_hdcam, DCAM_IDPROP_, value); @@ -1066,7 +1146,7 @@ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value){ */ //-- binning and ROI else if (index == hBinning) { - updateSensorSize(); + readSensor(); printf("[DEBUG]::writeInit32 Binning %d\n", value); } else if (index == hSubarrayHPos) { @@ -1746,49 +1826,6 @@ asynStatus Hama::writeFloat64(asynUser *pasynUser, epicsFloat64 value){ return status; } -//============================================================================ -asynStatus Hama::updateSensorSize(){ - - - asynStatus status = asynSuccess; - - int minH=0, minV=0, sizeH=0, sizeV=0, binning=1; - double dminH=0, dminV=0, dsizeH=0, dsizeV=0, dbinning=1; - double dvalue = 0; - - getIntegerParam(ADMinX, &minH); - getIntegerParam(ADMinY, &minV); - getIntegerParam(ADSizeX, &sizeH); - getIntegerParam(ADSizeY, &sizeV); - getIntegerParam(hBinning, &binning); - - - 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_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYMODE, &modeON); - - - callParamCallbacks(); - -return status; -} //============================================================================ void Hama::report(FILE *fp, int details){ diff --git a/ADHamaApp/src/hama.h b/ADHamaApp/src/hama.h index 1132aa0..9e5bfda 100644 --- a/ADHamaApp/src/hama.h +++ b/ADHamaApp/src/hama.h @@ -289,10 +289,15 @@ private: int allocateBuffers(unsigned int); int freeBuffers(); + // These function will be read only once int connectCamera(); int disconnectCamera(); int initCamera(); - asynStatus updateSensorSize(); + + // These function can be read more than once + asynStatus readAttributes(); + asynStatus readSensor(); + asynStatus getParameter(int paramIndex); @@ -303,6 +308,7 @@ private: int setParameter(int paramIndex); int getParameterStr(int paramIndex); int getProperties(); + asynStatus setFeature(int featureIndex, double value); }; From e7d48816d25afd0e45edeb770d5b6eeaaa28ea36 Mon Sep 17 00:00:00 2001 From: Iocuser Date: Mon, 6 Feb 2023 13:20:07 +0100 Subject: [PATCH 4/9] Add adpluginkafka --- cmds/st.cmd | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/cmds/st.cmd b/cmds/st.cmd index ac29702..b693a0f 100644 --- a/cmds/st.cmd +++ b/cmds/st.cmd @@ -1,5 +1,6 @@ # This should be a test startup script require adhama +require adpluginkafka epicsEnvSet("PREFIX", "Hama:") @@ -36,6 +37,15 @@ dbLoadRecords("$(adcore_DIR)/db/NDPva.template", "P=$(PREFIX),R=Pva1:, PORT=PVA NDStdArraysConfigure("Image1", "$(QSIZE)", 0, "$(PORT)", 0, 0) dbLoadRecords("NDStdArrays.template", "P=$(PREFIX),R=image1:,PORT=Image1,ADDR=0,TIMEOUT=1,NDARRAY_PORT=$(PORT),TYPE=Int32,FTVL=LONG,NELEMENTS=$(NELEMENTS)") +# Create a kafka plugin, set it to get data from hama driver. +epicsEnvSet("KFK_SERVER_IP", "10.100.1.19") +epicsEnvSet("KFK_SERVER_PORT", "9092") +epicsEnvSet("KFK_TOPIC", "ymir_camera") + +KafkaPluginConfigure("KFK1", 3, 1, "$(PORT)", 0, -1, "$(KFK_SERVER_IP):$(KFK_SERVER_PORT)", "$(KFK_TOPIC)", "hama_source") +dbLoadRecords("$(adpluginkafka_DIR)db/adpluginkafka.db", "P=$(PREFIX), R=Kfk1:, PORT=KFK1, ADDR=0, TIMEOUT=1, NDARRAY_PORT=$(PORT)") + + startPVAServer # @@ -49,6 +59,7 @@ iocInit() dbpf Hama:cam1:PoolUsedMem.SCAN 0 dbpf Hama:image1:EnableCallbacks 1 +dbpf Hama:Kfk1:EnableCallbacks 1 epicsThreadSleep(1.0) From b6de30a14443cb4b10500d2cf4786abe6dcf4af8 Mon Sep 17 00:00:00 2001 From: Iocuser Date: Mon, 6 Feb 2023 16:37:54 +0100 Subject: [PATCH 5/9] check and update getParameters --- ADHamaApp/src/hama.cpp | 141 ++++++++++++++++++++++++++++++++++------- 1 file changed, 117 insertions(+), 24 deletions(-) diff --git a/ADHamaApp/src/hama.cpp b/ADHamaApp/src/hama.cpp index 7694367..803e2aa 100644 --- a/ADHamaApp/src/hama.cpp +++ b/ADHamaApp/src/hama.cpp @@ -480,22 +480,22 @@ asynStatus Hama::getParameter(int propertyID){ double dvalue = 0; switch (propertyID){ - // - sensor mode and speed - case DCAM_IDPROP_SENSORMODE: + // - sensor mode and speed + case DCAM_IDPROP_SENSORMODE: //(RW1--) m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SENSORMODE, &dvalue); if(failed(m_err)) { printError(m_hdcam, m_err, "SENSOR MODE", "IDPROP:0x%08x, VALUE:%f\n", propertyID, dvalue); } status = setIntegerParam(hSensorMode, dvalue); break; - case DCAM_IDPROP_READOUTSPEED: + case DCAM_IDPROP_READOUTSPEED: //(RW1--) m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_READOUTSPEED, &dvalue); if(failed(m_err)) { printError(m_hdcam, m_err, "READOUT SPEED", "IDPROP:0x%08x, VALUE:%f\n", propertyID, dvalue); } status = setIntegerParam(hReadoutSpeed, dvalue); break; - case DCAM_IDPROP_READOUT_DIRECTION: + case DCAM_IDPROP_READOUT_DIRECTION: // (RW1--) m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_READOUT_DIRECTION, &dvalue); if(failed(m_err)) { printError(m_hdcam, m_err, "R DIRECTION", "IDPROP:0x%08x, VALUE:%f\n", propertyID, dvalue); @@ -503,92 +503,104 @@ asynStatus Hama::getParameter(int propertyID){ status = setIntegerParam(hReadoutDirection, dvalue); break; // - trigger - case DCAM_IDPROP_TRIGGERSOURCE: + 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: + 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: + 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: + 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: + 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: + 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: + case DCAM_IDPROP_TRIGGERTIMES: //(RW123) m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGERTIMES, &dvalue); status = setIntegerParam(hTriggerTimes, dvalue); break; - case DCAM_IDPROP_TRIGGERDELAY: + 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: + 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: + 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: + case DCAM_IDPROP_BINNING: //(RW1--) m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_BINNING, &dvalue); status = setIntegerParam(hBinning, dvalue); break; - case DCAM_IDPROP_SUBARRAYHSIZE: + case DCAM_IDPROP_SUBARRAYHSIZE: //(RW1--) m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHSIZE, &dvalue); status = setIntegerParam(ADSizeX, dvalue); break; - case DCAM_IDPROP_SUBARRAYVSIZE: + case DCAM_IDPROP_SUBARRAYVSIZE: //(RW1--) m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVSIZE, &dvalue); status = setIntegerParam(ADSizeY, dvalue); break; - case DCAM_IDPROP_SUBARRAYHPOS: + case DCAM_IDPROP_SUBARRAYHPOS: //(RW---) m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHPOS, &dvalue); status = setIntegerParam(ADMinX, dvalue); break; - case DCAM_IDPROP_SUBARRAYVPOS: + 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: + 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: + 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: + 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: + 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: + case DCAM_IDPROP_EXTRACTION_MODE: //(RW1--) m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_EXTRACTION_MODE, &dvalue); status = setIntegerParam(hExtractionMode, dvalue); break; @@ -598,6 +610,25 @@ asynStatus Hama::getParameter(int propertyID){ 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); @@ -607,7 +638,69 @@ asynStatus Hama::getParameter(int propertyID){ 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: From 27dabf4fdcde1c382586cd75c2d573b0c7ff5605 Mon Sep 17 00:00:00 2001 From: Iocuser Date: Wed, 8 Feb 2023 11:33:44 +0100 Subject: [PATCH 6/9] remove comments and old code --- ADHamaApp/src/hama.cpp | 534 +++++++++-------------------------------- ADHamaApp/src/hama.h | 22 +- 2 files changed, 127 insertions(+), 429 deletions(-) diff --git a/ADHamaApp/src/hama.cpp b/ADHamaApp/src/hama.cpp index 803e2aa..e235a6f 100644 --- a/ADHamaApp/src/hama.cpp +++ b/ADHamaApp/src/hama.cpp @@ -193,16 +193,6 @@ Hama::Hama(const char* portName, int cameraId, int maxBuffers, size_t maxMemory, printf("\n\n============================ Init Camera =========================\n"); initCamera(); - - printf("[DEBUG]:: FIRST_HAMA_PARAM = %d \n", FIRST_HAMA_PARAM); - //printf("[-DEBUG]:: FIRST_HAMA_PARAM = %d / LAST_HAMA_PARAM = %d, %d)\n", - //FIRST_HAMA_PARAM, LAST_HAMA_PARAM, NUM_HAMA_PARAMS); - - // printf("\n\n============================ Info Camera =========================\n"); - //dcamcon_show_dcamdev_info( m_hdcam ); - //printf("\n\n============================ Info Camera Details =================\n"); - //dcamcon_show_dcamdev_info_detail( m_hdcam ) - printf("\n\n============================ Start Threads =======================\n"); /* launch image read task */ epicsThreadCreate("HamaImageTask", @@ -233,93 +223,94 @@ int Hama::initCamera(){ int err = 0; - err |= getParameterStr(DCAM_IDSTR_VENDOR); - err |= getParameterStr(DCAM_IDSTR_MODEL); - err |= getParameterStr(DCAM_IDSTR_CAMERAID); - err |= getParameterStr(DCAM_IDSTR_BUS); - err |= getParameterStr(DCAM_IDSTR_CAMERAVERSION); - err |= getParameterStr(DCAM_IDSTR_DRIVERVERSION); - err |= getParameterStr(DCAM_IDSTR_MODULEVERSION); - err |= getParameterStr(DCAM_IDSTR_DCAMAPIVERSION); + 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 |= getParameter(DCAM_IDPROP_SENSORMODE); - err |= getParameter(DCAM_IDPROP_READOUTSPEED); - err |= getParameter(DCAM_IDPROP_READOUT_DIRECTION); + err |= readParameter(DCAM_IDPROP_SENSORMODE); + err |= readParameter(DCAM_IDPROP_READOUTSPEED); + err |= readParameter(DCAM_IDPROP_READOUT_DIRECTION); // TRIGGER -------------------------------------- - err |= getParameter(DCAM_IDPROP_TRIGGERSOURCE); - err |= getParameter(DCAM_IDPROP_TRIGGER_MODE); - err |= getParameter(DCAM_IDPROP_TRIGGERACTIVE); - err |= getParameter(DCAM_IDPROP_TRIGGER_GLOBALEXPOSURE); - err |= getParameter(DCAM_IDPROP_TRIGGERPOLARITY); - err |= getParameter(DCAM_IDPROP_TRIGGER_CONNECTOR); - err |= getParameter(DCAM_IDPROP_TRIGGERTIMES); - err |= getParameter(DCAM_IDPROP_TRIGGERDELAY); - err |= getParameter(DCAM_IDPROP_INTERNALTRIGGER_HANDLING); + 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 |= getParameter( DCAM_IDPROP_BINNING); - err |= getParameter( DCAM_IDPROP_SUBARRAYHPOS); - err |= getParameter( DCAM_IDPROP_SUBARRAYVPOS); - err |= getParameter( DCAM_IDPROP_SUBARRAYHSIZE); - err |= getParameter( DCAM_IDPROP_SUBARRAYVSIZE); - err |= getParameter( DCAM_IDPROP_IMAGE_FRAMEBYTES); - err |= getParameter( DCAM_IDPROP_IMAGE_PIXELTYPE); - err |= getParameter( DCAM_IDPROP_IMAGE_WIDTH); - err |= getParameter( DCAM_IDPROP_IMAGE_ROWBYTES); - err |= getParameter( DCAM_IDPROP_IMAGE_HEIGHT); - //SUBARRAYMODE + 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 + + // EXPOSURETIME ------------------------------------------ // ALU --------------------------------------------------- - err |= getParameter( DCAM_IDPROP_DEFECTCORRECT_MODE); - err |= getParameter( DCAM_IDPROP_HOTPIXELCORRECT_LEVEL); - err |= getParameter( DCAM_IDPROP_INTENSITYLUT_MODE); - err |= getParameter( DCAM_IDPROP_INTENSITYLUT_PAGE); - err |= getParameter( DCAM_IDPROP_EXTRACTION_MODE); + 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 |= getParameter(DCAM_IDPROP_OUTPUTTRIGGER_ACTIVE); - err |= getParameter(DCAM_IDPROP_NUMBEROF_OUTPUTTRIGGERCONNECTOR); + err |= readParameter(DCAM_IDPROP_OUTPUTTRIGGER_ACTIVE); + err |= readParameter(DCAM_IDPROP_NUMBEROF_OUTPUTTRIGGERCONNECTOR); // 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); + 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 |= getParameter(DCAM_IDPROP_COLORTYPE); - err |= getParameter(DCAM_IDPROP_BITSPERCHANNEL); - err |= getParameter(DCAM_IDPROP_IMAGE_TOPOFFSETBYTES); - err |= getParameter(DCAM_IDPROP_BUFFER_ROWBYTES); - err |= getParameter(DCAM_IDPROP_BUFFER_FRAMEBYTES); - err |= getParameter(DCAM_IDPROP_BUFFER_TOPOFFSETBYTES); - err |= getParameter(DCAM_IDPROP_BUFFER_PIXELTYPE); - err |= getParameter(DCAM_IDPROP_RECORDFIXEDBYTES_PERFILE); - err |= getParameter(DCAM_IDPROP_RECORDFIXEDBYTES_PERSESSION); - err |= getParameter(DCAM_IDPROP_RECORDFIXEDBYTES_PERFRAME); - err |= getParameter(DCAM_IDPROP_SYSTEM_ALIVE); - err |= getParameter(DCAM_IDPROP_CONVERSIONFACTOR_COEFF); - err |= getParameter(DCAM_IDPROP_CONVERSIONFACTOR_OFFSET); - err |= getParameter(DCAM_IDPROP_NUMBEROF_VIEW); - err |= getParameter(DCAM_IDPROP_TIMESTAMP_PRODUCER); - err |= getParameter(DCAM_IDPROP_FRAMESTAMP_PRODUCER); + 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 |= getParameter(DETECTOR_PIXEL_NUM_HORZ); - err |= getParameter(DETECTOR_PIXEL_NUM_VERT); + err |= readParameter(DETECTOR_PIXEL_NUM_HORZ); + err |= readParameter(DETECTOR_PIXEL_NUM_VERT); if(err){ @@ -330,7 +321,7 @@ return err; } //============================================================================ -int Hama::getParameterStr(int propertyID){ +int Hama::readParameterStr(int propertyID){ asynStatus status = asynSuccess; @@ -391,33 +382,33 @@ int Hama::getParameterStr(int propertyID){ callParamCallbacks(); -return int(status); +return status; } //============================================================================ asynStatus Hama::readAttributes(){ - asynStatus status = asynSuccess; + int status = 0; - getParameter( DCAM_IDPROP_COLORTYPE ); - //status |= getParameter( DCAM_IDPROP_BITSPERCHANNEL ); - status = getParameter( DCAM_IDPROP_IMAGE_ROWBYTES ); - status = getParameter( DCAM_IDPROP_IMAGE_FRAMEBYTES ); - status = getParameter( DCAM_IDPROP_IMAGE_TOPOFFSETBYTES ); - //status |= getParameter( DCAM_IDPROP_IMAGE_PIXELTYPE ); - status = getParameter( DCAM_IDPROP_BUFFER_ROWBYTES ); - status = getParameter( DCAM_IDPROP_BUFFER_FRAMEBYTES ); - status = getParameter( DCAM_IDPROP_BUFFER_TOPOFFSETBYTES ); - status = getParameter( DCAM_IDPROP_BUFFER_PIXELTYPE ); - status = getParameter( DCAM_IDPROP_RECORDFIXEDBYTES_PERFILE ); - status = getParameter( DCAM_IDPROP_RECORDFIXEDBYTES_PERSESSION ); - status = getParameter( DCAM_IDPROP_RECORDFIXEDBYTES_PERFRAME ); - status = getParameter( DCAM_IDPROP_SYSTEM_ALIVE ); - status = getParameter( DCAM_IDPROP_CONVERSIONFACTOR_COEFF ); - status = getParameter( DCAM_IDPROP_CONVERSIONFACTOR_OFFSET ); - status = getParameter( DCAM_IDPROP_NUMBEROF_VIEW ); + 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 status; +return (asynStatus)status; } @@ -474,7 +465,7 @@ return status; //============================================================================ -asynStatus Hama::getParameter(int propertyID){ +int Hama::readParameter(int propertyID){ asynStatus status = asynSuccess; double dvalue = 0; @@ -483,23 +474,14 @@ asynStatus Hama::getParameter(int propertyID){ // - sensor mode and speed case DCAM_IDPROP_SENSORMODE: //(RW1--) m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SENSORMODE, &dvalue); - if(failed(m_err)) { - printError(m_hdcam, m_err, "SENSOR MODE", "IDPROP:0x%08x, VALUE:%f\n", propertyID, dvalue); - } status = setIntegerParam(hSensorMode, dvalue); break; case DCAM_IDPROP_READOUTSPEED: //(RW1--) m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_READOUTSPEED, &dvalue); - if(failed(m_err)) { - printError(m_hdcam, m_err, "READOUT SPEED", "IDPROP:0x%08x, VALUE:%f\n", propertyID, dvalue); - } status = setIntegerParam(hReadoutSpeed, dvalue); break; case DCAM_IDPROP_READOUT_DIRECTION: // (RW1--) m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_READOUT_DIRECTION, &dvalue); - if(failed(m_err)) { - printError(m_hdcam, m_err, "R DIRECTION", "IDPROP:0x%08x, VALUE:%f\n", propertyID, dvalue); - } status = setIntegerParam(hReadoutDirection, dvalue); break; // - trigger @@ -819,30 +801,18 @@ asynStatus Hama::getParameter(int propertyID){ break; case DCAM_IDPROP_IMAGE_WIDTH: m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_WIDTH, &dvalue); - if(failed(m_err)) { - printError(m_hdcam, m_err, "IMAGE WIDTH", "IDPROP:0x%08x, VALUE:%f\n", propertyID, dvalue); - } status = setIntegerParam(ADBinX, dvalue); break; case DCAM_IDPROP_IMAGE_HEIGHT: m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_HEIGHT, &dvalue); - if(failed(m_err)) { - printError(m_hdcam, m_err, "IMAGE HEIGHT", "IDPROP:0x%08x, VALUE:%f\n", propertyID, dvalue); - } status = setIntegerParam(ADBinY, (int)dvalue); break; case DETECTOR_PIXEL_NUM_HORZ: m_err = dcamprop_getvalue(m_hdcam, DETECTOR_PIXEL_NUM_HORZ, &dvalue); - if(failed(m_err)) { - printError(m_hdcam, m_err, "DETECT)R_PIXEL_SIZE_HORZ", "IDPROP:0x%08x, VALUE:%f\n", propertyID, dvalue); - } status = setIntegerParam(ADMaxSizeX, dvalue); break; case DETECTOR_PIXEL_NUM_VERT: m_err = dcamprop_getvalue(m_hdcam, DETECTOR_PIXEL_NUM_VERT, &dvalue); - if(failed(m_err)) { - printError(m_hdcam, m_err, "DETECT)R_PIXEL_SIZE_VERT", "IDPROP:0x%08x, VALUE:%f\n", propertyID, dvalue); - } status = setIntegerParam(ADMaxSizeY, dvalue); break; case DCAM_IDPROP_TIMESTAMP_PRODUCER: @@ -868,29 +838,19 @@ asynStatus Hama::getParameter(int propertyID){ /* 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; } -//============================================================================ -int Hama::setParameter(int paramIndex){ -/* - setIntegerParam(ADBinY, 2048); - setIntegerParam(ADBinX, 2048); - setIntegerParam(NDNDimensions, 1); - setIntegerParam(NDArrayCounter, 1); - setIntegerParam(NDDataType, NDUInt16); - setIntegerParam(NDColorMode, NDColorModeMono); - setIntegerParam(NDArraySizeZ, 0); - setIntegerParam(NDArraySize, 5000000); - setStringParam(ADStringToServer, ""); - setStringParam(ADStringFromServer, ""); - setStringParam(ADManufacturer, "Hamamatsu"); -*/ - - -return 0; -} //============================================================================ void Hama::imageTask(){ @@ -1227,16 +1187,7 @@ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value){ printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue); } } - //-- sensor cooler - implemented in the temperature task - /* - else if (index == hSensorCoolerStatus) { - printf("[DEBUG]::writeInit32 SensorCoolerStatus %d\n", value); - m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SENSORCOOLERSTATUS, &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(); @@ -1308,6 +1259,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 == 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); @@ -1315,6 +1274,7 @@ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value){ 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); @@ -1360,28 +1320,6 @@ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value){ } } - else if (index == hOutputTriggerActive0) { - printf("[DEBUG]::writeInit32 OutputTriggerActive0 %d\n", value); - m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_ACTIVE, &dvalue); - if(failed(m_err)) { - printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue); - } - } - else if (index == hOutputTriggerActive1) { - printf("[DEBUG]::writeInit32 OutputTriggerActive1 %d\n", value); - m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_ACTIVE+0x100, &dvalue); - if(failed(m_err)) { - printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue); - } - } - else if (index == hOutputTriggerActive2) { - printf("[DEBUG]::writeInit32 OutputTriggerActive2 %d\n", value); - m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_ACTIVE+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); @@ -1447,13 +1385,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 == 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 == hMasterPulseBurstTimes) { printf("[DEBUG]::writeInit32 MasterPulseBurstTimes %d\n", value); m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_MASTERPULSE_BURSTTIMES, &dvalue); @@ -1471,57 +1403,6 @@ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value){ } } -/* - else if (index == hBufferRowbytes) { - printf("[DEBUG]::writeInit32 BufferRowBytes %d\n", value); - m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_BUFFER_ROWBYTES, &dvalue); - if(failed(m_err)) { - printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue); - } - } - else if (index == hTimingExposure) { - printf("[DEBUG]::writeInit32 TimingExposure %d\n", value); - m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TIMING_EXPOSURE, &dvalue); - if(failed(m_err)) { - printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue); - } - } - else if (index == ADBinX) { - printf("[DEBUG]::writeInit32 ImageWidth %d\n", value); - m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_WIDTH, &dvalue); - if(failed(m_err)) { - printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue); - } - } - else if (index == ADBinY) { - printf("[DEBUG]::writeInit32 ImageHeight %d\n", value); - m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_HEIGHT, &dvalue); - if(failed(m_err)) { - printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue); - } - } - else if (index == hImageRowbytes) { - printf("[DEBUG]::writeInit32 ImageRowBytes %d\n", value); - m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_IMAGE_ROWBYTES, &dvalue); - if(failed(m_err)) { - printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue); - } - } - else if (index == hImageFramebytes) { - printf("[DEBUG]::writeInit32 ImageFramBytes %d\n", value); - m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &dvalue); - if(failed(m_err)) { - printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue); - } - } - else if (index == hImageTopOffsetBytes) { - printf("[DEBUG]::writeInit32 ImageTopOffsetBytes %d\n", value); - m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_IMAGE_TOPOFFSETBYTES, &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); @@ -1529,99 +1410,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 == hBufferFramebytes) { - printf("[DEBUG]::writeInit32 BufferFrameBytes %d\n", value); - m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_BUFFER_FRAMEBYTES, &dvalue); - if(failed(m_err)) { - printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue); - } - } - else if (index == hBufferTopOffsetBytes) { - printf("[DEBUG]::writeInit32 BufferTopOffsetBytes %d\n", value); - m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_BUFFER_TOPOFFSETBYTES, &dvalue); - if(failed(m_err)) { - printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue); - } - } - else if (index == hBufferPixelType) { - printf("[DEBUG]::writeInit32 BufferPixelType %d\n", value); - m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_BUFFER_PIXELTYPE, &dvalue); - if(failed(m_err)) { - printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue); - } - } - else if (index == hRecordFixedBytesPerFile) { - printf("[DEBUG]::writeInit32 ecordFixedBytesPerFile %d\n", value); - m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_RECORDFIXEDBYTES_PERFILE, &dvalue); - if(failed(m_err)) { - printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue); - } - } - else if (index == hRecordFixedBytesPerSession) { - printf("[DEBUG]::writeInit32 RecordFixedBytesPerSesion %d\n", value); - m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_RECORDFIXEDBYTES_PERSESSION, &dvalue); - if(failed(m_err)) { - printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue); - } - } - else if (index == hRecordFixedBytesPerFrame) { - printf("[DEBUG]::writeInit32 RecordFixedBytesPerFrame %d\n", value); - m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_RECORDFIXEDBYTES_PERFRAME, &dvalue); - if(failed(m_err)) { - printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue); - } - } - //else if (index == hNumberOfOutputTriggerConnector) { - // printf("[DEBUG]::writeInit32 NumberOutputTriggerConnector %d\n", value); - // m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_NUMBEROF_OUTPUTTRIGGERCONNECTOR, &dvalue); - // if(failed(m_err)) { - // 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); - if(failed(m_err)) { - printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue); - } - } - else if (index == hNumberOfView) { - printf("[DEBUG]::writeInit32 NumberOfView %d\n", value); - m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_NUMBEROF_VIEW, &dvalue); - if(failed(m_err)) { - printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue); - } - } - else if (index == hImageDetectorPixelNumHorz) { - printf("[DEBUG]::writeInit32 ImageDetectorPixelNumHorz %d\n", value); - m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_IMAGEDETECTOR_PIXELHEIGHT, &dvalue); - if(failed(m_err)) { - printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue); - } - } - else if (index == hImageDetectorPixelNumVert) { - printf("[DEBUG]::writeInit32 ImageDetectorPixelNumVert %d\n", value); - m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_IMAGEDETECTOR_PIXELWIDTH, &dvalue); - if(failed(m_err)) { - printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue); - } - } - else if (index == hTimeStampProducer) { - printf("[DEBUG]::writeInit32 TimeStampProducer %d\n", value); - m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TIMESTAMP_PRODUCER, &dvalue); - if(failed(m_err)) { - printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue); - } - } - else if (index == hFrameStampProducer) { - printf("[DEBUG]::writeInit32 FrameStampProducer %d\n", value); - m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_FRAMESTAMP_PRODUCER, &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){ @@ -1783,72 +1571,6 @@ asynStatus Hama::writeFloat64(asynUser *pasynUser, epicsFloat64 value){ } } //-- Synchronous timing - /* - else if (index == hTimingReadoutTime) { - printf("[DEBUG]::function TimingReadoutTime %f\n", value); - m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TIMING_READOUTTIME, &dvalue); - if(failed(m_err)) { - printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue); - } - } - else if (index == hTimingCyclicTriggerPeriod) { - printf("[DEBUG]::function TimingCyclicTriggerPeriod %f\n", value); - m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TIMING_CYCLICTRIGGERPERIOD, &dvalue); - if(failed(m_err)) { - printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue); - } - } - else if (index == hTimingMinTriggerBlanking) { - printf("[DEBUG]::function TimingMinTriggerBlanking %f\n", value); - m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TIMING_MINTRIGGERBLANKING, &dvalue); - if(failed(m_err)) { - printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue); - } - } - else if (index == hTimingMinTriggerInterval) { - printf("[DEBUG]::function TimingMinTriggerInterval %f\n", value); - m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TIMING_MINTRIGGERINTERVAL, &dvalue); - if(failed(m_err)) { - printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue); - } - } - else if (index == hTimingGlobalExposureDelay) { - printf("[DEBUG]::function TimingGlobalExposureDelay %f\n", value); - m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TIMING_GLOBALEXPOSUREDELAY, &dvalue); - if(failed(m_err)) { - printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue); - } - } - else if (index == hTimingInvalidExposurePeriod) { - printf("[DEBUG]::function TimingEnvalidExposurePeriod %f\n", value); - m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TIMING_INVALIDEXPOSUREPERIOD, &dvalue); - if(failed(m_err)) { - printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue); - } - }*/ - - /* THESE PARAMETERS ARE READ ONLY - else if (index == hInternalFrameRate) { - int sensorMode = 0; - getIntegerParam(hSensorMode, &sensorMode); - 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) { - printf("[DEBUG]::function InternalFrameRate %f\n", value); - m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_INTERNAL_FRAMEINTERVAL, &dvalue); - if(failed(m_err)) { - printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue); - } - } - */ else if (index == hInternalLineSpeed) { printf("[DEBUG]::function InternalLineSpeed %f\n", value); @@ -1864,36 +1586,6 @@ asynStatus Hama::writeFloat64(asynUser *pasynUser, epicsFloat64 value){ printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue); } } - /* - else if (index == hConversionFactorCoeff) { - printf("[DEBUG]::function ConversionFactorCoeff %f\n", value); - m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_CONVERSIONFACTOR_COEFF, &dvalue); - if(failed(m_err)) { - printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue); - } - } - else if (index == hConversionFactorOffset) { - printf("[DEBUG]::function ConversionFactorOffset %f\n", value); - m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_CONVERSIONFACTOR_OFFSET, &dvalue); - if(failed(m_err)) { - printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue); - } - } - else if (index == hImageDetectorPixelWidth) { - printf("[DEBUG]::function ImageDetectorPixelWidth %f\n", value); - m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_IMAGEDETECTOR_PIXELWIDTH, &dvalue); - if(failed(m_err)) { - printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue); - } - } - else if (index == hImageDetectorPixelHeight) { - printf("[DEBUG]::function ImageDetectorPixelHeight %f\n", value); - m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_IMAGEDETECTOR_PIXELHEIGHT, &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); diff --git a/ADHamaApp/src/hama.h b/ADHamaApp/src/hama.h index 9e5bfda..7000c76 100644 --- a/ADHamaApp/src/hama.h +++ b/ADHamaApp/src/hama.h @@ -138,15 +138,20 @@ class epicsShareClass Hama : public ADDriver { public: Hama(const char*, int, int, size_t, int, int, int); -// ~Hama(); +// ~Hama(); /* override ADDriver methods */ virtual asynStatus writeInt32(asynUser *pasynUser, epicsInt32 value); virtual asynStatus writeFloat64(asynUser *pasynUser, epicsFloat64 value); - -// virtual asynStatus getBounds(asynUser *, epicsInt32 *low, epicsInt32 *high); - //virtual asynStatus readEnum(asynUser *pasynUser, char *strings[], int values[], - // int severities[], size_t nElements, size_t *nIn); virtual void report(FILE *fp, int details); + + /* This function could be implemented as overwrite virtual readInt32, readFloat64 */ + /* It is however implemented in that way due to sugestion that only */ + /* writeInt32, writeFloat64, report should be overwrite */ + /* could be changed in the future */ + int readParameter(int paramIndex); + int readParameterStr(int paramIndex); + + void imageTask(); void temperatureTask(); @@ -279,6 +284,7 @@ private: epicsEventId startEvent_; + // Helper functions asynStatus startAcquire(void); asynStatus stopAcquire(void); void getImageInformation(HDCAM hdcam, int32& pixeltype, int32& width, int32& rowbytes, int32& height, int32& framebytes); @@ -298,15 +304,15 @@ private: asynStatus readAttributes(); asynStatus readSensor(); - asynStatus getParameter(int paramIndex); + // helper functions for dcamapi void printError(HDCAM hdcam, DCAMERR errid, const char* apiname, const char* fmt=NULL, ...); void printInfo(HDCAM hdcam); int dcamdev_string( DCAMERR& err, HDCAM hdcam, int32 idStr, char* text, int32 textbytes ); - int setParameter(int paramIndex); - int getParameterStr(int paramIndex); + + int getProperties(); asynStatus setFeature(int featureIndex, double value); From b01e13eb776d205538d8ddacf71a2c3847bcff07 Mon Sep 17 00:00:00 2001 From: Iocuser Date: Thu, 9 Feb 2023 09:20:07 +0100 Subject: [PATCH 7/9] small update --- ADHamaApp/src/hama.cpp | 165 ++++++++++++++++++++++------------------- 1 file changed, 87 insertions(+), 78 deletions(-) diff --git a/ADHamaApp/src/hama.cpp b/ADHamaApp/src/hama.cpp index e235a6f..39e04a3 100644 --- a/ADHamaApp/src/hama.cpp +++ b/ADHamaApp/src/hama.cpp @@ -385,84 +385,6 @@ int Hama::readParameterStr(int propertyID){ return status; } -//============================================================================ -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; - double dminH=0, dminV=0, dsizeH=0, dsizeV=0, dbinning=1; - double dvalue = 0; - - getIntegerParam(ADMinX, &minH); - getIntegerParam(ADMinY, &minV); - getIntegerParam(ADSizeX, &sizeH); - getIntegerParam(ADSizeY, &sizeV); - getIntegerParam(hBinning, &binning); - - - 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, &dvalue); - m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &dvalue); - //m_err = dcamprop_getvalue(m_hdcam, , &dvalue); - - - - - m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYMODE, &modeON); - - - callParamCallbacks(); - -return status; -} - //============================================================================ int Hama::readParameter(int propertyID){ @@ -1035,6 +957,93 @@ void Hama::temperatureTask(){ } +//============================================================================ +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){ From e2368aa11375b4a463c67c99920f77b3badd4ec6 Mon Sep 17 00:00:00 2001 From: Iocuser Date: Thu, 16 Mar 2023 20:29:40 +0100 Subject: [PATCH 8/9] just update --- ADHamaApp/Db/hama.template | 10 +- ADHamaApp/src/hama.cpp | 265 ++++++++++++++++++++++++++++++++++--- cmds/st.cmd | 12 +- 3 files changed, 256 insertions(+), 31 deletions(-) diff --git a/ADHamaApp/Db/hama.template b/ADHamaApp/Db/hama.template index d3fc562..e4965a4 100644 --- a/ADHamaApp/Db/hama.template +++ b/ADHamaApp/Db/hama.template @@ -611,7 +611,7 @@ record(mbbo, "$(P)$(R)Binning-S") { field(ZRST, "1x1") field(ONVL, "2") field(ONST, "2x2") - field(TWVL, "3") + field(TWVL, "4") field(TWST, "4x4") # field(DRVL, "1") # field(DRVH, "3") @@ -626,7 +626,7 @@ record(mbbi, "$(P)$(R)Binning-RB") { field(ZRST, "1x1") field(ONVL, "2") field(ONST, "2x2") - field(TWVL, "3") + field(TWVL, "4") field(TWST, "4x4") field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_BINNING") field(SCAN, "I/O Intr") @@ -1541,7 +1541,6 @@ record(ai, "$(P)$(R)TimingInvalidExposurePeriod-RB") { # Internal Frame Rate record(ao, "$(P)$(R)InternalFrameRate-S") { field(DESC, "") - field(PINI, "YES") field(DTYP, "asynFloat64") field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_INTERNAL_FRAME_RATE") field(EGU, "Hz") @@ -1559,7 +1558,6 @@ record(ai, "$(P)$(R)InternalFrameRate-RB") { # Internal Frame Interval record(ao, "$(P)$(R)InternalFrameInternal-S") { field(DESC, "") - field(PINI, "YES") field(DTYP, "asynFloat64") field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_INTERNAL_FRAME_INTERVAL") field(EGU, "Sec") @@ -1616,8 +1614,8 @@ record(ai, "$(P)$(R)InternalLineInterval-RB") { record(mbbi, "$(P)$(R)ColorType-R") { field(DESC,"") field(DTYP, "asynInt32") - field(ZRVL, "0") - field(ZRST, "BW") + field(ZRVL, "1") + field(ZRST, "B & W") field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_COLOR_TYPE") field(SCAN, "I/O Intr") } diff --git a/ADHamaApp/src/hama.cpp b/ADHamaApp/src/hama.cpp index 39e04a3..a7eb2b9 100644 --- a/ADHamaApp/src/hama.cpp +++ b/ADHamaApp/src/hama.cpp @@ -277,8 +277,8 @@ int Hama::initCamera(){ 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); @@ -818,6 +818,7 @@ void Hama::imageTask(){ acquire = 1; /* Get the current time */ prevAcquisitionCount = 0; + setIntegerParam(ADNumImagesCounter, 0); } } @@ -876,7 +877,7 @@ void Hama::imageTask(){ 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: %f\n", (ts_sec + ts_microsec / 1.0e6)); //printf("Timestamp from camera with correction: %f\n", timestamp); epicsTimeGetCurrent(¤tAcqTime); @@ -914,6 +915,7 @@ void Hama::imageTask(){ getIntegerParam(ADNumImages, &totalImages); getIntegerParam(ADImageMode, &imageMode); + setIntegerParam(ADNumImagesCounter, captransferinfo.nFrameCount); if ((imageMode == ADImageMultiple && totalImages == captransferinfo.nFrameCount) || (imageMode == ADImageSingle && captransferinfo.nFrameCount == 1)) { @@ -994,6 +996,8 @@ asynStatus Hama::readSensor(){ double dminH=0, dminV=0, dsizeH=0, dsizeV=0, dbinning=1; double dFrameBytes = 0, dRowBytes = 0; double dvalue = 0; + int mode = 0; + getIntegerParam(ADMinX, &minH); getIntegerParam(ADMinY, &minV); @@ -1001,7 +1005,14 @@ asynStatus Hama::readSensor(){ getIntegerParam(ADSizeY, &sizeV); getIntegerParam(hBinning, &binning); getIntegerParam(hBitPerChannel, &bitPerChannel); - + getIntegerParam(hSubarrayMode ,&mode); + + if(mode == DCAMPROP_MODE__OFF){ + status = asynError; + return status ; + } + + dbinning = binning; dminH = minH; dminV = minV; @@ -1009,33 +1020,109 @@ asynStatus Hama::readSensor(){ dsizeV = sizeV; double modeON = DCAMPROP_MODE__ON; double modeOFF = DCAMPROP_MODE__OFF; + double dsensorH = 2048; + double dsensorV = 2048; +/* m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYMODE, &modeOFF); + if(failed(m_err)) + printError(m_hdcam, m_err, "dcamprop_SubarrayMode()", " VALUE:%f\n", modeOFF); + +*/ m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_BINNING, &dbinning); + if(failed(m_err)) + printError(m_hdcam, m_err, "dcamprop_Binning()", " VALUE:%f\n", dbinning); + status = setIntegerParam(hBinning, dbinning); + + printf("BEFORE::::n"); + printf("SUBARRAY Hpos = %f \n", dminH); + printf("SUBARRAY Vpos = %f \n", dminV); + printf("SUBARRAY Hsize = %f \n", dsizeH); + printf("SUBARRAY Vsize = %f \n", dsizeV); + + if(dsizeH > (dsensorH - dminH)){ + dsizeH = dsensorH - dminH; + m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHSIZE, &dsizeH); + m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHPOS, &dminH); + } + if(dsizeV > (dsensorV - dminV)){ + dsizeV = dsensorV - dminV; + m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVSIZE, &dsizeV); + m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVPOS, &dminV); + } + + + m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHPOS, &dminH); + if(failed(m_err)) + printError(m_hdcam, m_err, "dcamprop_SubarrayHPos()", " VALUE:%f\n", dminH); + else + status = setIntegerParam(ADMinX, dminH); + m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVPOS, &dminV); + if(failed(m_err)) + printError(m_hdcam, m_err, "dcamprop_SubarrayVPos()", " VALUE:%f\n", dminV); + else status = setIntegerParam(ADMinY, dminV); + + //dsizeH = 2048 - dminH; + //dsizeV = 2048 - dminV; + m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHSIZE, &dsizeH); + if(failed(m_err)) + printError(m_hdcam, m_err, "dcamprop_SubarrayHSize()", " VALUE:%f\n", dsizeH); + else status = setIntegerParam(ADSizeX, dsizeH); + m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVSIZE, &dsizeV); + if(failed(m_err)) + printError(m_hdcam, m_err, "dcamprop_SubarrayVSize()", " VALUE:%f\n", dsizeV); + else status = setIntegerParam(ADSizeY, dsizeV); + m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_WIDTH, &dvalue); + if(failed(m_err)) + printError(m_hdcam, m_err, "dcamprop_ImageWidth()", " VALUE:%f\n", dvalue); + else status = setIntegerParam(ADBinX, dvalue); + m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_HEIGHT, &dvalue); - status = setIntegerParam(ADBinX, dvalue); - status = setIntegerParam(ADBinY, dvalue); + if(failed(m_err)) + printError(m_hdcam, m_err, "dcamprop_ImageHeight()", " VALUE:%f\n", dvalue); + else status = setIntegerParam(ADBinY, dvalue); m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_ROWBYTES, &dRowBytes); + if(failed(m_err)) + printError(m_hdcam, m_err, "dcamprop_ImageRowBytes()", " VALUE:%f\n", dRowBytes); + else status = setIntegerParam(hImageRowbytes, dRowBytes); + m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &dFrameBytes); + if(failed(m_err)) + printError(m_hdcam, m_err, "dcamprop_ImageFrameBytes()", " VALUE:%f\n", dFrameBytes); + else status = setIntegerParam(hImageFramebytes, dFrameBytes); + //m_err = dcamprop_getvalue(m_hdcam, , &dvalue); - status = setIntegerParam(hBinning, dbinning); + + printf("AFTER::::n"); + printf("SUBARRAY Hpos = %f \n", dminH); + printf("SUBARRAY Vpos = %f \n", dminV); + printf("SUBARRAY Hsize = %f \n", dsizeH); + printf("SUBARRAY Vsize = %f \n", dsizeV); + + printf("binning = %f \n", dbinning); + + unsigned long size = (dsizeH-dminH) * (dsizeV-dminV) / dbinning * 2; + printf("ImageSize = %ld\n", size); + 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); - - + + int bytes = 2; + if(bitPerChannel >=12) bytes = 2; + else bytes = 1; + + status = setIntegerParam(NDArraySize, bytes); + +/* m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYMODE, &modeON); - +*/ callParamCallbacks(); @@ -1101,16 +1188,113 @@ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value){ printf("[DEBUG]::writeInit32 ADNumExposures\n"); } else if (index == ADMinX) { - readSensor(); + + int sensorH = 2048, minH = 0, sizeH = 0; + double dFrameBytes = 0; + getIntegerParam(ADMinX, &minH); + getIntegerParam(ADSizeX, &sizeH); + + if(sizeH > (sensorH - minH)){ + sizeH = sensorH - minH; + double dsizeH = sizeH; + double dminH = minH; + m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHSIZE, &dsizeH); + m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHPOS, &dminH); + printf("--- minH = %d\n", sizeH); + setIntegerParam(ADSizeX, sizeH); + dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &dFrameBytes); + status = setIntegerParam(hImageFramebytes, dFrameBytes); + } + else{ + double dsizeH = sizeH; + double dminH = minH; + m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHSIZE, &dsizeH); + m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHPOS, &dminH); + m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &dFrameBytes); + status = setIntegerParam(hImageFramebytes, dFrameBytes); + } } else if (index == ADMinY) { - readSensor(); + int sensorV = 2048, minV = 0, sizeV = 0; + double dFrameBytes = 0; + getIntegerParam(ADMinY, &minV); + getIntegerParam(ADSizeY, &sizeV); + + if(sizeV > (sensorV - minV)){ + sizeV = sensorV - minV; + double dsizeV = sizeV; + double dminV = minV; + m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVSIZE, &dsizeV); + m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVPOS, &dminV); + printf("--- sizeV = %d\n", sizeV); + setIntegerParam(ADSizeY, sizeV); + dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &dFrameBytes); + status = setIntegerParam(hImageFramebytes, dFrameBytes); + } + else{ + double dsizeV = sizeV; + double dminV = minV; + m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHSIZE, &dsizeV); + m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHPOS, &dminV); + dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &dFrameBytes); + status = setIntegerParam(hImageFramebytes, dFrameBytes); + } } else if (index == ADSizeX) { - readSensor(); + int sensorH = 2048, minH = 0, sizeH = 0; + double dFrameBytes = 0; + getIntegerParam(ADMinX, &minH); + getIntegerParam(ADSizeX, &sizeH); + printf("---1 sensorH = %d minH = %d sizeH = %d\n", sensorH, minH, sizeH); + + if(sizeH < sensorH - minH){ + double dsizeH = sizeH; + m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHSIZE, &dsizeH); + m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &dFrameBytes); + status = setIntegerParam(hImageFramebytes, dFrameBytes); + } + else{ + + double dsizeH = sensorH - minH; + printf("---2 sensorH = %d minH = %d sizeH = %f\n", sensorH, minH, dsizeH); + m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHSIZE, &dsizeH); + if(failed(m_err)) printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%d\n", index, (int)dsizeH); + + m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &dFrameBytes); + if(failed(m_err)) printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%d\n", index, (int)dFrameBytes); + + printf("---3 dFrameBuffer = %f\n", dFrameBytes); + status = setIntegerParam(hImageFramebytes, dFrameBytes); + //status = setIntegerParam(ADSizeX, dsizeH); + } + } else if (index == ADSizeY) { - readSensor(); + int sensorV = 2048, minV = 0, sizeV = 0; + double dFrameBytes = 0; + getIntegerParam(ADMinY, &minV); + getIntegerParam(ADSizeY, &sizeV); + + if(sizeV < sensorV - minV){ + double dsizeV = sizeV; + m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVSIZE, &dsizeV); + m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &dFrameBytes); + status = setIntegerParam(hImageFramebytes, dFrameBytes); + } + else{ + + double dsizeV = sizeV; + printf("---4 sensor = %d min = %d size = %d\n", sensorV, minV, sizeV); + m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVSIZE, &dsizeV); + if(failed(m_err)) printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%d\n", index, (int)dsizeV); + + m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &dFrameBytes); + if(failed(m_err)) printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%d\n", index, (int)dFrameBytes); + + status = setIntegerParam(hImageFramebytes, dFrameBytes); + status = setIntegerParam(ADSizeX, dsizeV); + } + } else if (index == ADReadStatus) { // dcamprop_setvalue(m_hdcam, DCAM_IDPROP_, value); @@ -1199,9 +1383,21 @@ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value){ //-- binning and ROI else if (index == hBinning) { - readSensor(); + int binning = 0; + double dFrameBytes = 0; + + getIntegerParam(hBinning, &binning); + double dbinning = binning; + m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_BINNING, &dbinning); + if(failed(m_err)) printError(m_hdcam, m_err, "dcamprop_Binning()", " VALUE:%f\n", dbinning); + + m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &dFrameBytes); + status = setIntegerParam(hImageFramebytes, dFrameBytes); + + status = setIntegerParam(hBinning, dbinning); 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); @@ -1230,6 +1426,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 == hSubarrayMode) { printf("[DEBUG]::writeInit32 SubarrayMode %d\n", value); m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYMODE, &dvalue); @@ -1464,8 +1661,14 @@ asynStatus Hama::writeFloat64(asynUser *pasynUser, epicsFloat64 value){ //-- Feature if(index == ADAcquireTime) { printf("[DEBUG]::function ADAcquireTime from camera: %f\n", value); - - int trigger_mode = 0; + 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); + status = asynError; + } + + /* int trigger_mode = 0; getIntegerParam(hTriggerSource, &trigger_mode); if (trigger_mode != DCAMPROP_TRIGGERSOURCE__EXTERNAL) { @@ -1486,6 +1689,7 @@ asynStatus Hama::writeFloat64(asynUser *pasynUser, epicsFloat64 value){ } else status = asynError; + */ } else if(index == ADAcquirePeriod) { @@ -1588,20 +1792,37 @@ asynStatus Hama::writeFloat64(asynUser *pasynUser, epicsFloat64 value){ printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue); } } - else if (index == hInternalLineInterval) { + /* + 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)) { + printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue); + } + } +else if (index == hInternalFrameInterval) { + printf("[DEBUG]::function Internal FrameInterval %f\n", value); + m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_INTERNAL_FRAMEINTERVAL, &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); + printf("[-DEBUG]::function writeFloat64 did not find a parameter index = %d, %s\n", index, paramName); } } diff --git a/cmds/st.cmd b/cmds/st.cmd index b693a0f..ebb4796 100644 --- a/cmds/st.cmd +++ b/cmds/st.cmd @@ -7,18 +7,22 @@ epicsEnvSet("PREFIX", "Hama:") epicsEnvSet("PORT", "HAMA") epicsEnvSet("CAMERA", "0") epicsEnvSet("QSIZE", "21") -epicsEnvSet("XSIZE", "10") -epicsEnvSet("YSIZE", "10") +epicsEnvSet("XSIZE", "2048") +epicsEnvSet("YSIZE", "2048") epicsEnvSet("NCHANS", "2048") # Number of Elements epicsEnvSet("NELEMENTS", "4194304") epicsEnvSet("EPICS_CA_MAX_ARRAY_BYTES", "64000000") +#EVR settings +epicsEnvSet("EVR", "YMIR-TS:Ctrl-EVR-01") +epicsEnvSet("EVR_EVENT", "E") + # iocshLoad("$(adhama_DIR)ADHama.iocsh") devHamamatsuConfig("$(PORT)", $(CAMERA), 0, 0, 0, 0, 10) -dbLoadRecords("$(adhama_DIR)db/hama.db","P=$(PREFIX),R=cam1:,EVR=LabS-Utgard-VIP:TS-EVR-3,E=F,PORT=$(PORT),ADDR=0,TIMEOUT=1") +dbLoadRecords("$(adhama_DIR)db/hama.db","P=$(PREFIX),R=cam1:,EVR=$(EVR),E=$(EVR_EVENT),PORT=$(PORT),ADDR=0,TIMEOUT=1") #asynSetTraceMask("$(PORT)",-1,0x9) #asynSetTraceIOMask("$(PORT)",-1,0x2) @@ -61,6 +65,8 @@ dbpf Hama:cam1:PoolUsedMem.SCAN 0 dbpf Hama:image1:EnableCallbacks 1 dbpf Hama:Kfk1:EnableCallbacks 1 +#dbpf Hama:cam1:TriggerPolarity-S # 2-positive, 1-negative + epicsThreadSleep(1.0) dbl > pv.list From 545fb7b0ec9fcda41106e70148582fb8db40366e Mon Sep 17 00:00:00 2001 From: Iocuser Date: Fri, 31 Mar 2023 10:12:04 +0200 Subject: [PATCH 9/9] Add Tomasz's changes --- .gitignore | 4 +- .vscode/c_cpp_properties.json | 10 ++--- ADHamaApp/src/hama.cpp | 77 ++++++++++++++++------------------- 3 files changed, 44 insertions(+), 47 deletions(-) diff --git a/.gitignore b/.gitignore index fbd322a..eeaf8f9 100644 --- a/.gitignore +++ b/.gitignore @@ -7,4 +7,6 @@ O.* *.db.* pv.list core.* -.vscode \ No newline at end of file +.vscode +list.txt +.vscode/c_cpp_properties.json \ No newline at end of file diff --git a/.vscode/c_cpp_properties.json b/.vscode/c_cpp_properties.json index ead342c..1da3a01 100644 --- a/.vscode/c_cpp_properties.json +++ b/.vscode/c_cpp_properties.json @@ -6,11 +6,11 @@ "${workspaceFolder}/**", "${workspaceFolder}/ADHamaApp/src/**", "${workspaceFolder}/ADHamaApp/src/", - "/home/iocuser/.conda/envs/hama/epics/include/**", - "/home/iocuser/.conda/envs/hama/epics/include/", - "/home/iocuser/.conda/envs/hama/modules/adcore/3.10.0/include/", - "/home/iocuser/.conda/envs/hama/modules/**", - "/home/iocuser/.conda/envs/hama/epics/include/os/Linux" + "/home/iocuser/.conda/envs/hama-dev/epics/include/**", + "/home/iocuser/.conda/envs/hama-dev/epics/include/", + "/home/iocuser/.conda/envs/hama-dev/modules/adcore/3.10.0/include/", + "/home/iocuser/.conda/envs/hama-dev/modules/**", + "/home/iocuser/.conda/envs/hama-dev/epics/include/os/Linux" ], "defines": [], "compilerPath": "/usr/bin/gcc", diff --git a/ADHamaApp/src/hama.cpp b/ADHamaApp/src/hama.cpp index a7eb2b9..3b8b3cc 100644 --- a/ADHamaApp/src/hama.cpp +++ b/ADHamaApp/src/hama.cpp @@ -988,10 +988,9 @@ 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; @@ -1023,12 +1022,12 @@ asynStatus Hama::readSensor(){ double dsensorH = 2048; double dsensorV = 2048; -/* - m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYMODE, &modeOFF); - if(failed(m_err)) - printError(m_hdcam, m_err, "dcamprop_SubarrayMode()", " VALUE:%f\n", modeOFF); + + //m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYMODE, &modeOFF); + //if(failed(m_err)) + // printError(m_hdcam, m_err, "dcamprop_SubarrayMode()", " VALUE:%f\n", modeOFF); -*/ + m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_BINNING, &dbinning); if(failed(m_err)) printError(m_hdcam, m_err, "dcamprop_Binning()", " VALUE:%f\n", dbinning); @@ -1120,12 +1119,12 @@ asynStatus Hama::readSensor(){ status = setIntegerParam(NDArraySize, bytes); -/* - m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYMODE, &modeON); -*/ + +// m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYMODE, &modeON); + callParamCallbacks(); - + */ return status; } @@ -1241,58 +1240,54 @@ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value){ } } else if (index == ADSizeX) { - int sensorH = 2048, minH = 0, sizeH = 0; + int sensorX = 2048, minX = 0, sizeX = 0; double dFrameBytes = 0; - getIntegerParam(ADMinX, &minH); - getIntegerParam(ADSizeX, &sizeH); - printf("---1 sensorH = %d minH = %d sizeH = %d\n", sensorH, minH, sizeH); + getIntegerParam(ADMinX, &minX); + getIntegerParam(ADSizeX, &sizeX); - if(sizeH < sensorH - minH){ - double dsizeH = sizeH; - m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHSIZE, &dsizeH); + if(sizeX < sensorX - minX){ + double dsizeX = sizeX; + m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHSIZE, &dsizeX); m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &dFrameBytes); status = setIntegerParam(hImageFramebytes, dFrameBytes); + status = setIntegerParam(ADSizeX, (int)dsizeX); + printf("1-Status = %d\n", status); } else{ - double dsizeH = sensorH - minH; - printf("---2 sensorH = %d minH = %d sizeH = %f\n", sensorH, minH, dsizeH); - m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHSIZE, &dsizeH); - if(failed(m_err)) printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%d\n", index, (int)dsizeH); - + double dsizeX = sensorX - minX; + m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHSIZE, &dsizeX); m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &dFrameBytes); - if(failed(m_err)) printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%d\n", index, (int)dFrameBytes); - - printf("---3 dFrameBuffer = %f\n", dFrameBytes); + status = setIntegerParam(ADSizeX, sizeX); + printf("2-Status = %d\n", status); status = setIntegerParam(hImageFramebytes, dFrameBytes); - //status = setIntegerParam(ADSizeX, dsizeH); - } + } } else if (index == ADSizeY) { - int sensorV = 2048, minV = 0, sizeV = 0; + int sensorY = 2048, minY = 0, sizeY = 0; double dFrameBytes = 0; - getIntegerParam(ADMinY, &minV); - getIntegerParam(ADSizeY, &sizeV); + getIntegerParam(ADMinY, &minY); + getIntegerParam(ADSizeY, &sizeY); - if(sizeV < sensorV - minV){ - double dsizeV = sizeV; - m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVSIZE, &dsizeV); + if(sizeY < sensorY - minY){ + double dsizeY = sizeY; + m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVSIZE, &dsizeY); m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &dFrameBytes); + status = setIntegerParam(ADSizeX, (int)dsizeY); status = setIntegerParam(hImageFramebytes, dFrameBytes); } else{ - - double dsizeV = sizeV; - printf("---4 sensor = %d min = %d size = %d\n", sensorV, minV, sizeV); - m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVSIZE, &dsizeV); - if(failed(m_err)) printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%d\n", index, (int)dsizeV); + double dsizeY = sizeY; + //printf("---4 sensor = %d min = %d size = %d\n", sensorY, minY, sizeY); + m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVSIZE, &dsizeY); + //if(failed(m_err)) printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%d\n", index, (int)dsizeY); m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &dFrameBytes); - if(failed(m_err)) printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%d\n", index, (int)dFrameBytes); + //if(failed(m_err)) printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%d\n", index, (int)dFrameBytes); status = setIntegerParam(hImageFramebytes, dFrameBytes); - status = setIntegerParam(ADSizeX, dsizeV); + status = setIntegerParam(ADSizeX, (int)dsizeY); } }