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

remove comments and old code

Browse Source
This commit is contained in:
Iocuser
2023-02-08 11:33:44 +01:00
parent ed7881d93c
commit 27dabf4fdc
2 changed files with 127 additions and 429 deletions
Download Patch File Download Diff File Expand all files Collapse all files
ADHamaApp/src/hama.cpp
+113 -421
View File
@@ -193,16 +193,6 @@ Hama::Hama(const char* portName, int cameraId, int maxBuffers, size_t maxMemory,
printf("\n\n============================ Init Camera =========================\n");
initCamera();
printf("[DEBUG]:: FIRST_HAMA_PARAM = %d \n", FIRST_HAMA_PARAM);
//printf("[-DEBUG]:: FIRST_HAMA_PARAM = %d / LAST_HAMA_PARAM = %d, %d)\n",
//FIRST_HAMA_PARAM, LAST_HAMA_PARAM, NUM_HAMA_PARAMS);
// printf("\n\n============================ Info Camera =========================\n");
//dcamcon_show_dcamdev_info( m_hdcam );
//printf("\n\n============================ Info Camera Details =================\n");
//dcamcon_show_dcamdev_info_detail( m_hdcam )
printf("\n\n============================ Start Threads =======================\n");
/* launch image read task */
epicsThreadCreate("HamaImageTask",
@@ -233,93 +223,94 @@ int Hama::initCamera(){
int err = 0;
err |= getParameterStr(DCAM_IDSTR_VENDOR);
err |= getParameterStr(DCAM_IDSTR_MODEL);
err |= getParameterStr(DCAM_IDSTR_CAMERAID);
err |= getParameterStr(DCAM_IDSTR_BUS);
err |= getParameterStr(DCAM_IDSTR_CAMERAVERSION);
err |= getParameterStr(DCAM_IDSTR_DRIVERVERSION);
err |= getParameterStr(DCAM_IDSTR_MODULEVERSION);
err |= getParameterStr(DCAM_IDSTR_DCAMAPIVERSION);
err |= readParameterStr(DCAM_IDSTR_VENDOR);
err |= readParameterStr(DCAM_IDSTR_MODEL);
err |= readParameterStr(DCAM_IDSTR_CAMERAID);
err |= readParameterStr(DCAM_IDSTR_BUS);
err |= readParameterStr(DCAM_IDSTR_CAMERAVERSION);
err |= readParameterStr(DCAM_IDSTR_DRIVERVERSION);
err |= readParameterStr(DCAM_IDSTR_MODULEVERSION);
err |= readParameterStr(DCAM_IDSTR_DCAMAPIVERSION);
// SENSOR MODE AND SPEED ------------------------
err |= getParameter(DCAM_IDPROP_SENSORMODE);
err |= getParameter(DCAM_IDPROP_READOUTSPEED);
err |= getParameter(DCAM_IDPROP_READOUT_DIRECTION);
err |= readParameter(DCAM_IDPROP_SENSORMODE);
err |= readParameter(DCAM_IDPROP_READOUTSPEED);
err |= readParameter(DCAM_IDPROP_READOUT_DIRECTION);
// TRIGGER --------------------------------------
err |= getParameter(DCAM_IDPROP_TRIGGERSOURCE);
err |= getParameter(DCAM_IDPROP_TRIGGER_MODE);
err |= getParameter(DCAM_IDPROP_TRIGGERACTIVE);
err |= getParameter(DCAM_IDPROP_TRIGGER_GLOBALEXPOSURE);
err |= getParameter(DCAM_IDPROP_TRIGGERPOLARITY);
err |= getParameter(DCAM_IDPROP_TRIGGER_CONNECTOR);
err |= getParameter(DCAM_IDPROP_TRIGGERTIMES);
err |= getParameter(DCAM_IDPROP_TRIGGERDELAY);
err |= getParameter(DCAM_IDPROP_INTERNALTRIGGER_HANDLING);
err |= readParameter(DCAM_IDPROP_TRIGGERSOURCE);
err |= readParameter(DCAM_IDPROP_TRIGGER_MODE);
err |= readParameter(DCAM_IDPROP_TRIGGERACTIVE);
err |= readParameter(DCAM_IDPROP_TRIGGER_GLOBALEXPOSURE);
err |= readParameter(DCAM_IDPROP_TRIGGERPOLARITY);
err |= readParameter(DCAM_IDPROP_TRIGGER_CONNECTOR);
err |= readParameter(DCAM_IDPROP_TRIGGERTIMES);
err |= readParameter(DCAM_IDPROP_TRIGGERDELAY);
err |= readParameter(DCAM_IDPROP_INTERNALTRIGGER_HANDLING);
// BINNING AND ROI ------------------------------
err |= getParameter( DCAM_IDPROP_BINNING);
err |= getParameter( DCAM_IDPROP_SUBARRAYHPOS);
err |= getParameter( DCAM_IDPROP_SUBARRAYVPOS);
err |= getParameter( DCAM_IDPROP_SUBARRAYHSIZE);
err |= getParameter( DCAM_IDPROP_SUBARRAYVSIZE);
err |= getParameter( DCAM_IDPROP_IMAGE_FRAMEBYTES);
err |= getParameter( DCAM_IDPROP_IMAGE_PIXELTYPE);
err |= getParameter( DCAM_IDPROP_IMAGE_WIDTH);
err |= getParameter( DCAM_IDPROP_IMAGE_ROWBYTES);
err |= getParameter( DCAM_IDPROP_IMAGE_HEIGHT);
//SUBARRAYMODE
err |= readParameter( DCAM_IDPROP_BINNING);
err |= readParameter( DCAM_IDPROP_SUBARRAYHPOS);
err |= readParameter( DCAM_IDPROP_SUBARRAYVPOS);
err |= readParameter( DCAM_IDPROP_SUBARRAYHSIZE);
err |= readParameter( DCAM_IDPROP_SUBARRAYVSIZE);
err |= readParameter( DCAM_IDPROP_IMAGE_FRAMEBYTES);
err |= readParameter( DCAM_IDPROP_IMAGE_PIXELTYPE);
err |= readParameter( DCAM_IDPROP_IMAGE_WIDTH);
err |= readParameter( DCAM_IDPROP_IMAGE_ROWBYTES);
err |= readParameter( DCAM_IDPROP_IMAGE_HEIGHT);
// SUBARRAYMODE ------------------------------------------
// FEATURE -----------------------------------------------
//EXPOSURETIME
// EXPOSURETIME ------------------------------------------
// ALU ---------------------------------------------------
err |= getParameter( DCAM_IDPROP_DEFECTCORRECT_MODE);
err |= getParameter( DCAM_IDPROP_HOTPIXELCORRECT_LEVEL);
err |= getParameter( DCAM_IDPROP_INTENSITYLUT_MODE);
err |= getParameter( DCAM_IDPROP_INTENSITYLUT_PAGE);
err |= getParameter( DCAM_IDPROP_EXTRACTION_MODE);
err |= readParameter( DCAM_IDPROP_DEFECTCORRECT_MODE);
err |= readParameter( DCAM_IDPROP_HOTPIXELCORRECT_LEVEL);
err |= readParameter( DCAM_IDPROP_INTENSITYLUT_MODE);
err |= readParameter( DCAM_IDPROP_INTENSITYLUT_PAGE);
err |= readParameter( DCAM_IDPROP_EXTRACTION_MODE);
// OUTPUT TRIGGER ----------------------------------------
err |= getParameter(DCAM_IDPROP_OUTPUTTRIGGER_ACTIVE);
err |= getParameter(DCAM_IDPROP_NUMBEROF_OUTPUTTRIGGERCONNECTOR);
err |= readParameter(DCAM_IDPROP_OUTPUTTRIGGER_ACTIVE);
err |= readParameter(DCAM_IDPROP_NUMBEROF_OUTPUTTRIGGERCONNECTOR);
// MASTER PULSE ------------------------------------------
// SYNCHRONOUS TIMING ------------------------------------
err |= getParameter( DCAM_IDPROP_TIMING_READOUTTIME);
err |= getParameter( DCAM_IDPROP_TIMING_CYCLICTRIGGERPERIOD);
err |= getParameter( DCAM_IDPROP_TIMING_MINTRIGGERBLANKING);
err |= getParameter( DCAM_IDPROP_TIMING_MINTRIGGERINTERVAL);
err |= getParameter( DCAM_IDPROP_TIMING_GLOBALEXPOSUREDELAY);
err |= getParameter( DCAM_IDPROP_TIMING_EXPOSURE);
err |= getParameter( DCAM_IDPROP_TIMING_INVALIDEXPOSUREPERIOD);
err |= getParameter( DCAM_IDPROP_INTERNALFRAMERATE);
err |= getParameter( DCAM_IDPROP_INTERNAL_FRAMEINTERVAL);
err |= getParameter( DCAM_IDPROP_INTERNALLINESPEED);
err |= getParameter( DCAM_IDPROP_INTERNAL_LINEINTERVAL);
err |= readParameter( DCAM_IDPROP_TIMING_READOUTTIME);
err |= readParameter( DCAM_IDPROP_TIMING_CYCLICTRIGGERPERIOD);
err |= readParameter( DCAM_IDPROP_TIMING_MINTRIGGERBLANKING);
err |= readParameter( DCAM_IDPROP_TIMING_MINTRIGGERINTERVAL);
err |= readParameter( DCAM_IDPROP_TIMING_GLOBALEXPOSUREDELAY);
err |= readParameter( DCAM_IDPROP_TIMING_EXPOSURE);
err |= readParameter( DCAM_IDPROP_TIMING_INVALIDEXPOSUREPERIOD);
err |= readParameter( DCAM_IDPROP_INTERNALFRAMERATE);
err |= readParameter( DCAM_IDPROP_INTERNAL_FRAMEINTERVAL);
err |= readParameter( DCAM_IDPROP_INTERNALLINESPEED);
err |= readParameter( DCAM_IDPROP_INTERNAL_LINEINTERVAL);
// SYSTEM INFORMATION ------------------------------------
err |= getParameter(DCAM_IDPROP_COLORTYPE);
err |= getParameter(DCAM_IDPROP_BITSPERCHANNEL);
err |= getParameter(DCAM_IDPROP_IMAGE_TOPOFFSETBYTES);
err |= getParameter(DCAM_IDPROP_BUFFER_ROWBYTES);
err |= getParameter(DCAM_IDPROP_BUFFER_FRAMEBYTES);
err |= getParameter(DCAM_IDPROP_BUFFER_TOPOFFSETBYTES);
err |= getParameter(DCAM_IDPROP_BUFFER_PIXELTYPE);
err |= getParameter(DCAM_IDPROP_RECORDFIXEDBYTES_PERFILE);
err |= getParameter(DCAM_IDPROP_RECORDFIXEDBYTES_PERSESSION);
err |= getParameter(DCAM_IDPROP_RECORDFIXEDBYTES_PERFRAME);
err |= getParameter(DCAM_IDPROP_SYSTEM_ALIVE);
err |= getParameter(DCAM_IDPROP_CONVERSIONFACTOR_COEFF);
err |= getParameter(DCAM_IDPROP_CONVERSIONFACTOR_OFFSET);
err |= getParameter(DCAM_IDPROP_NUMBEROF_VIEW);
err |= getParameter(DCAM_IDPROP_TIMESTAMP_PRODUCER);
err |= getParameter(DCAM_IDPROP_FRAMESTAMP_PRODUCER);
err |= readParameter(DCAM_IDPROP_COLORTYPE);
err |= readParameter(DCAM_IDPROP_BITSPERCHANNEL);
err |= readParameter(DCAM_IDPROP_IMAGE_TOPOFFSETBYTES);
err |= readParameter(DCAM_IDPROP_BUFFER_ROWBYTES);
err |= readParameter(DCAM_IDPROP_BUFFER_FRAMEBYTES);
err |= readParameter(DCAM_IDPROP_BUFFER_TOPOFFSETBYTES);
err |= readParameter(DCAM_IDPROP_BUFFER_PIXELTYPE);
err |= readParameter(DCAM_IDPROP_RECORDFIXEDBYTES_PERFILE);
err |= readParameter(DCAM_IDPROP_RECORDFIXEDBYTES_PERSESSION);
err |= readParameter(DCAM_IDPROP_RECORDFIXEDBYTES_PERFRAME);
err |= readParameter(DCAM_IDPROP_SYSTEM_ALIVE);
err |= readParameter(DCAM_IDPROP_CONVERSIONFACTOR_COEFF);
err |= readParameter(DCAM_IDPROP_CONVERSIONFACTOR_OFFSET);
err |= readParameter(DCAM_IDPROP_NUMBEROF_VIEW);
err |= readParameter(DCAM_IDPROP_TIMESTAMP_PRODUCER);
err |= readParameter(DCAM_IDPROP_FRAMESTAMP_PRODUCER);
err |= getParameter(DETECTOR_PIXEL_NUM_HORZ);
err |= getParameter(DETECTOR_PIXEL_NUM_VERT);
err |= readParameter(DETECTOR_PIXEL_NUM_HORZ);
err |= readParameter(DETECTOR_PIXEL_NUM_VERT);
if(err){
@@ -330,7 +321,7 @@ return err;
}
//============================================================================
int Hama::getParameterStr(int propertyID){
int Hama::readParameterStr(int propertyID){
asynStatus status = asynSuccess;
@@ -391,33 +382,33 @@ int Hama::getParameterStr(int propertyID){
callParamCallbacks();
return int(status);
return status;
}
//============================================================================
asynStatus Hama::readAttributes(){
asynStatus status = asynSuccess;
int status = 0;
getParameter( DCAM_IDPROP_COLORTYPE );
//status |= getParameter( DCAM_IDPROP_BITSPERCHANNEL );
status = getParameter( DCAM_IDPROP_IMAGE_ROWBYTES );
status = getParameter( DCAM_IDPROP_IMAGE_FRAMEBYTES );
status = getParameter( DCAM_IDPROP_IMAGE_TOPOFFSETBYTES );
//status |= getParameter( DCAM_IDPROP_IMAGE_PIXELTYPE );
status = getParameter( DCAM_IDPROP_BUFFER_ROWBYTES );
status = getParameter( DCAM_IDPROP_BUFFER_FRAMEBYTES );
status = getParameter( DCAM_IDPROP_BUFFER_TOPOFFSETBYTES );
status = getParameter( DCAM_IDPROP_BUFFER_PIXELTYPE );
status = getParameter( DCAM_IDPROP_RECORDFIXEDBYTES_PERFILE );
status = getParameter( DCAM_IDPROP_RECORDFIXEDBYTES_PERSESSION );
status = getParameter( DCAM_IDPROP_RECORDFIXEDBYTES_PERFRAME );
status = getParameter( DCAM_IDPROP_SYSTEM_ALIVE );
status = getParameter( DCAM_IDPROP_CONVERSIONFACTOR_COEFF );
status = getParameter( DCAM_IDPROP_CONVERSIONFACTOR_OFFSET );
status = getParameter( DCAM_IDPROP_NUMBEROF_VIEW );
readParameter( DCAM_IDPROP_COLORTYPE );
//status |= readParameter( DCAM_IDPROP_BITSPERCHANNEL );
status = readParameter( DCAM_IDPROP_IMAGE_ROWBYTES );
status = readParameter( DCAM_IDPROP_IMAGE_FRAMEBYTES );
status = readParameter( DCAM_IDPROP_IMAGE_TOPOFFSETBYTES );
//status |= readParameter( DCAM_IDPROP_IMAGE_PIXELTYPE );
status = readParameter( DCAM_IDPROP_BUFFER_ROWBYTES );
status = readParameter( DCAM_IDPROP_BUFFER_FRAMEBYTES );
status = readParameter( DCAM_IDPROP_BUFFER_TOPOFFSETBYTES );
status = readParameter( DCAM_IDPROP_BUFFER_PIXELTYPE );
status = readParameter( DCAM_IDPROP_RECORDFIXEDBYTES_PERFILE );
status = readParameter( DCAM_IDPROP_RECORDFIXEDBYTES_PERSESSION );
status = readParameter( DCAM_IDPROP_RECORDFIXEDBYTES_PERFRAME );
status = readParameter( DCAM_IDPROP_SYSTEM_ALIVE );
status = readParameter( DCAM_IDPROP_CONVERSIONFACTOR_COEFF );
status = readParameter( DCAM_IDPROP_CONVERSIONFACTOR_OFFSET );
status = readParameter( DCAM_IDPROP_NUMBEROF_VIEW );
return status;
return (asynStatus)status;
}
@@ -474,7 +465,7 @@ return status;
//============================================================================
asynStatus Hama::getParameter(int propertyID){
int Hama::readParameter(int propertyID){
asynStatus status = asynSuccess;
double dvalue = 0;
@@ -483,23 +474,14 @@ asynStatus Hama::getParameter(int propertyID){
// - sensor mode and speed
case DCAM_IDPROP_SENSORMODE: //(RW1--)
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SENSORMODE, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "SENSOR MODE", "IDPROP:0x%08x, VALUE:%f\n", propertyID, dvalue);
}
status = setIntegerParam(hSensorMode, dvalue);
break;
case DCAM_IDPROP_READOUTSPEED: //(RW1--)
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_READOUTSPEED, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "READOUT SPEED", "IDPROP:0x%08x, VALUE:%f\n", propertyID, dvalue);
}
status = setIntegerParam(hReadoutSpeed, dvalue);
break;
case DCAM_IDPROP_READOUT_DIRECTION: // (RW1--)
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_READOUT_DIRECTION, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "R DIRECTION", "IDPROP:0x%08x, VALUE:%f\n", propertyID, dvalue);
}
status = setIntegerParam(hReadoutDirection, dvalue);
break;
// - trigger
@@ -819,30 +801,18 @@ asynStatus Hama::getParameter(int propertyID){
break;
case DCAM_IDPROP_IMAGE_WIDTH:
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_WIDTH, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "IMAGE WIDTH", "IDPROP:0x%08x, VALUE:%f\n", propertyID, dvalue);
}
status = setIntegerParam(ADBinX, dvalue);
break;
case DCAM_IDPROP_IMAGE_HEIGHT:
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_HEIGHT, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "IMAGE HEIGHT", "IDPROP:0x%08x, VALUE:%f\n", propertyID, dvalue);
}
status = setIntegerParam(ADBinY, (int)dvalue);
break;
case DETECTOR_PIXEL_NUM_HORZ:
m_err = dcamprop_getvalue(m_hdcam, DETECTOR_PIXEL_NUM_HORZ, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "DETECT)R_PIXEL_SIZE_HORZ", "IDPROP:0x%08x, VALUE:%f\n", propertyID, dvalue);
}
status = setIntegerParam(ADMaxSizeX, dvalue);
break;
case DETECTOR_PIXEL_NUM_VERT:
m_err = dcamprop_getvalue(m_hdcam, DETECTOR_PIXEL_NUM_VERT, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "DETECT)R_PIXEL_SIZE_VERT", "IDPROP:0x%08x, VALUE:%f\n", propertyID, dvalue);
}
status = setIntegerParam(ADMaxSizeY, dvalue);
break;
case DCAM_IDPROP_TIMESTAMP_PRODUCER:
@@ -868,29 +838,19 @@ asynStatus Hama::getParameter(int propertyID){
/* Do callbacks so higher layers see any changes */
status = callParamCallbacks();
/*
if (status)
asynPrint(0, ASYN_TRACE_ERROR,
"%s:%s: error, status=%d function=%d, paramName=%s, value=%d\n",
driverName, functionName, status, index, paramName, value);
else
asynPrint(NULL, ASYN_TRACEIO_DRIVER,
"%s:%s: function=%d, paramName=%s, value=%d\n",
driverName, functionName, index, paramName, value);
*/
return status;
}
//============================================================================
int Hama::setParameter(int paramIndex){
/*
setIntegerParam(ADBinY, 2048);
setIntegerParam(ADBinX, 2048);
setIntegerParam(NDNDimensions, 1);
setIntegerParam(NDArrayCounter, 1);
setIntegerParam(NDDataType, NDUInt16);
setIntegerParam(NDColorMode, NDColorModeMono);
setIntegerParam(NDArraySizeZ, 0);
setIntegerParam(NDArraySize, 5000000);
setStringParam(ADStringToServer, "<not used by driver>");
setStringParam(ADStringFromServer, "<not used by driver>");
setStringParam(ADManufacturer, "Hamamatsu");
*/
return 0;
}
//============================================================================
void Hama::imageTask(){
@@ -1227,16 +1187,7 @@ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value){
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
//-- sensor cooler - implemented in the temperature task
/*
else if (index == hSensorCoolerStatus) {
printf("[DEBUG]::writeInit32 SensorCoolerStatus %d\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SENSORCOOLERSTATUS, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
*/
//-- binning and ROI
else if (index == hBinning) {
readSensor();
@@ -1308,6 +1259,14 @@ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value){
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
else if (index == hIntensityLutMode) {
printf("[DEBUG]::writeInit32 IntensityLutMode %d\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_INTENSITYLUT_MODE, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
/*
else if (index == hExtractionMode) {
printf("[DEBUG]::writeInit32 ExtractionMode %d\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_EXTRACTION_MODE, &dvalue);
@@ -1315,6 +1274,7 @@ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value){
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
*/
//-- Output trigger
else if (index == hOutputTriggerSource0) {
printf("[DEBUG]::writeInit32 OutputTriggerSource0 %d\n", value);
@@ -1360,28 +1320,6 @@ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value){
}
}
else if (index == hOutputTriggerActive0) {
printf("[DEBUG]::writeInit32 OutputTriggerActive0 %d\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_ACTIVE, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
else if (index == hOutputTriggerActive1) {
printf("[DEBUG]::writeInit32 OutputTriggerActive1 %d\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_ACTIVE+0x100, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
else if (index == hOutputTriggerActive2) {
printf("[DEBUG]::writeInit32 OutputTriggerActive2 %d\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_ACTIVE+0x200, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
else if (index == hOutputTriggerKind0) {
printf("[DEBUG]::writeInit32 OutputTriggerKind0 %d\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_KIND, &dvalue);
@@ -1447,13 +1385,7 @@ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value){
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
else if (index == hIntensityLutMode) {
printf("[DEBUG]::writeInit32 IntensityLutMode %d\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_INTENSITYLUT_MODE, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
else if (index == hMasterPulseBurstTimes) {
printf("[DEBUG]::writeInit32 MasterPulseBurstTimes %d\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_MASTERPULSE_BURSTTIMES, &dvalue);
@@ -1471,57 +1403,6 @@ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value){
}
}
/*
else if (index == hBufferRowbytes) {
printf("[DEBUG]::writeInit32 BufferRowBytes %d\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_BUFFER_ROWBYTES, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
else if (index == hTimingExposure) {
printf("[DEBUG]::writeInit32 TimingExposure %d\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TIMING_EXPOSURE, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
else if (index == ADBinX) {
printf("[DEBUG]::writeInit32 ImageWidth %d\n", value);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_WIDTH, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
else if (index == ADBinY) {
printf("[DEBUG]::writeInit32 ImageHeight %d\n", value);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_HEIGHT, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
else if (index == hImageRowbytes) {
printf("[DEBUG]::writeInit32 ImageRowBytes %d\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_IMAGE_ROWBYTES, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
else if (index == hImageFramebytes) {
printf("[DEBUG]::writeInit32 ImageFramBytes %d\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
else if (index == hImageTopOffsetBytes) {
printf("[DEBUG]::writeInit32 ImageTopOffsetBytes %d\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_IMAGE_TOPOFFSETBYTES, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
*/
else if (index == hImagePixelType) {
printf("[DEBUG]::writeInit32 ImagePixelType %d\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_IMAGE_PIXELTYPE, &dvalue);
@@ -1529,99 +1410,6 @@ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value){
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
/*
else if (index == hBufferFramebytes) {
printf("[DEBUG]::writeInit32 BufferFrameBytes %d\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_BUFFER_FRAMEBYTES, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
else if (index == hBufferTopOffsetBytes) {
printf("[DEBUG]::writeInit32 BufferTopOffsetBytes %d\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_BUFFER_TOPOFFSETBYTES, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
else if (index == hBufferPixelType) {
printf("[DEBUG]::writeInit32 BufferPixelType %d\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_BUFFER_PIXELTYPE, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
else if (index == hRecordFixedBytesPerFile) {
printf("[DEBUG]::writeInit32 ecordFixedBytesPerFile %d\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_RECORDFIXEDBYTES_PERFILE, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
else if (index == hRecordFixedBytesPerSession) {
printf("[DEBUG]::writeInit32 RecordFixedBytesPerSesion %d\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_RECORDFIXEDBYTES_PERSESSION, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
else if (index == hRecordFixedBytesPerFrame) {
printf("[DEBUG]::writeInit32 RecordFixedBytesPerFrame %d\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_RECORDFIXEDBYTES_PERFRAME, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
//else if (index == hNumberOfOutputTriggerConnector) {
// printf("[DEBUG]::writeInit32 NumberOutputTriggerConnector %d\n", value);
// m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_NUMBEROF_OUTPUTTRIGGERCONNECTOR, &dvalue);
// if(failed(m_err)) {
// printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
// }
//}
else if (index == hSystemAlive) {
printf("[DEBUG]::writeInit32 SystemAlive %d\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SYSTEM_ALIVE, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
else if (index == hNumberOfView) {
printf("[DEBUG]::writeInit32 NumberOfView %d\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_NUMBEROF_VIEW, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
else if (index == hImageDetectorPixelNumHorz) {
printf("[DEBUG]::writeInit32 ImageDetectorPixelNumHorz %d\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_IMAGEDETECTOR_PIXELHEIGHT, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
else if (index == hImageDetectorPixelNumVert) {
printf("[DEBUG]::writeInit32 ImageDetectorPixelNumVert %d\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_IMAGEDETECTOR_PIXELWIDTH, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
else if (index == hTimeStampProducer) {
printf("[DEBUG]::writeInit32 TimeStampProducer %d\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TIMESTAMP_PRODUCER, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
else if (index == hFrameStampProducer) {
printf("[DEBUG]::writeInit32 FrameStampProducer %d\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_FRAMESTAMP_PRODUCER, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
*/
else{
if(index < FIRST_HAMA_PARAM){
@@ -1783,72 +1571,6 @@ asynStatus Hama::writeFloat64(asynUser *pasynUser, epicsFloat64 value){
}
}
//-- Synchronous timing
/*
else if (index == hTimingReadoutTime) {
printf("[DEBUG]::function TimingReadoutTime %f\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TIMING_READOUTTIME, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
else if (index == hTimingCyclicTriggerPeriod) {
printf("[DEBUG]::function TimingCyclicTriggerPeriod %f\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TIMING_CYCLICTRIGGERPERIOD, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
else if (index == hTimingMinTriggerBlanking) {
printf("[DEBUG]::function TimingMinTriggerBlanking %f\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TIMING_MINTRIGGERBLANKING, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
else if (index == hTimingMinTriggerInterval) {
printf("[DEBUG]::function TimingMinTriggerInterval %f\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TIMING_MINTRIGGERINTERVAL, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
else if (index == hTimingGlobalExposureDelay) {
printf("[DEBUG]::function TimingGlobalExposureDelay %f\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TIMING_GLOBALEXPOSUREDELAY, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
else if (index == hTimingInvalidExposurePeriod) {
printf("[DEBUG]::function TimingEnvalidExposurePeriod %f\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TIMING_INVALIDEXPOSUREPERIOD, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}*/
/* THESE PARAMETERS ARE READ ONLY
else if (index == hInternalFrameRate) {
int sensorMode = 0;
getIntegerParam(hSensorMode, &sensorMode);
if((sensorMode != DCAMPROP_SENSORMODE__AREA) && (sensorMode != DCAMPROP_SENSORMODE__SPLITVIEW)){
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_INTERNALFRAMERATE, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
else{
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_INTERNALFRAMERATE, &dvalue);
}
}
else if (index == hInternalFrameInterval) {
printf("[DEBUG]::function InternalFrameRate %f\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_INTERNAL_FRAMEINTERVAL, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
*/
else if (index == hInternalLineSpeed) {
printf("[DEBUG]::function InternalLineSpeed %f\n", value);
@@ -1864,36 +1586,6 @@ asynStatus Hama::writeFloat64(asynUser *pasynUser, epicsFloat64 value){
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
/*
else if (index == hConversionFactorCoeff) {
printf("[DEBUG]::function ConversionFactorCoeff %f\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_CONVERSIONFACTOR_COEFF, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
else if (index == hConversionFactorOffset) {
printf("[DEBUG]::function ConversionFactorOffset %f\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_CONVERSIONFACTOR_OFFSET, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
else if (index == hImageDetectorPixelWidth) {
printf("[DEBUG]::function ImageDetectorPixelWidth %f\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_IMAGEDETECTOR_PIXELWIDTH, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
else if (index == hImageDetectorPixelHeight) {
printf("[DEBUG]::function ImageDetectorPixelHeight %f\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_IMAGEDETECTOR_PIXELHEIGHT, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
*/
else{
if(index < FIRST_HAMA_PARAM){
status = ADDriver::writeFloat64(pasynUser, value);
ADHamaApp/src/hama.h
+14 -8
View File
@@ -138,15 +138,20 @@ class epicsShareClass Hama : public ADDriver {
public:
Hama(const char*, int, int, size_t, int, int, int);
// ~Hama();
// ~Hama();
/* override ADDriver methods */
virtual asynStatus writeInt32(asynUser *pasynUser, epicsInt32 value);
virtual asynStatus writeFloat64(asynUser *pasynUser, epicsFloat64 value);
// virtual asynStatus getBounds(asynUser *, epicsInt32 *low, epicsInt32 *high);
//virtual asynStatus readEnum(asynUser *pasynUser, char *strings[], int values[],
// int severities[], size_t nElements, size_t *nIn);
virtual void report(FILE *fp, int details);
/* This function could be implemented as overwrite virtual readInt32, readFloat64 */
/* It is however implemented in that way due to sugestion that only */
/* writeInt32, writeFloat64, report should be overwrite */
/* could be changed in the future */
int readParameter(int paramIndex);
int readParameterStr(int paramIndex);
void imageTask();
void temperatureTask();
@@ -279,6 +284,7 @@ private:
epicsEventId startEvent_;
// Helper functions
asynStatus startAcquire(void);
asynStatus stopAcquire(void);
void getImageInformation(HDCAM hdcam, int32& pixeltype, int32& width, int32& rowbytes, int32& height, int32& framebytes);
@@ -298,15 +304,15 @@ private:
asynStatus readAttributes();
asynStatus readSensor();
asynStatus getParameter(int paramIndex);
// helper functions for dcamapi
void printError(HDCAM hdcam, DCAMERR errid, const char* apiname, const char* fmt=NULL, ...);
void printInfo(HDCAM hdcam);
int dcamdev_string( DCAMERR& err, HDCAM hdcam, int32 idStr, char* text, int32 textbytes );
int setParameter(int paramIndex);
int getParameterStr(int paramIndex);
int getProperties();
asynStatus setFeature(int featureIndex, double value);