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

Refactor sensor size and position definitions

Browse Source
This commit is contained in:
Douglas Araujo
2023-05-30 08:34:47 +02:00
committed by Iocuser
parent 374a84971b
commit 41d69d3ef1
3 changed files with 150 additions and 368 deletions
Download Patch File Download Diff File Expand all files Collapse all files
ADHamaApp/Db/hama.template
+24 -19
View File
@@ -90,6 +90,30 @@ record(mbbi, "$(P)$(R)ColorMode_RBV") {
field(SVVL, "")
}
record("*", "$(P)$(R)SizeX")
{
field(DRVH, "2048")
field(DRVL, "4")
}
record("*", "$(P)$(R)SizeY")
{
field(DRVH, "2048")
field(DRVL, "4")
}
record("*", "$(P)$(R)MinX")
{
field(DRVH, "2044")
field(DRVL, "0")
}
record("*", "$(P)$(R)MinY")
{
field(DRVH, "2044")
field(DRVL, "0")
}
record("*", "$(P)$(R)AcquirePeriod_RBV")
{
field(FLNK, "$(P)$(R)#EVRAcquireTime-S.PROC PP MS")
@@ -701,25 +725,6 @@ record(mbbi, "$(P)$(R)SubarrayMode-RB") {
}
##########################################################################
# Feature #
##########################################################################
record(ao, "$(P)$(R)ExposureTime-S") {
field(DESC, "")
field(DTYP, "asynFloat64")
field(DRVL, "0.001004")
field(DRVH, "10.0")
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_EXPOSURE_TIME")
field(VAL, "0.009998")
}
record(ai, "$(P)$(R)ExposureTime-RB") {
field(DESC, "")
field(DTYP, "asynFloat64")
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_EXPOSURE_TIME")
field(SCAN, "I/O Intr")
}
##########################################################################
# ALU #
##########################################################################
ADHamaApp/src/hama.cpp
+122 -339
View File
@@ -103,9 +103,6 @@ Hama::Hama(const char* portName, int cameraId, int maxBuffers, size_t maxMemory,
createParam( hSubarrayVSizeString, asynParamInt32, &hSubarrayVSize);
createParam( hSubarrayModeString, asynParamInt32, &hSubarrayMode);
//Feature
createParam( hExposureTimeString, asynParamFloat64, &hExposureTime);
//ALU
createParam( hDefectCorrectModeString, asynParamInt32, &hDefectCorrectMode);
createParam( hHotPixelCorrectLevelString, asynParamInt32, &hHotPixelCorrectLevel);
@@ -481,11 +478,10 @@ int Hama::readParameter(int propertyID){
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;
case DCAM_IDPROP_EXPOSURETIME:
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_EXPOSURETIME, &dvalue);
status = setDoubleParam(ADAcquireTime, dvalue);
break;
// - alu
case DCAM_IDPROP_DEFECTCORRECT_MODE: //(RW123)
@@ -949,177 +945,6 @@ 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) {
asynStatus status = asynSuccess;
@@ -1150,18 +975,6 @@ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value) {
stopAcquire();
}
}
/*
else if (index == ADMaxSizeX_RBV) {
dcamprop_setvalue(m_hdcam, DETECTOR_PIXEL_NUM_HORZ, value);
dcamprop_getvalue(m_hdcam, DETECTOR_PIXEL_NUM_HORZ, &value_d);
printf("[DEBUG]::function ADNumExposures\n");
}
else if (index == ADMaxSizeY_RBV) {
dcamprop_setvalue(m_hdcam, DETECTOR_PIXEL_NUM_VERT, value);
dcamprop_getvalue(m_hdcam, DETECTOR_PIXEL_NUM_VERT, &value_d);
printf("[DEBUG]::function ADMinX\n");
}
*/
else if (index == ADImageMode) {
// dcamprop_setvalue(m_hdcam, DCAM_IDPROP_, value);
// dcamprop_getvalue(m_hdcam, DCAM_IDPROP_, &value_d);
@@ -1172,131 +985,123 @@ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value) {
//dcamprop_getvalue(m_hdcam, DCAM_IDPROP_EXPOSURETIME, &value_d);
printf("[DEBUG]::writeInit32 ADNumExposures\n");
}
else if (index == ADMinX) {
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) {
int sensorV = 2048, minV = 0, sizeV = 0;
double dFrameBytes = 0;
getIntegerParam(ADMinY, &minV);
getIntegerParam(ADSizeY, &sizeV);
else if (index == ADMinX) {
int minH = 0, sizeH = 0;
double dFrameBytes = 0;
getIntegerParam(ADMinX, &minH);
getIntegerParam(ADSizeX, &sizeH);
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) {
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);
}
if(sizeH > (MAX_H_SENSOR_SIZE - minH)) {
sizeH = MAX_H_SENSOR_SIZE - 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);
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);
}
readParameter(DCAM_IDPROP_TIMING_READOUTTIME);
}
else if (index == ADMinY) {
int minV = 0, sizeV = 0;
double dFrameBytes = 0;
status = getIntegerParam(ADMinY, &minV);
getIntegerParam(ADSizeY, &sizeV);
}
else if (index == ADSizeY) {
int sensorY = 2048, minY = 0, sizeY = 0;
double dFrameBytes = 0;
getIntegerParam(ADMinY, &minY);
getIntegerParam(ADSizeY, &sizeY);
if(sizeV > (MAX_V_SENSOR_SIZE - minV)) {
sizeV = MAX_V_SENSOR_SIZE - 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);
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_SUBARRAYVSIZE, &dsizeV);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVPOS, &dminV);
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &dFrameBytes);
status = setIntegerParam(hImageFramebytes, dFrameBytes);
}
readParameter(DCAM_IDPROP_TIMING_READOUTTIME);
}
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 == ADSizeX) {
int minX = 0, sizeX = 0;
double dFrameBytes = 0;
getIntegerParam(ADMinX, &minX);
getIntegerParam(ADSizeX, &sizeX);
}
if(sizeX < MAX_H_SENSOR_SIZE - minX) {
double dsizeX = roundToNearestMultipleOfFour(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);
value = (int)dsizeX;
}
else {
double dsizeX = MAX_H_SENSOR_SIZE - minX;
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);
value = (int)dsizeX;
}
readParameter(DCAM_IDPROP_TIMING_READOUTTIME);
}
else if (index == ADSizeY) {
int minY = 0, sizeY = 0;
double dFrameBytes = 0;
getIntegerParam(ADMinY, &minY);
getIntegerParam(ADSizeY, &sizeY);
if(sizeY < MAX_V_SENSOR_SIZE - minY) {
double dsizeY = roundToNearestMultipleOfFour(sizeY);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVSIZE, &dsizeY);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &dFrameBytes);
value = (int)dsizeY;
status = setIntegerParam(hImageFramebytes, dFrameBytes);
}
else {
double dsizeY = 0;
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVSIZE, &dsizeY);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &dFrameBytes);
status = setIntegerParam(hImageFramebytes, dFrameBytes);
value = (int)dsizeY;
}
readParameter(DCAM_IDPROP_TIMING_READOUTTIME);
}
else if (index == ADReadStatus) {
// dcamprop_setvalue(m_hdcam, DCAM_IDPROP_, value);
// dcamprop_getvalue(m_hdcam, DCAM_IDPROP_, &value_d);
printf("[DEBUG]::writeInit32 ADReadStatus\n");
}
//-- Sensor mode and speed
else if (index == hSensorMode) {
printf("[DEBUG]::writeInit32 SensorMode %d\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SENSORMODE, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
else if (index == hReadoutSpeed) {
printf("[DEBUG]::writeInit32 ReadoutSpeed %d\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_READOUTSPEED, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
else if (index == hSensorMode) {
printf("[DEBUG]::writeInit32 SensorMode %d\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SENSORMODE, &dvalue);
if (failed(m_err)) printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
readParameter(DCAM_IDPROP_TIMING_READOUTTIME);
}
else if (index == hReadoutSpeed) {
printf("[DEBUG]::writeInit32 ReadoutSpeed %d\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_READOUTSPEED, &dvalue);
if (failed(m_err)) printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
readParameter(DCAM_IDPROP_TIMING_READOUTTIME);
}
else if (index == hReadoutDirection) {
printf("[DEBUG]::writeInit32 ReadoutDirection %d\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_READOUT_DIRECTION, &dvalue, 0);
@@ -1378,36 +1183,6 @@ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value) {
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);
if(failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
else if (index == hSubarrayHSize) {
printf("[DEBUG]::writeInit32 SubarrayHSize %d\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHSIZE, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
else if (index == hSubarrayVPos) {
printf("[DEBUG]::writeInit32 SubarrayVPos %d\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVPOS, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
else if (index == hSubarrayVSize) {
printf("[DEBUG]::writeInit32 SubarrayVSize %d\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVSIZE, &dvalue);
if(failed(m_err)) {
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);
@@ -1642,7 +1417,6 @@ asynStatus Hama::writeFloat64(asynUser *pasynUser, epicsFloat64 value){
//-- Feature
if(index == ADAcquireTime) {
printf("[DEBUG]::function ADAcquireTime from camera: %f\n", value);
int trigger_mode = 0;
double acquire_period = 0;
status = getDoubleParam(ADAcquirePeriod, &acquire_period);
@@ -1662,7 +1436,10 @@ asynStatus Hama::writeFloat64(asynUser *pasynUser, epicsFloat64 value){
status = setIntegerParam(hTriggerSource, DCAMPROP_TRIGGERSOURCE__INTERNAL);
callParamCallbacks();
}
}
}
readParameter(DCAM_IDPROP_TIMING_READOUTTIME);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_EXPOSURETIME, &value);
}
else if(index == ADAcquirePeriod) {
@@ -2393,6 +2170,12 @@ int Hama::getProperties(){
return 0;
}
int Hama::roundToNearestMultipleOfFour(int value) {
int remainder = value % 4;
if (remainder == 0) return value;
else if (remainder <= 2) return value - remainder;
else return value + (4 - remainder);
}
//============================================================================
ADHamaApp/src/hama.h
+4 -10
View File
@@ -6,6 +6,9 @@
#define MAX_FEATURE_NAME_LEN 64
#define MAX_H_SENSOR_SIZE 2048
#define MAX_V_SENSOR_SIZE 2048
#define hFrameRateString "H_FRAMERATE"
#define hHamaNameString "H_HAMA_NAME" /* asynOctet ro */
#define hVendorString "H_VENDOR" /* asynOctet ro */
@@ -48,9 +51,6 @@
// #define hFrameBundleMode (usb3 only not implemented)
// #define hFrameBundleNumber (usb3 only not implemented)
// Feature
#define hExposureTimeString "H_EXPOSURE_TIME" /* asynFloat64 rw */
// ALU
#define hDefectCorrectModeString "H_DEFECTCORRECT_MODE" /* asynInt32 rw */
#define hHotPixelCorrectLevelString "H_HOT_PIXEL_CORRECT_LEVEL" /* asynInt32 rw */
@@ -301,14 +301,7 @@ private:
int connectCamera();
int disconnectCamera();
int initCamera();
// 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);
@@ -316,6 +309,7 @@ private:
int getProperties();
int roundToNearestMultipleOfFour(int value);
asynStatus setFeature(int featureIndex, double value);
};