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

update posX, posY, sizeX, sizeY

Browse Source
This commit is contained in:
Iocuser
2022-10-25 17:37:33 +02:00
parent 5a2535bb99
commit 2aeba5fe53
2 changed files with 136 additions and 93 deletions
Download Patch File Download Diff File Expand all files Collapse all files
ADHamaApp/src/hama.cpp
+134 -92
View File
@@ -186,25 +186,6 @@ Hama::Hama(const char* portName, int cameraId, int maxBuffers, size_t maxMemory,
callParamCallbacks();
connectCamera();
/*
err |= getParameter(DCAM_IDPROP_SENSORMODE);
err |= getParameter(DCAM_IDPROP_READOUTSPEED);
err |= getParameter(DCAM_IDPROP_READOUT_DIRECTION);
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);
*/
initCamera();
/* launch image read task */
@@ -251,6 +232,7 @@ int Hama::initCamera(){
err |= getParameter( DCAM_IDPROP_IMAGE_WIDTH);
err |= getParameter( DCAM_IDPROP_IMAGE_ROWBYTES);
err |= getParameter( DCAM_IDPROP_IMAGE_HEIGHT);
err |= getParameter( DCAM_IDPROP_BINNING);
err |= getParameter( DCAM_IDPROP_IMAGE_FRAMEBYTES);
err |= getParameter( DCAM_IDPROP_SUBARRAYHPOS);
err |= getParameter( DCAM_IDPROP_SUBARRAYVPOS);
@@ -349,7 +331,7 @@ int Hama::getParameter(int propertyID){
asynStatus status = asynSuccess;
double value = 0;
double value_d = 0;
/*
dcamprop_getvalue(m_hdcam, propertyID, &value);
setIntegerParameter(ADMaxSizeX, value);
@@ -359,136 +341,145 @@ int Hama::getParameter(int propertyID){
switch (propertyID){
case DETECTOR_PIXEL_NUM_HORZ:
dcamprop_getvalue(m_hdcam, DETECTOR_PIXEL_NUM_HORZ, &value);
status = setIntegerParam(ADMaxSizeX, value);
printf("SENSOR SIZE_X = %f\n", value);
dcamprop_getvalue(m_hdcam, DETECTOR_PIXEL_NUM_HORZ, &value_d);
status = setIntegerParam(ADMaxSizeX, value_d);
printf("SENSOR SIZE_X = %f\n", value_d);
break;
case DETECTOR_PIXEL_NUM_VERT:
dcamprop_getvalue(m_hdcam, DETECTOR_PIXEL_NUM_VERT, &value);
status = setIntegerParam(ADMaxSizeY, value);
printf("SENSOR SIZE_Y = %f\n", value);
dcamprop_getvalue(m_hdcam, DETECTOR_PIXEL_NUM_VERT, &value_d);
status = setIntegerParam(ADMaxSizeY, value_d);
printf("SENSOR SIZE_Y = %f\n", value_d);
break;
case DCAM_IDPROP_IMAGE_PIXELTYPE:
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_PIXELTYPE, &value);
status = setIntegerParam(hImagePixelType, value);
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_PIXELTYPE, &value_d);
status = setIntegerParam(hImagePixelType, value_d);
printf("The PIXELTYPE = %f\n", value_d);
break;
case DCAM_IDPROP_IMAGE_WIDTH:
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_WIDTH, &value);
status = setIntegerParam(hImageWidth, value);
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_WIDTH, &value_d);
status = setIntegerParam(hImageWidth, value_d);
printf("The IMAGE_WIDTH = %f\n", value_d);
break;
case DCAM_IDPROP_IMAGE_HEIGHT:
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_HEIGHT, &value);
status = setIntegerParam(hImageHeight, value);
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_HEIGHT, &value_d);
status = setIntegerParam(hImageHeight, value_d);
printf("The IMAGE_HEIGHT = %f\n", value_d);
break;
case DCAM_IDPROP_IMAGE_ROWBYTES:
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_ROWBYTES, &value);
status = setIntegerParam(hImageRowbytes, value);
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_ROWBYTES, &value_d);
status = setIntegerParam(hImageRowbytes, value_d);
printf("The IMAGE_ROWBYTES = %f\n", value_d);
break;
case DCAM_IDPROP_IMAGE_FRAMEBYTES:
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &value);
status = setIntegerParam(hImageFramebytes, value);
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &value_d);
status = setIntegerParam(hImageFramebytes, value_d);
printf("The IMAGE FRAMEBYTES = %f\n", value_d);
break;
case DCAM_IDPROP_SUBARRAYHSIZE:
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHSIZE, &value);
status = setIntegerParam(ADMinX, value);
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHSIZE, &value_d);
status = setIntegerParam(ADSizeX, value_d);
printf("The SENSOR HSIZE = %f\n", value_d);
break;
case DCAM_IDPROP_SUBARRAYVSIZE:
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVSIZE, &value);
status = setIntegerParam(ADMinY, value);
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVSIZE, &value_d);
status = setIntegerParam(ADSizeY, value_d);
printf("The SENSOR VSIZE = %f\n", value_d);
break;
case DCAM_IDPROP_SUBARRAYHPOS:
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHPOS, &value);
status = setIntegerParam(ADSizeX, value);
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHPOS, &value_d);
status = setIntegerParam(ADMinX, value_d);
printf("The SENSOR HPOS = %f\n", value_d);
break;
case DCAM_IDPROP_SUBARRAYVPOS:
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVPOS, &value);
status = setIntegerParam(ADSizeY, value);
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVPOS, &value_d);
status = setIntegerParam(ADMinY, value_d);
printf("The SENSOR VPOS = %f\n", value_d);
break;
case DCAM_IDPROP_SENSORMODE:
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SENSORMODE, &value);
status = setIntegerParam(hSensorMode, value);
printf("The SENSOR MODE = %f\n", value);
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SENSORMODE, &value_d);
status = setIntegerParam(hSensorMode, value_d);
//printf("The SENSOR MODE = %f\n", value_d);
break;
case DCAM_IDPROP_READOUTSPEED:
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_READOUTSPEED, &value);
status = setIntegerParam(hReadoutSpeed, value);
printf("The READOUT SPEED = %f\n", value);
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_READOUTSPEED, &value_d);
status = setIntegerParam(hReadoutSpeed, value_d);
//printf("The READOUT SPEED = %f\n", value_d);
break;
case DCAM_IDPROP_READOUT_DIRECTION:
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_READOUT_DIRECTION, &value);
status = setIntegerParam(hReadoutDirection, value);
printf("The READOUT DIRECTION = %f\n", value);
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_READOUT_DIRECTION, &value_d);
status = setIntegerParam(hReadoutDirection, value_d);
//printf("The READOUT DIRECTION = %f\n", value_d);
break;
case DCAM_IDPROP_TRIGGERSOURCE:
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGERSOURCE, &value);
status = setIntegerParam(hTriggerSource, value);
printf("The = TRIGGER SOURCE = %f\n", value);
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGERSOURCE, &value_d);
status = setIntegerParam(hTriggerSource, value_d);
//printf("The = TRIGGER SOURCE = %f\n", value_d);
break;
case DCAM_IDPROP_TRIGGER_MODE:
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGER_MODE, &value);
status = setIntegerParam(hTriggerMode, value);
printf("The TRIGGER MODE = %f\n", value);
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGER_MODE, &value_d);
status = setIntegerParam(hTriggerMode, value_d);
//printf("The TRIGGER MODE = %f\n", value_d);
break;
case DCAM_IDPROP_TRIGGERACTIVE:
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGERACTIVE, &value);
status = setIntegerParam(hTriggerActive, value);
printf("The TRIGGER ACTIVE = %f\n", value);
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGERACTIVE, &value_d);
status = setIntegerParam(hTriggerActive, value_d);
//printf("The TRIGGER ACTIVE = %f\n", value_d);
break;
case DCAM_IDPROP_TRIGGER_GLOBALEXPOSURE:
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGER_GLOBALEXPOSURE, &value);
status = setIntegerParam(hTriggerGlobalExposure, value);
printf("The TRIGGER GLOBAL EXPOSURE = %f\n", value);
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGER_GLOBALEXPOSURE, &value_d);
status = setIntegerParam(hTriggerGlobalExposure, value_d);
//printf("The TRIGGER GLOBAL EXPOSURE = %f\n", value_d);
break;
case DCAM_IDPROP_TRIGGERPOLARITY:
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_POLARITY, &value);
status = setIntegerParam(hTriggerPolarity, value);
printf("The TRIGGER POLARITY = %f\n", value);
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGERPOLARITY, &value_d);
status = setIntegerParam(hTriggerPolarity, value_d);
//printf("The TRIGGER POLARITY = %f\n", value_d);
break;
case DCAM_IDPROP_TRIGGER_CONNECTOR:
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGER_CONNECTOR, &value);
status = setIntegerParam(hTriggerConnector, value);
printf("The TRIGGER CONNECTOR = %f\n", value);
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGER_CONNECTOR, &value_d);
status = setIntegerParam(hTriggerConnector, value_d);
//printf("The TRIGGER CONNECTOR = %f\n", value_d);
break;
case DCAM_IDPROP_TRIGGERTIMES:
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGERTIMES, &value);
status = setIntegerParam(hTriggerTimes, value);
printf("The TRIGGER TIMES = %f\n", value);
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGERTIMES, &value_d);
status = setIntegerParam(hTriggerTimes, value_d);
//printf("The TRIGGER TIMES = %f\n", value_d);
break;
case DCAM_IDPROP_TRIGGERDELAY:
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGERDELAY, &value);
status = setIntegerParam(hTriggerDelay, value);
printf("The TRIGGER DELAY = %f\n", value);
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGERDELAY, &value_d);
status = setDoubleParam(hTriggerDelay, value_d);
//printf("The TRIGGER DELAY = %f\n", value_d);
break;
case DCAM_IDPROP_INTERNALTRIGGER_HANDLING:
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_INTERNALTRIGGER_HANDLING, &value);
status = setIntegerParam(hInternalTriggerHandling, value);
printf("The INTERNAL TRIGGE HANDLING = %f\n", value);
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_INTERNALTRIGGER_HANDLING, &value_d);
status = setIntegerParam(hInternalTriggerHandling, value_d);
//printf("The INTERNAL TRIGGE HANDLING = %f\n", value_d);
break;
default:
printf("The init parameter not recognised.... = %f\n", value);
printf("The init parameter not recognised.... = %d\n", propertyID);
break;
}
@@ -795,23 +786,19 @@ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value){
printf("[DEBUG]::function ADNumExposures\n");
}
else if (index == ADMinX) {
dcamprop_setvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVPOS, value);
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVPOS, &value_d);
updateSensorSize();
printf("[DEBUG]::function ADMinX\n");
}
else if (index == ADMinY) {
dcamprop_setvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHPOS, value);
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHPOS, &value_d);
updateSensorSize();
printf("[DEBUG]::function ADMinY\n");
}
else if (index == ADSizeX) {
dcamprop_setvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVSIZE, value);
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVSIZE, &value_d);
updateSensorSize();
printf("[DEBUG]::function ADSizeX\n");
}
else if (index == ADSizeY) {
dcamprop_setvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHSIZE, value);
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHSIZE, &value_d);
updateSensorSize();
printf("[DEBUG]::function ADSizeY\n");
}
else if (index == ADReadStatus) {
@@ -901,8 +888,9 @@ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value){
printf("[DEBUG]::function HotPixelCorrectLevel %d\n", value);
}
else if (index == hBinning) {
dcamprop_setvalue(m_hdcam, DCAM_IDPROP_BINNING, value);
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_BINNING, &value_d);
updateSensorSize();
//dcamprop_setvalue(m_hdcam, DCAM_IDPROP_BINNING, value);
//dcamprop_getvalue(m_hdcam, DCAM_IDPROP_BINNING, &value_d);
printf("[DEBUG]::function Binning %d\n", value);
}
else if (index == hSubarrayHPos) {
@@ -1131,7 +1119,6 @@ asynStatus Hama::writeFloat64(asynUser *pasynUser, epicsFloat64 value){
getParamName(index, &paramName);
setDoubleParam(index, value);
if(index == ADAcquireTime) {
status = (asynStatus)setFeature(DCAM_IDPROP_EXPOSURETIME, value);
@@ -1242,6 +1229,7 @@ asynStatus Hama::writeFloat64(asynUser *pasynUser, epicsFloat64 value){
printf("[DEBUG]::function writeFloat64 did not find a parameter\n");
}
setDoubleParam(index, value);
status = (asynStatus) callParamCallbacks();
if (status)
@@ -1258,6 +1246,60 @@ asynStatus Hama::writeFloat64(asynUser *pasynUser, epicsFloat64 value){
return(asynSuccess);
}
//============================================================================
int Hama::updateSensorSize(){
int minH=0, minV=0, sizeH=0, sizeV=0, binning=1;
int status = 0;
double v1,v2,v3,v4,b1;
double a1,a2,a3,a4,a5;
status |= getIntegerParam(ADMinX, &minH);
status |= getIntegerParam(ADMinY, &minV);
status |= getIntegerParam(ADSizeX, &sizeH);
status |= getIntegerParam(ADSizeY, &sizeV);
status |= getIntegerParam(hBinning, &binning);
printf("minH = %d\n", minH);
dcamprop_setvalue(m_hdcam, DCAM_IDPROP_SUBARRAYMODE, 2);
dcamprop_setvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHPOS, minH);
dcamprop_setvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVPOS, minV);
dcamprop_setvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHSIZE, sizeH);
dcamprop_setvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVSIZE, sizeV);
//dcamprop_setvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVSIZE, sizeV);
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHPOS, &v1);
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVPOS, &v2);
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHSIZE, &v3);
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVSIZE, &v4);
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_BINNING, &b1);
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);
setIntegerParam(hSubarrayMode, 2);
status = (asynStatus) callParamCallbacks();
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) );
return 0;
}
//============================================================================
/*
asynStatus Hama::readEnum(asynUser *pasynUser, char *strings[], int values[],
ADHamaApp/src/hama.h
+2 -1
View File
@@ -280,7 +280,8 @@ private:
int connectCamera();
int disconnectCamera();
int initCamera();
int initCamera();
int updateSensorSize();
// helper functions for dcamapi