lin-epics-modules/adorca
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update two functions: getParameter and sensorSize

Browse Source
This commit is contained in:
Iocuser
2022-11-07 17:29:44 +01:00
parent cc160d8fa8
commit 97a79d1cdf
1 changed files with 105 additions and 101 deletions
Download Patch File Download Diff File Expand all files Collapse all files

206
ADHamaApp/src/hama.cpp
View File

@@ -205,7 +205,8 @@ Hama::Hama(const char* portName, int cameraId, int maxBuffers, size_t maxMemory,
/* shutdown on exit */
//epicsAtExit(c_shutdown, this);
printf("[DEBUG] === END Constructor ADHama ===\n");
printf("\n\n=== END Constructor ADHama ===\n");
printf("===================================================================\n");
}
//============================================================================
//Hama::~Hama(){
@@ -249,7 +250,7 @@ int Hama::initCamera(){
err |= getParameter(DCAM_IDPROP_TRIGGER_MODE);
err |= getParameter(DCAM_IDPROP_TRIGGERACTIVE);
err |= getParameter(DCAM_IDPROP_TRIGGER_GLOBALEXPOSURE);
err |= getParameter(DCAM_IDPROP_OUTPUTTRIGGER_POLARITY);
err |= getParameter(DCAM_IDPROP_TRIGGERPOLARITY);
err |= getParameter(DCAM_IDPROP_TRIGGER_CONNECTOR);
err |= getParameter(DCAM_IDPROP_TRIGGERTIMES);
err |= getParameter(DCAM_IDPROP_TRIGGERDELAY);
@@ -331,166 +332,149 @@ return int(status);
int Hama::getParameter(int propertyID){
printf("\n[DEBUG] *** Function:getProperty\n");
asynStatus status = asynSuccess;
double value_d = 0;
/*
dcamprop_getvalue(m_hdcam, propertyID, &value);
setIntegerParameter(ADMaxSizeX, value);
printf("PropertyID = %f\n", value);
*/
double dvalue = 0;
switch (propertyID){
case DETECTOR_PIXEL_NUM_HORZ:
dcamprop_getvalue(m_hdcam, DETECTOR_PIXEL_NUM_HORZ, &value_d);
status = setIntegerParam(ADMaxSizeX, value_d);
printf("SENSOR SIZE_X = %f\n", value_d);
m_err = dcamprop_getvalue(m_hdcam, DETECTOR_PIXEL_NUM_HORZ, &dvalue);
status = setIntegerParam(ADMaxSizeX, dvalue);
break;
case DETECTOR_PIXEL_NUM_VERT:
dcamprop_getvalue(m_hdcam, DETECTOR_PIXEL_NUM_VERT, &value_d);
status = setIntegerParam(ADMaxSizeY, value_d);
printf("SENSOR SIZE_Y = %f\n", value_d);
m_err = dcamprop_getvalue(m_hdcam, DETECTOR_PIXEL_NUM_VERT, &dvalue);
status = setIntegerParam(ADMaxSizeY, dvalue);
break;
case DCAM_IDPROP_IMAGE_PIXELTYPE:
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_PIXELTYPE, &value_d);
status = setIntegerParam(hImagePixelType, value_d);
printf("The PIXELTYPE = %f\n", value_d);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_PIXELTYPE, &dvalue);
status = setIntegerParam(hImagePixelType, dvalue);
break;
case DCAM_IDPROP_IMAGE_WIDTH:
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_WIDTH, &value_d);
status = setIntegerParam(hImageWidth, value_d);
printf("The IMAGE_WIDTH = %f\n", value_d);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_WIDTH, &dvalue);
status = setIntegerParam(hImageWidth, dvalue);
break;
case DCAM_IDPROP_IMAGE_HEIGHT:
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_HEIGHT, &value_d);
status = setIntegerParam(hImageHeight, value_d);
printf("The IMAGE_HEIGHT = %f\n", value_d);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_HEIGHT, &dvalue);
status = setIntegerParam(hImageHeight, dvalue);
break;
case DCAM_IDPROP_IMAGE_ROWBYTES:
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_ROWBYTES, &value_d);
status = setIntegerParam(hImageRowbytes, value_d);
printf("The IMAGE_ROWBYTES = %f\n", value_d);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_ROWBYTES, &dvalue);
status = setIntegerParam(hImageRowbytes, dvalue);
break;
case DCAM_IDPROP_IMAGE_FRAMEBYTES:
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &value_d);
status = setIntegerParam(hImageFramebytes, value_d);
printf("The IMAGE FRAMEBYTES = %f\n", value_d);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &dvalue);
status = setIntegerParam(hImageFramebytes, dvalue);
break;
case DCAM_IDPROP_BINNING:
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_BINNING, &dvalue);
status = setIntegerParam(hBinning, dvalue);
break;
case DCAM_IDPROP_SUBARRAYHSIZE:
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHSIZE, &value_d);
status = setIntegerParam(ADSizeX, value_d);
printf("The SENSOR HSIZE = %f\n", value_d);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHSIZE, &dvalue);
status = setIntegerParam(ADSizeX, dvalue);
break;
case DCAM_IDPROP_SUBARRAYVSIZE:
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVSIZE, &value_d);
status = setIntegerParam(ADSizeY, value_d);
printf("The SENSOR VSIZE = %f\n", value_d);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVSIZE, &dvalue);
status = setIntegerParam(ADSizeY, dvalue);
break;
case DCAM_IDPROP_SUBARRAYHPOS:
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHPOS, &value_d);
status = setIntegerParam(ADMinX, value_d);
printf("The SENSOR HPOS = %f\n", value_d);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHPOS, &dvalue);
status = setIntegerParam(ADMinX, dvalue);
break;
case DCAM_IDPROP_SUBARRAYVPOS:
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVPOS, &value_d);
status = setIntegerParam(ADMinY, value_d);
printf("The SENSOR VPOS = %f\n", value_d);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVPOS, &dvalue);
status = setIntegerParam(ADMinY, dvalue);
break;
case DCAM_IDPROP_SENSORMODE:
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SENSORMODE, &value_d);
status = setIntegerParam(hSensorMode, value_d);
//printf("The SENSOR MODE = %f\n", value_d);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SENSORMODE, &dvalue);
status = setIntegerParam(hSensorMode, dvalue);
break;
case DCAM_IDPROP_READOUTSPEED:
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_READOUTSPEED, &value_d);
status = setIntegerParam(hReadoutSpeed, value_d);
//printf("The READOUT SPEED = %f\n", value_d);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_READOUTSPEED, &dvalue);
status = setIntegerParam(hReadoutSpeed, dvalue);
break;
case DCAM_IDPROP_READOUT_DIRECTION:
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_READOUT_DIRECTION, &value_d);
status = setIntegerParam(hReadoutDirection, value_d);
//printf("The READOUT DIRECTION = %f\n", value_d);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_READOUT_DIRECTION, &dvalue);
status = setIntegerParam(hReadoutDirection, dvalue);
break;
case DCAM_IDPROP_TRIGGERSOURCE:
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGERSOURCE, &value_d);
status = setIntegerParam(hTriggerSource, value_d);
//printf("The = TRIGGER SOURCE = %f\n", value_d);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGERSOURCE, &dvalue);
status = setIntegerParam(hTriggerSource, dvalue);
break;
case DCAM_IDPROP_TRIGGER_MODE:
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGER_MODE, &value_d);
status = setIntegerParam(hTriggerMode, value_d);
//printf("The TRIGGER MODE = %f\n", value_d);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGER_MODE, &dvalue);
status = setIntegerParam(hTriggerMode, dvalue);
break;
case DCAM_IDPROP_TRIGGERACTIVE:
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGERACTIVE, &value_d);
status = setIntegerParam(hTriggerActive, value_d);
//printf("The TRIGGER ACTIVE = %f\n", value_d);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGERACTIVE, &dvalue);
status = setIntegerParam(hTriggerActive, dvalue);
break;
case DCAM_IDPROP_TRIGGER_GLOBALEXPOSURE:
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGER_GLOBALEXPOSURE, &value_d);
status = setIntegerParam(hTriggerGlobalExposure, value_d);
//printf("The TRIGGER GLOBAL EXPOSURE = %f\n", value_d);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGER_GLOBALEXPOSURE, &dvalue);
status = setIntegerParam(hTriggerGlobalExposure, dvalue);
break;
case DCAM_IDPROP_TRIGGERPOLARITY:
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGERPOLARITY, &value_d);
status = setIntegerParam(hTriggerPolarity, value_d);
//printf("The TRIGGER POLARITY = %f\n", value_d);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGERPOLARITY, &dvalue);
status = setIntegerParam(hTriggerPolarity, dvalue);
break;
case DCAM_IDPROP_TRIGGER_CONNECTOR:
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGER_CONNECTOR, &value_d);
status = setIntegerParam(hTriggerConnector, value_d);
//printf("The TRIGGER CONNECTOR = %f\n", value_d);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGER_CONNECTOR, &dvalue);
status = setIntegerParam(hTriggerConnector, dvalue);
break;
case DCAM_IDPROP_TRIGGERTIMES:
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGERTIMES, &value_d);
status = setIntegerParam(hTriggerTimes, value_d);
//printf("The TRIGGER TIMES = %f\n", value_d);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGERTIMES, &dvalue);
status = setIntegerParam(hTriggerTimes, dvalue);
break;
case DCAM_IDPROP_TRIGGERDELAY:
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGERDELAY, &value_d);
status = setDoubleParam(hTriggerDelay, value_d);
//printf("The TRIGGER DELAY = %f\n", value_d);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGERDELAY, &dvalue);
status = setDoubleParam(hTriggerDelay, dvalue);
break;
case DCAM_IDPROP_INTERNALTRIGGER_HANDLING:
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_INTERNALTRIGGER_HANDLING, &value_d);
status = setIntegerParam(hInternalTriggerHandling, value_d);
//printf("The INTERNAL TRIGGE HANDLING = %f\n", value_d);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_INTERNALTRIGGER_HANDLING, &dvalue);
status = setIntegerParam(hInternalTriggerHandling, dvalue);
break;
case DCAM_IDPROP_TIMESTAMP_PRODUCER:
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TIMESTAMP_PRODUCER, &value_d);
status = setIntegerParam(hTimeStampProducer, value_d);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TIMESTAMP_PRODUCER, &dvalue);
status = setIntegerParam(hTimeStampProducer, dvalue);
break;
default:
printf("The init parameter not recognised.... = %d\n", propertyID);
char text[256];
dcamprop_getname(m_hdcam, propertyID, text, sizeof(text));
printf("Parameter not recognised, IDPROP:0x%08x, NAME:%s\n", propertyID, text);
break;
}
if(failed(m_err)) {
char text[256];
dcamprop_getname(m_hdcam, propertyID, text, sizeof(text));
printError(m_hdcam, m_err, "dcamprop_getvalue()", "IDPROP:0x%08x, VALUE:%s\n", propertyID, text);
}
/* Do callbacks so higher layers see any changes */
status = (asynStatus) callParamCallbacks();
return int(status);
@@ -761,7 +745,6 @@ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value){
int adstatus;
// the setget function required double parameter
double dvalue = double(value);
double value_d = 0;
getParamName(index, &paramName);
@@ -1414,10 +1397,11 @@ return(asynSuccess);
int Hama::updateSensorSize(){
int minH=0, minV=0, sizeH=0, sizeV=0, binning=1;
double dminH=0, dminV=0, dsizeH=0, dsizeV=0, dbinning=1;
int status = 0;
double v1,v2,v3,v4,b1;
double a1,a2,a3,a4;
//double v1,v2,v3,v4,b1;
//double a1,a2,a3,a4;
status |= getIntegerParam(ADMinX, &minH);
status |= getIntegerParam(ADMinY, &minV);
@@ -1426,13 +1410,29 @@ int Hama::updateSensorSize(){
status |= getIntegerParam(hBinning, &binning);
printf("minH = %d\nminV = %d\nSizeV = %d\nSizeH = %d\n", minH, minV, sizeV, sizeH);
dbinning = binning;
dminH = minH;
dminV = minV;
dsizeH = sizeH;
dsizeV = sizeV;
double mode = DCAMPROP_MODE__ON;
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYMODE, &mode);
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);
/*
double value = 0;
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_BINNING_INDEPENDENT, &value);
printf("DCAM_IDPROP_BINNING_INDEPENDENT: %d\n", value);
printf("DCAM_IDPROP_BINNING_INDEPENDENT: %d\n", (int)value);
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYMODE, &value);
printf("DCAM_IDPROP_SUBARRAYMODE: %d\n", value);
printf("DCAM_IDPROP_SUBARRAYMODE: %d\n", (int)value);
// set subarray mode off. This setting is not mandatory,
// but you have to control the setting order of offset and size when mode is on.
@@ -1467,25 +1467,24 @@ int Hama::updateSensorSize(){
if( failed(m_err) )
printError( m_hdcam, m_err, "dcambuf_release()" );
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_WIDTH, &a1);
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_HEIGHT, &a2);
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_ROWBYTES, &a3);
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &a4);
*/
status = (asynStatus) callParamCallbacks();
//dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_WIDTH, &a1);
//dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_HEIGHT, &a2);
//dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_ROWBYTES, &a3);
//dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &a4);
printf("status = %d\n", status);
printf("\n");
printf("updateSensorSize, hPos = %d\n", int(v1) );
printf("updateSensorSize, hSize = %d\n", int(v3) );
printf("updateSensorSize, vPos = %d\n", int(v2) );
printf("updateSensorSize, vSize = %d\n", int(v4) );
printf("updateSensorSize, binning = %d\n", int(b1) );
printf("updateSensorSize, imageSizeH = %d\n", int(a1) );
printf("updateSensorSize, imageSizeV = %d\n", int(a2) );
printf("updateSensorSize, imageSize = %d\n", int(a1*a2) );
printf("updateSensorSize, rowBytes = %d\n", int(a3) );
printf("updateSensorSize, frameBytes = %d\n", int(a4) );
printf("updateSensorSize, hPos = %d\n", int(minH) );
printf("updateSensorSize, hSize = %d\n", int(sizeH) );
printf("updateSensorSize, vPos = %d\n", int(minV) );
printf("updateSensorSize, vSize = %d\n", int(sizeV) );
printf("updateSensorSize, binning = %d\n", int(binning) );
printf("updateSensorSize, frameBytes = %d\n", int(sizeH*sizeV) );
return 0;
}
@@ -1710,6 +1709,7 @@ int Hama::freeBuffers(){
return 0;
}
//============================================================================
asynStatus Hama::stopAcquire(void)
{
asynStatus status = asynSuccess;
@@ -1718,6 +1718,7 @@ asynStatus Hama::stopAcquire(void)
return status;
}
//============================================================================
asynStatus Hama::startAcquire(void)
{
asynStatus status = asynSuccess;
@@ -1752,6 +1753,7 @@ asynStatus Hama::startAcquire(void)
return status;
}
//============================================================================
inline void* memcpy_s( void* dst, size_t dstsize, const void* src, size_t srclen )
{
if( dstsize < srclen )
@@ -1760,6 +1762,7 @@ inline void* memcpy_s( void* dst, size_t dstsize, const void* src, size_t srclen
return memcpy( dst, src, srclen );
}
//============================================================================
asynStatus Hama::accessCapturedImage(HDCAM hdcam, int32 iFrame, void* buf,
int32 rowbytes, int32 cx, int32 cy,
int32& ts_sec, int32& ts_microsec)
@@ -1863,6 +1866,7 @@ void Hama::getImageInformation(HDCAM hdcam, int32& pixeltype, int32& width, int3
framebytes = (int32)property_value;
}
//============================================================================
asynStatus Hama::imageTransferStatus(HDCAM hdcam, DCAMCAP_TRANSFERINFO &captransferinfo)
{
DCAMERR err;