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/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 3525d4d..3b8b3cc 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,124 +382,129 @@ int Hama::getParameterStr(int propertyID){ callParamCallbacks(); -return int(status); +return status; } + + //============================================================================ -asynStatus Hama::getParameter(int propertyID){ +int Hama::readParameter(int propertyID){ asynStatus status = asynSuccess; 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); - } 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; @@ -518,6 +514,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); @@ -527,7 +542,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: @@ -646,30 +723,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: @@ -695,29 +760,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(){ @@ -763,6 +818,7 @@ void Hama::imageTask(){ acquire = 1; /* Get the current time */ prevAcquisitionCount = 0; + setIntegerParam(ADNumImagesCounter, 0); } } @@ -821,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); @@ -859,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)) { @@ -902,6 +959,177 @@ 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; + int mode = 0; + + + getIntegerParam(ADMinX, &minH); + getIntegerParam(ADMinY, &minV); + getIntegerParam(ADSizeX, &sizeH); + 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; + dsizeH = sizeH; + 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); + 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); + + + 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); + + 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(); + */ +return status; +} + + + //============================================================================ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value){ @@ -959,16 +1187,109 @@ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value){ printf("[DEBUG]::writeInit32 ADNumExposures\n"); } else if (index == ADMinX) { - updateSensorSize(); + + 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) { - updateSensorSize(); + 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) { - updateSensorSize(); + int sensorX = 2048, minX = 0, sizeX = 0; + double dFrameBytes = 0; + getIntegerParam(ADMinX, &minX); + getIntegerParam(ADSizeX, &sizeX); + + 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 dsizeX = sensorX - minX; + m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHSIZE, &dsizeX); + m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &dFrameBytes); + status = setIntegerParam(ADSizeX, sizeX); + printf("2-Status = %d\n", status); + status = setIntegerParam(hImageFramebytes, dFrameBytes); + } + } else if (index == ADSizeY) { - updateSensorSize(); + int sensorY = 2048, minY = 0, sizeY = 0; + double dFrameBytes = 0; + getIntegerParam(ADMinY, &minY); + getIntegerParam(ADSizeY, &sizeY); + + 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 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); + + status = setIntegerParam(hImageFramebytes, dFrameBytes); + status = setIntegerParam(ADSizeX, (int)dsizeY); + } + } else if (index == ADReadStatus) { // dcamprop_setvalue(m_hdcam, DCAM_IDPROP_, value); @@ -1054,21 +1375,24 @@ 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) { - updateSensorSize(); + 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); @@ -1097,6 +1421,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); @@ -1135,6 +1460,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); @@ -1142,6 +1475,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); @@ -1187,28 +1521,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); @@ -1274,13 +1586,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); @@ -1298,57 +1604,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); @@ -1356,99 +1611,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){ @@ -1494,8 +1656,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) { @@ -1516,6 +1684,7 @@ asynStatus Hama::writeFloat64(asynUser *pasynUser, epicsFloat64 value){ } else status = asynError; + */ } else if(index == ADAcquirePeriod) { @@ -1610,72 +1779,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); @@ -1684,50 +1787,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 == 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); 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); } } @@ -1746,49 +1836,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..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); @@ -289,20 +295,26 @@ private: int allocateBuffers(unsigned int); int freeBuffers(); + // These function will be read only once int connectCamera(); int disconnectCamera(); int initCamera(); - asynStatus updateSensorSize(); - asynStatus getParameter(int paramIndex); + + // These function can be read more than once + asynStatus readAttributes(); + asynStatus readSensor(); + + // 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); }; diff --git a/cmds/st.cmd b/cmds/st.cmd index ac29702..ebb4796 100644 --- a/cmds/st.cmd +++ b/cmds/st.cmd @@ -1,23 +1,28 @@ # This should be a test startup script require adhama +require adpluginkafka 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) @@ -36,6 +41,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 +63,9 @@ iocInit() 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)