lin-epics-modules/adorca
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
52c274d5b297ade0ae0f0084da261c6832059c14
adorca/ADOrcaApp/src/orca.cpp
T

2185 lines
85 KiB
C++
Raw Blame History

#include "orca.h"
#include <string.h>
#include "dcamprop.h"
using namespace std;
static const char* driverName = "drvOrca";
// Flow message formatters
#define FLOW(msg) \
asynPrint(pasynUserSelf, ASYN_TRACE_FLOW, "%s::%s: %s\n", driverName, \
functionName, msg)
#define FLOW_ARGS(fmt, ...) \
asynPrint(pasynUserSelf, ASYN_TRACE_FLOW, "%s::%s: " fmt "\n", driverName, \
functionName, __VA_ARGS__);
static void c_imagetask(void* arg) {
Orca* p = (Orca*)arg;
p->imageTask();
}
static void c_temperaturetask(void* arg) {
Orca* p = (Orca*)arg;
p->temperatureTask();
}
//============================================================================
Orca::Orca(const char* portName, int maxBuffers, size_t maxMemory, int priority,
int stackSize, int maxFrames)
: ADDriver(portName, 1, 0, maxBuffers, maxMemory, asynEnumMask,
asynEnumMask,
ASYN_CANBLOCK, /* ASYN_CANBLOCK=1 ASYN_MULTIDEVICE=0 */
1, /* autoConnect=1 */
priority, stackSize),
m_hdcam(NULL) {
const char* functionName = "orcaDetector::orcaDetector";
stopThread = 0;
startEvent_ = epicsEventCreate(epicsEventEmpty);
if (!startEvent_) {
FLOW("epicsEventCreate failure for acquire start event");
return;
}
createAsynParams();
setIntegerParam(NDArrayCallbacks, 1);
setStringParam(ADStatusMessage, "Idle");
callParamCallbacks();
connectCamera();
initCamera();
/* launch image read task */
epicsThreadCreate("OrcaImageTask", epicsThreadPriorityMedium,
epicsThreadGetStackSize(epicsThreadStackMedium),
c_imagetask, this);
/* launch temp read task */
epicsThreadCreate("OrcaTemperatureTask", epicsThreadPriorityMedium,
epicsThreadGetStackSize(epicsThreadStackMedium),
c_temperaturetask, this);
}
void Orca::createAsynParams() {
// General
createParam(hFrameRateString, asynParamFloat64, &hFrameRate);
createParam(hOrcaNameString, asynParamOctet, &hOrcaName);
createParam(hVendorString, asynParamOctet, &hVendor);
createParam(hModelString, asynParamOctet, &hModel);
createParam(hCameraIDString, asynParamOctet, &hCameraID);
createParam(hBusString, asynParamOctet, &hBus);
createParam(hCameraVersionString, asynParamOctet, &hCameraVersion);
createParam(hDriverVersionString, asynParamOctet, &hDriverVersion);
createParam(hModuleVersionString, asynParamOctet, &hModuleVersion);
createParam(hDcamApiVersionString, asynParamOctet, &hDcamApiVersion);
// Sensor Mode and Speed
createParam(hSensorModeString, asynParamInt32, &hSensorMode);
createParam(hReadoutSpeedString, asynParamInt32, &hReadoutSpeed);
createParam(hReadoutDirectionString, asynParamInt32, &hReadoutDirection);
// Trigger
createParam(hTriggerSourceString, asynParamInt32, &hTriggerSource);
createParam(hTriggerModeString, asynParamInt32, &hTriggerMode);
createParam(hTriggerActiveString, asynParamInt32, &hTriggerActive);
createParam(hTriggerGlobalExposureString, asynParamInt32,
&hTriggerGlobalExposure);
createParam(hTriggerPolarityString, asynParamInt32, &hTriggerPolarity);
createParam(hTriggerConnectorString, asynParamInt32, &hTriggerConnector);
createParam(hTriggerTimesString, asynParamInt32, &hTriggerTimes);
createParam(hTriggerDelayString, asynParamFloat64, &hTriggerDelay);
createParam(hInternalTriggerHandlingString, asynParamInt32,
&hInternalTriggerHandling);
// Sensor cooler
createParam(hSensorTemperatureString, asynParamFloat64, &hSensorTemperature);
createParam(hSensorCoolerString, asynParamInt32, &hSensorCooler);
createParam(hSensorCoolerStatusString, asynParamInt32, &hSensorCoolerStatus);
// Binning and ROI
createParam(hBinningString, asynParamInt32, &hBinning);
createParam(hSubarrayHPosString, asynParamInt32, &hSubarrayHPos);
createParam(hSubarrayHSizeString, asynParamInt32, &hSubarrayHSize);
createParam(hSubarrayVPosString, asynParamInt32, &hSubarrayVPos);
createParam(hSubarrayVSizeString, asynParamInt32, &hSubarrayVSize);
createParam(hSubarrayModeString, asynParamInt32, &hSubarrayMode);
// ALU
createParam(hDefectCorrectModeString, asynParamInt32, &hDefectCorrectMode);
createParam(hHotPixelCorrectLevelString, asynParamInt32,
&hHotPixelCorrectLevel);
createParam(hIntensityLutModeString, asynParamInt32, &hIntensityLutMode);
createParam(hIntensityLutPageString, asynParamInt32, &hIntensityLutPage);
createParam(hExtractionModeString, asynParamInt32, &hExtractionMode);
// output trigger
createParam(hNumberOfOutputTriggerConnectorString, asynParamInt32,
&hNumberOfOutputTriggerConnector);
createParam(hOutputTriggerSource0String, asynParamInt32,
&hOutputTriggerSource0);
createParam(hOutputTriggerSource1String, asynParamInt32,
&hOutputTriggerSource1);
createParam(hOutputTriggerSource2String, asynParamInt32,
&hOutputTriggerSource2);
createParam(hOutputTriggerPolarity0String, asynParamInt32,
&hOutputTriggerPolarity0);
createParam(hOutputTriggerPolarity1String, asynParamInt32,
&hOutputTriggerPolarity1);
createParam(hOutputTriggerPolarity2String, asynParamInt32,
&hOutputTriggerPolarity2);
createParam(hOutputTriggerActive0String, asynParamInt32,
&hOutputTriggerActive0);
createParam(hOutputTriggerActive1String, asynParamInt32,
&hOutputTriggerActive1);
createParam(hOutputTriggerActive2String, asynParamInt32,
&hOutputTriggerActive2);
createParam(hOutputTriggerDelay0String, asynParamFloat64,
&hOutputTriggerDelay0);
createParam(hOutputTriggerDelay1String, asynParamFloat64,
&hOutputTriggerDelay1);
createParam(hOutputTriggerDelay2String, asynParamFloat64,
&hOutputTriggerDelay2);
createParam(hOutputTriggerPeriod0String, asynParamFloat64,
&hOutputTriggerPeriod0);
createParam(hOutputTriggerPeriod1String, asynParamFloat64,
&hOutputTriggerPeriod1);
createParam(hOutputTriggerPeriod2String, asynParamFloat64,
&hOutputTriggerPeriod2);
createParam(hOutputTriggerKind0String, asynParamInt32, &hOutputTriggerKind0);
createParam(hOutputTriggerKind1String, asynParamInt32, &hOutputTriggerKind1);
createParam(hOutputTriggerKind2String, asynParamInt32, &hOutputTriggerKind2);
createParam(hOutputTriggerBaseSensor0String, asynParamInt32,
&hOutputTriggerBaseSensor0);
createParam(hOutputTriggerBaseSensor1String, asynParamInt32,
&hOutputTriggerBaseSensor1);
createParam(hOutputTriggerBaseSensor2String, asynParamInt32,
&hOutputTriggerBaseSensor2);
createParam(hOutputTriggerPreHsyncCountString, asynParamInt32,
&hOutputTriggerPreHsyncCount);
// Master Puls
createParam(hMasterPulseModeString, asynParamInt32, &hMasterPulseMode);
createParam(hMasterPulseTriggerSourceString, asynParamInt32,
&hMasterPulseTriggerSource);
createParam(hMasterPulseIntervalString, asynParamFloat64,
&hMasterPulseInterval);
createParam(hMasterPulseBurstTimesString, asynParamInt32,
&hMasterPulseBurstTimes);
// Synchronious Timing
createParam(hTimingReadoutTimeString, asynParamFloat64, &hTimingReadoutTime);
createParam(hTimingCyclicTriggerPeriodString, asynParamFloat64,
&hTimingCyclicTriggerPeriod);
createParam(hTimingMinTriggerBlankingString, asynParamFloat64,
&hTimingMinTriggerBlanking);
createParam(hTimingMinTriggerIntervalString, asynParamFloat64,
&hTimingMinTriggerInterval);
createParam(hTimingGlobalExposureDelayString, asynParamFloat64,
&hTimingGlobalExposureDelay);
createParam(hTimingExposureString, asynParamInt32, &hTimingExposure);
createParam(hTimingInvalidExposurePeriodString, asynParamFloat64,
&hTimingInvalidExposurePeriod);
createParam(hInternalFrameRateString, asynParamFloat64, &hInternalFrameRate);
createParam(hInternalFrameIntervalString, asynParamFloat64,
&hInternalFrameInterval);
createParam(hInternalLineSpeedString, asynParamFloat64, &hInternalLineSpeed);
createParam(hInternalLineIntervalString, asynParamFloat64,
&hInternalLineInterval);
// System Information
createParam(hColorTypeString, asynParamInt32, &hColorType);
createParam(hBitPerChannelString, asynParamInt32, &hBitPerChannel);
createParam(hImageRowBytesString, asynParamInt32, &hImageRowbytes);
createParam(hImageFrameBytesString, asynParamInt32, &hImageFramebytes);
createParam(hImageTopOffsetBytesString, asynParamInt32,
&hImageTopOffsetBytes);
createParam(hImagePixelTypeString, asynParamInt32, &hImagePixelType);
createParam(hBufferRowbytesString, asynParamInt32, &hBufferRowbytes);
createParam(hBufferFramebytesString, asynParamInt32, &hBufferFramebytes);
createParam(hBufferTopOffsetBytesString, asynParamInt32,
&hBufferTopOffsetBytes);
createParam(hBufferPixelTypeString, asynParamInt32, &hBufferPixelType);
createParam(hRecordFixedBytesPerFileString, asynParamInt32,
&hRecordFixedBytesPerFile);
createParam(hRecordFixedBytesPerSessionString, asynParamInt32,
&hRecordFixedBytesPerSession);
createParam(hRecordFixedBytesPerFrameString, asynParamInt32,
&hRecordFixedBytesPerFrame);
createParam(hSystemAliveString, asynParamInt32, &hSystemAlive);
createParam(hConversionFactorCoeffString, asynParamFloat64,
&hConversionFactorCoeff);
createParam(hConversionFactorOffsetString, asynParamFloat64,
&hConversionFactorOffset);
createParam(hNumberOfViewString, asynParamInt32, &hNumberOfView);
createParam(hImageDetectorPixelWidthString, asynParamFloat64,
&hImageDetectorPixelWidth);
createParam(hImageDetectorPixelHeightString, asynParamFloat64,
&hImageDetectorPixelHeight);
createParam(hImageDetectorPixelNumHorzString, asynParamInt32,
&hImageDetectorPixelNumHorz);
createParam(hImageDetectorPixelNumVertString, asynParamInt32,
&hImageDetectorPixelNumVert);
createParam(hTimeStampProducerString, asynParamInt32, &hTimeStampProducer);
createParam(hFrameStampProducerString, asynParamInt32, &hFrameStampProducer);
createParam(evrTimeStampString, asynParamOctet, &evrTimeStamp);
createParam(evrCountString, asynParamInt32, &evrCounts);
createParam(evrCountSinceAcqStartString, asynParamInt32,
&evrCountsSinceAcqStart);
createParam(evrTriggerDroppedString, asynParamInt32, &evrTriggerDropped);
createParam(hAcqControlString, asynParamInt32, &hAcqControl);
}
int Orca::initCamera() {
int err = 0;
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 |= readParameter(DCAM_IDPROP_SENSORMODE);
err |= readParameter(DCAM_IDPROP_READOUTSPEED);
err |= readParameter(DCAM_IDPROP_READOUT_DIRECTION);
// TRIGGER --------------------------------------
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 |= 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);
// ALU ---------------------------------------------------
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 |= readParameter(DCAM_IDPROP_OUTPUTTRIGGER_ACTIVE);
err |= readParameter(DCAM_IDPROP_NUMBEROF_OUTPUTTRIGGERCONNECTOR);
// SYNCHRONOUS TIMING ------------------------------------
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 |= 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 |= readParameter(DETECTOR_PIXEL_NUM_HORZ);
err |= readParameter(DETECTOR_PIXEL_NUM_VERT);
if (err) {
}
return err;
}
//============================================================================
int Orca::readParameterStr(int propertyID) {
const char* functionName = "readParameterStr";
asynStatus status = asynSuccess;
char text[256];
DCAMDEV_STRING param;
memset(&param, 0, sizeof(param));
param.size = sizeof(param);
param.text = text;
param.textbytes = sizeof(text);
param.iString = propertyID;
switch (propertyID) {
case DCAM_IDSTR_VENDOR:
dcamdev_getstring(m_hdcam, &param);
status = setStringParam(hVendor, text);
FLOW_ARGS("Vendor %s\n", text);
break;
case DCAM_IDSTR_MODEL:
dcamdev_getstring(m_hdcam, &param);
status = setStringParam(hModel, text);
FLOW_ARGS("Model %s\n", text);
break;
case DCAM_IDSTR_CAMERAID:
dcamdev_getstring(m_hdcam, &param);
status = setStringParam(hCameraID, text);
FLOW_ARGS("CameraID %s\n", text);
break;
case DCAM_IDSTR_BUS:
dcamdev_getstring(m_hdcam, &param);
status = setStringParam(hBus, text);
FLOW_ARGS("Bus %s\n", text);
break;
case DCAM_IDSTR_CAMERAVERSION:
dcamdev_getstring(m_hdcam, &param);
status = setStringParam(hCameraVersion, text);
FLOW_ARGS("CameraVersion %s\n", text);
break;
case DCAM_IDSTR_DRIVERVERSION:
dcamdev_getstring(m_hdcam, &param);
status = setStringParam(hDriverVersion, text);
FLOW_ARGS("DriverVersion %s\n", text);
break;
case DCAM_IDSTR_MODULEVERSION:
dcamdev_getstring(m_hdcam, &param);
status = setStringParam(hModuleVersion, text);
FLOW_ARGS("ModuleVersion %s\n", text);
break;
case DCAM_IDSTR_DCAMAPIVERSION:
dcamdev_getstring(m_hdcam, &param);
status = setStringParam(hDcamApiVersion, text);
FLOW_ARGS("DCAMP Version %s\n", text);
break;
default:
FLOW("NOT SUPPORTED\n");
break;
}
callParamCallbacks();
return status;
}
//============================================================================
int Orca::readParameter(int propertyID, bool processPV) {
const char* functionName = "readParameter";
asynStatus status = asynSuccess;
double dvalue = 0;
switch (propertyID) {
// - sensor mode and speed
case DCAM_IDPROP_SENSORMODE: //(RW1--)
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SENSORMODE, &dvalue);
status = setIntegerParam(hSensorMode, dvalue);
break;
case DCAM_IDPROP_READOUTSPEED: //(RW1--)
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_READOUTSPEED, &dvalue);
status = setIntegerParam(hReadoutSpeed, dvalue);
break;
case DCAM_IDPROP_READOUT_DIRECTION: // (RW1--)
m_err =
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_READOUT_DIRECTION, &dvalue);
status = setIntegerParam(hReadoutDirection, dvalue);
break;
// - trigger
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: // (RW123)
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGER_MODE, &dvalue);
status = setIntegerParam(hTriggerMode, dvalue);
break;
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: //(RW1--)
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGER_GLOBALEXPOSURE,
&dvalue);
status = setIntegerParam(hTriggerGlobalExposure, dvalue);
break;
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: //(RW123)
m_err =
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGER_CONNECTOR, &dvalue);
status = setIntegerParam(hTriggerConnector, dvalue);
break;
case DCAM_IDPROP_TRIGGERTIMES: //(RW123)
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGERTIMES, &dvalue);
status = setIntegerParam(hTriggerTimes, dvalue);
break;
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: //(RW12-)
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_INTERNALTRIGGER_HANDLING,
&dvalue);
status = setIntegerParam(hInternalTriggerHandling, dvalue);
break;
// - sensor cooler
case DCAM_IDPROP_SENSORCOOLERSTATUS: //(R)
m_err =
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SENSORCOOLERSTATUS, &dvalue);
status = setIntegerParam(hSensorCoolerStatus, dvalue);
break;
// - binning and roi
case DCAM_IDPROP_BINNING: //(RW1--)
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_BINNING, &dvalue);
status = setIntegerParam(hBinning, dvalue);
break;
case DCAM_IDPROP_SUBARRAYHSIZE: //(RW1--)
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHSIZE, &dvalue);
status = setIntegerParam(ADSizeX, dvalue);
break;
case DCAM_IDPROP_SUBARRAYVSIZE: //(RW1--)
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVSIZE, &dvalue);
status = setIntegerParam(ADSizeY, dvalue);
break;
case DCAM_IDPROP_SUBARRAYHPOS: //(RW---)
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHPOS, &dvalue);
status = setIntegerParam(ADMinX, dvalue);
break;
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;
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)
m_err =
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_DEFECTCORRECT_MODE, &dvalue);
status = setIntegerParam(hDefectCorrectMode, dvalue);
break;
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: //(RW123)
m_err =
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_INTENSITYLUT_MODE, &dvalue);
status = setIntegerParam(hIntensityLutMode, dvalue);
break;
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: //(RW1--)
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_EXTRACTION_MODE, &dvalue);
status = setIntegerParam(hExtractionMode, dvalue);
break;
// - output trigger
case DCAM_IDPROP_NUMBEROF_OUTPUTTRIGGERCONNECTOR:
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);
m_err = dcamprop_getvalue(
m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_ACTIVE + 0x100, &dvalue);
status = setIntegerParam(hOutputTriggerActive1, dvalue);
m_err = dcamprop_getvalue(
m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_ACTIVE + 0x200, &dvalue);
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:
m_err =
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TIMING_READOUTTIME, &dvalue);
status = setDoubleParam(hTimingReadoutTime, dvalue);
break;
case DCAM_IDPROP_TIMING_CYCLICTRIGGERPERIOD:
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TIMING_CYCLICTRIGGERPERIOD,
&dvalue);
status = setDoubleParam(hTimingCyclicTriggerPeriod, dvalue);
break;
case DCAM_IDPROP_TIMING_MINTRIGGERBLANKING:
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TIMING_MINTRIGGERBLANKING,
&dvalue);
status = setDoubleParam(hTimingMinTriggerBlanking, dvalue);
break;
case DCAM_IDPROP_TIMING_MINTRIGGERINTERVAL:
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TIMING_MINTRIGGERINTERVAL,
&dvalue);
status = setDoubleParam(hTimingMinTriggerInterval, dvalue);
break;
case DCAM_IDPROP_TIMING_GLOBALEXPOSUREDELAY:
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TIMING_GLOBALEXPOSUREDELAY,
&dvalue);
status = setDoubleParam(hTimingGlobalExposureDelay, dvalue);
break;
case DCAM_IDPROP_TIMING_EXPOSURE:
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TIMING_EXPOSURE, &dvalue);
status = setIntegerParam(hTimingExposure, dvalue);
break;
case DCAM_IDPROP_TIMING_INVALIDEXPOSUREPERIOD:
m_err = dcamprop_getvalue(
m_hdcam, DCAM_IDPROP_TIMING_INVALIDEXPOSUREPERIOD, &dvalue);
status = setDoubleParam(hTimingInvalidExposurePeriod, dvalue);
break;
case DCAM_IDPROP_INTERNALFRAMERATE:
m_err =
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_INTERNALFRAMERATE, &dvalue);
status = setDoubleParam(hInternalFrameRate, dvalue);
break;
case DCAM_IDPROP_INTERNAL_FRAMEINTERVAL:
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_INTERNAL_FRAMEINTERVAL,
&dvalue);
status = setDoubleParam(hInternalFrameInterval, dvalue);
break;
case DCAM_IDPROP_INTERNALLINESPEED:
m_err =
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_INTERNALLINESPEED, &dvalue);
status = setDoubleParam(hInternalLineSpeed, dvalue);
break;
case DCAM_IDPROP_INTERNAL_LINEINTERVAL:
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_INTERNAL_LINEINTERVAL,
&dvalue);
status = setDoubleParam(hInternalLineInterval, dvalue);
break;
// - system information
case DCAM_IDPROP_COLORTYPE:
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_COLORTYPE, &dvalue);
status = setIntegerParam(hColorType, dvalue);
break;
case DCAM_IDPROP_BITSPERCHANNEL:
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_BITSPERCHANNEL, &dvalue);
status = setIntegerParam(hBitPerChannel, dvalue);
break;
case DCAM_IDPROP_IMAGE_ROWBYTES:
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_ROWBYTES, &dvalue);
status = setIntegerParam(hImageRowbytes, dvalue);
break;
case DCAM_IDPROP_IMAGE_FRAMEBYTES:
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &dvalue);
status = setIntegerParam(hImageFramebytes, dvalue);
break;
case DCAM_IDPROP_IMAGE_TOPOFFSETBYTES:
m_err =
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_TOPOFFSETBYTES, &dvalue);
status = setIntegerParam(hImageTopOffsetBytes, dvalue);
break;
case DCAM_IDPROP_IMAGE_PIXELTYPE:
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_PIXELTYPE, &dvalue);
status = setIntegerParam(hImagePixelType, dvalue);
break;
case DCAM_IDPROP_BUFFER_ROWBYTES:
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_BUFFER_ROWBYTES, &dvalue);
status = setIntegerParam(hBufferRowbytes, dvalue);
break;
case DCAM_IDPROP_BUFFER_FRAMEBYTES:
m_err =
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_BUFFER_FRAMEBYTES, &dvalue);
status = setIntegerParam(hBufferFramebytes, dvalue);
break;
case DCAM_IDPROP_BUFFER_TOPOFFSETBYTES:
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_BUFFER_TOPOFFSETBYTES,
&dvalue);
status = setIntegerParam(hBufferTopOffsetBytes, dvalue);
break;
case DCAM_IDPROP_BUFFER_PIXELTYPE:
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_BUFFER_PIXELTYPE, &dvalue);
status = setIntegerParam(hBufferPixelType, dvalue);
break;
case DCAM_IDPROP_RECORDFIXEDBYTES_PERFILE:
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_RECORDFIXEDBYTES_PERFILE,
&dvalue);
status = setIntegerParam(hRecordFixedBytesPerFile, dvalue);
break;
case DCAM_IDPROP_RECORDFIXEDBYTES_PERSESSION:
m_err = dcamprop_getvalue(
m_hdcam, DCAM_IDPROP_RECORDFIXEDBYTES_PERSESSION, &dvalue);
status = setIntegerParam(hRecordFixedBytesPerSession, dvalue);
break;
case DCAM_IDPROP_RECORDFIXEDBYTES_PERFRAME:
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_RECORDFIXEDBYTES_PERFRAME,
&dvalue);
status = setIntegerParam(hRecordFixedBytesPerFrame, dvalue);
break;
case DCAM_IDPROP_SYSTEM_ALIVE:
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SYSTEM_ALIVE, &dvalue);
status = setIntegerParam(hSystemAlive, dvalue);
break;
case DCAM_IDPROP_CONVERSIONFACTOR_COEFF:
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_CONVERSIONFACTOR_COEFF,
&dvalue);
status = setDoubleParam(hConversionFactorCoeff, dvalue);
break;
case DCAM_IDPROP_CONVERSIONFACTOR_OFFSET:
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_CONVERSIONFACTOR_OFFSET,
&dvalue);
status = setDoubleParam(hConversionFactorOffset, dvalue);
break;
case DCAM_IDPROP_NUMBEROF_VIEW:
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_NUMBEROF_VIEW, &dvalue);
status = setIntegerParam(hNumberOfView, dvalue);
break;
case DCAM_IDPROP_IMAGE_WIDTH:
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_WIDTH, &dvalue);
status = setIntegerParam(ADBinX, dvalue);
break;
case DCAM_IDPROP_IMAGE_HEIGHT:
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_HEIGHT, &dvalue);
status = setIntegerParam(ADBinY, (int)dvalue);
break;
case DETECTOR_PIXEL_NUM_HORZ:
m_err = dcamprop_getvalue(m_hdcam, DETECTOR_PIXEL_NUM_HORZ, &dvalue);
status = setIntegerParam(ADMaxSizeX, dvalue);
break;
case DETECTOR_PIXEL_NUM_VERT:
m_err = dcamprop_getvalue(m_hdcam, DETECTOR_PIXEL_NUM_VERT, &dvalue);
status = setIntegerParam(ADMaxSizeY, dvalue);
break;
case DCAM_IDPROP_TIMESTAMP_PRODUCER:
m_err =
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TIMESTAMP_PRODUCER, &dvalue);
status = setIntegerParam(hTimeStampProducer, dvalue);
break;
case DCAM_IDPROP_FRAMESTAMP_PRODUCER:
m_err =
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_FRAMESTAMP_PRODUCER, &dvalue);
status = setIntegerParam(hFrameStampProducer, dvalue);
break;
default:
char text[256];
dcamprop_getname(m_hdcam, propertyID, text, sizeof(text));
FLOW_ARGS("Parameter not recognised, IDPROP:0x%08x, NAME:%s\n",
propertyID, text);
break;
}
if (failed(m_err)) {
char text[256] = {'\0'};
dcamprop_getname(m_hdcam, propertyID, text, sizeof(text));
printError(m_hdcam, m_err, "+dcamprop_getvalue()",
"IDPROP:0x%08x, VALUE:%s\n", propertyID, text);
}
if (processPV) status = callParamCallbacks();
return status;
}
//============================================================================
void Orca::imageTask() {
const char* functionName = "imageTask";
int status;
unsigned char* image;
int acquire;
int count = 0;
int callback;
int imageMode = 0;
int totalImages = 0;
int initial_evr_counters = 0;
int evr_counts_since_last_start = 0;
int evr_counts_since_last_start_previous = 0;
int evr_trigger_dropped = 0;
int acqStatus;
uint64_t prevAcquisitionCount = 0;
DCAMCAP_TRANSFERINFO captransferinfo;
epicsTimeStamp prevAcqTime, currentAcqTime;
epicsTimeStamp prev_trigger_time, current_trigger_time;
double elapsedTime;
int evr_counts = 0;
double exposure_time, readout_time;
double maxAcqusitionTime, acqusitionRate;
int triggerMode = DCAMPROP_TRIGGERSOURCE__INTERNAL;
lock();
while (1) {
getIntegerParam(ADAcquire, &acquire);
if (!acquire) {
unlock();
status = epicsEventWait(startEvent_);
lock();
status = startAcquire();
setStringParam(ADStatusMessage, "Acquiring");
setIntegerParam(hAcqControl, 1);
callParamCallbacks();
epicsTimeGetCurrent(&prevAcqTime);
if (status != asynSuccess) {
epicsThreadSleep(.1);
} else {
getIntegerParam(ADNumImages, &totalImages);
getIntegerParam(ADImageMode, &imageMode);
setIntegerParam(ADStatus, ADStatusAcquire);
acquire = 1;
prevAcquisitionCount = 0;
evr_trigger_dropped = 0;
setIntegerParam(ADNumImagesCounter, 0);
getIntegerParam(evrCounts, &initial_evr_counters);
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TIMING_READOUTTIME,
&readout_time);
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_EXPOSURETIME, &exposure_time);
}
}
// get image transfer status.
unlock();
imageTransferStatus(m_hdcam, captransferinfo);
lock();
if (prevAcquisitionCount < (uint64_t)captransferinfo.nFrameCount) {
FLOW_ARGS("Orca Frame Count: %d", captransferinfo.nFrameCount);
prevAcquisitionCount = captransferinfo.nFrameCount;
// get image information
int32 pixeltype = 0, width = 0, rowbytes = 0, height = 0, framebytes = 0;
getImageInformation(m_hdcam, pixeltype, width, rowbytes, height,
framebytes);
if (pixeltype != DCAM_PIXELTYPE_MONO16) {
FLOW("not implement");
return;
}
setIntegerParam(NDArraySizeX, (int)width);
setIntegerParam(NDArraySizeY, (int)height);
/* Do callbacks so higher layers see any changes */
callParamCallbacks();
image = new unsigned char[width * 2 * height];
memset(image, 0, width * 2 * height);
getIntegerParam(NDArrayCounter, &count);
count++;
setIntegerParam(NDArrayCounter, count);
epicsUInt32 ts_sec = 0, ts_microsec = 0;
accessCapturedImage(m_hdcam, captransferinfo.nNewestFrameIndex, image,
width * 2, width, height, ts_sec, ts_microsec);
double timestamp;
getIntegerParam(hTriggerSource, &triggerMode);
if (triggerMode == DCAMPROP_TRIGGERSOURCE__EXTERNAL) {
getIntegerParam(evrCounts, &evr_counts);
evr_counts_since_last_start = evr_counts - initial_evr_counters;
evr_trigger_dropped =
evr_counts_since_last_start - captransferinfo.nFrameCount;
FLOW_ARGS("EVR event count: %d\n", evr_counts);
FLOW_ARGS("evr_counts_since_last_start: %d\n",
evr_counts_since_last_start);
setIntegerParam(evrCountsSinceAcqStart, evr_counts_since_last_start);
setIntegerParam(evrTriggerDropped, evr_trigger_dropped);
char buf[256];
getStringParam(evrTimeStamp, 256, buf);
// remember parsed timestamp values
sscanf(buf, "%u.%u", &mTimeStampSec, &mTimeStampNsec);
timestamp = mTimeStampSec + mTimeStampNsec / 1.e9;
FLOW_ARGS("mTimeStampSec: %u - mTimeStampNsec: %u\n", mTimeStampSec,
mTimeStampNsec);
FLOW_ARGS("Timestamp from evr: %f\n", timestamp);
} else {
timestamp =
(ts_sec + ts_microsec / 1.0e6) - (exposure_time + readout_time);
FLOW_ARGS("Timestamp from camera: %f\n", timestamp);
}
FLOW_ARGS("readout_time: %f - exposure_time: %f\n", readout_time,
exposure_time);
epicsTimeGetCurrent(&currentAcqTime);
elapsedTime = epicsTimeDiffInSeconds(&currentAcqTime, &prevAcqTime);
prevAcqTime = currentAcqTime;
status = setDoubleParam(hFrameRate, (double)(1 / elapsedTime));
getIntegerParam(NDArrayCallbacks, &callback);
if (callback) {
NDArray* pImage;
size_t dims[2];
int itemp = 0;
getIntegerParam(NDArraySizeX, &itemp);
dims[0] = itemp;
getIntegerParam(NDArraySizeY, &itemp);
dims[1] = itemp;
pImage = pNDArrayPool->alloc(2, dims, NDUInt16, 0, 0);
if (pImage) {
pImage->uniqueId = count;
pImage->timeStamp = timestamp;
updateTimeStamp(&pImage->epicsTS);
memcpy(pImage->pData, (epicsUInt16*)image, pImage->dataSize);
getAttributes(pImage->pAttributeList);
doCallbacksGenericPointer(pImage, NDArrayData, 0);
pImage->release();
}
}
delete[] image;
}
setIntegerParam(ADNumImagesCounter, captransferinfo.nFrameCount);
getIntegerParam(evrCounts, &evr_counts);
evr_counts_since_last_start = evr_counts - initial_evr_counters;
if (evr_counts_since_last_start != evr_counts_since_last_start_previous) {
setIntegerParam(evrCountsSinceAcqStart, evr_counts_since_last_start);
epicsTimeGetCurrent(&prev_trigger_time);
evr_counts_since_last_start_previous = evr_counts_since_last_start;
}
getDoubleParam(ADAcquirePeriod, &acqusitionRate);
getIntegerParam(ADStatus, &acqStatus);
maxAcqusitionTime = acqusitionRate * 2;
epicsTimeGetCurrent(&currentAcqTime);
if ((epicsTimeDiffInSeconds(&currentAcqTime, &prevAcqTime) >
maxAcqusitionTime) &&
acqStatus != ADStatusAborted) {
FLOW_ARGS("maxAcqusitionTime %f\n", maxAcqusitionTime);
setShutter(0);
stopAcquire();
setIntegerParam(ADAcquire, 0);
setIntegerParam(hAcqControl, 0);
setIntegerParam(ADStatus, ADStatusError);
setStringParam(ADStatusMessage, "Acquisition timeout");
}
epicsTimeGetCurrent(&current_trigger_time);
if (epicsTimeDiffInSeconds(&current_trigger_time, &prev_trigger_time) >
(exposure_time + readout_time)) {
if ((evr_counts_since_last_start) > captransferinfo.nFrameCount) {
evr_trigger_dropped =
evr_counts_since_last_start - captransferinfo.nFrameCount;
setIntegerParam(evrTriggerDropped, evr_trigger_dropped);
}
}
if ((imageMode == ADImageMultiple &&
totalImages == captransferinfo.nFrameCount) ||
(imageMode == ADImageSingle && captransferinfo.nFrameCount == 1)) {
setShutter(0);
stopAcquire();
setIntegerParam(ADAcquire, 0);
setIntegerParam(hAcqControl, 0);
setIntegerParam(ADStatus, ADStatusIdle);
setStringParam(ADStatusMessage, "Acquisition Done");
}
callParamCallbacks();
}
}
//============================================================================
void Orca::temperatureTask() {
static const char* functionName = "tempTask";
asynStatus status = asynSuccess;
double dvalue = 0;
while (!stopThread) {
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SENSORTEMPERATURE, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_SensorTemperature()", " VALUE:%f\n",
dvalue);
}
status = setDoubleParam(hSensorTemperature, dvalue);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SENSORCOOLERSTATUS, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_SensorCoolerStatus()", "VALUE:%f\n",
dvalue);
}
status = setIntegerParam(hSensorCoolerStatus, dvalue);
if (status) {
asynPrint(pasynUserSelf, ASYN_TRACE_ERROR,
"%s:%s: temperature read error = %d\n", driverName,
functionName, m_err);
}
callParamCallbacks();
epicsThreadSleep(1.0);
}
}
//============================================================================
asynStatus Orca::writeInt32(asynUser* pasynUser, epicsInt32 value) {
asynStatus status = asynSuccess;
const char* functionName = "writeInt32";
const char* paramName;
int index = pasynUser->reason;
int adstatus;
// the setget function required double parameter
double dvalue = double(value);
getParamName(index, &paramName);
/* Ensure that ADStatus is set correctly before we set ADAcquire.*/
getIntegerParam(ADStatus, &adstatus);
status = setIntegerParam(index, value);
if (index == ADAcquire) {
if (value && adstatus != ADStatusAcquire) {
double readoutTime, acquirePeriod, acquireTime;
status = getDoubleParam(hTimingReadoutTime, &readoutTime);
status = getDoubleParam(ADAcquireTime, &acquireTime);
status = getDoubleParam(ADAcquirePeriod, &acquirePeriod);
if (acquirePeriod < (readoutTime + acquireTime)) {
setStringParam(
ADStatusMessage,
"Acquire Period must be greater than ReadoutTime + AcquireTime");
setIntegerParam(ADAcquire, 0);
setIntegerParam(ADStatus, ADStatusAborted);
} else {
/* Send an event to wake up the acq task.*/
setStringParam(ADStatusMessage, "");
epicsEventSignal(this->startEvent_);
}
} else if (!value &&
(adstatus == ADStatusAcquire || adstatus == ADStatusError ||
adstatus == ADStatusWaiting)) {
/* This was a command to stop acquisition */
setIntegerParam(ADStatus, ADStatusAborted);
setIntegerParam(hAcqControl, 0);
setStringParam(ADStatusMessage, "Acquisition aborted by user");
stopAcquire();
}
} else if (index == ADMinX) {
int minH = 0, sizeH = 0;
double dFrameBytes = 0;
getIntegerParam(ADMinX, &minH);
getIntegerParam(ADSizeX, &sizeH);
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, false);
} else if (index == ADMinY) {
int minV = 0, sizeV = 0;
double dFrameBytes = 0;
status = getIntegerParam(ADMinY, &minV);
getIntegerParam(ADSizeY, &sizeV);
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, false);
}
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, false);
}
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, false);
} else if (index == hSensorMode) {
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, false);
}
else if (index == hReadoutSpeed) {
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, false);
}
else if (index == hReadoutDirection) {
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_READOUT_DIRECTION,
&dvalue, 0);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
//-- Trigger
else if (index == hTriggerSource) {
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TRIGGERSOURCE, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
} else if (index == hTriggerMode) {
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TRIGGER_MODE, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
} else if (index == hTriggerActive) {
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TRIGGERACTIVE, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
} else if (index == hTriggerGlobalExposure) {
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TRIGGER_GLOBALEXPOSURE,
&dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
} else if (index == hTriggerPolarity) {
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TRIGGERPOLARITY, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
} else if (index == hTriggerConnector) {
m_err =
dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TRIGGER_CONNECTOR, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
} else if (index == hTriggerTimes) {
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TRIGGERTIMES, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
} else if (index == hInternalTriggerHandling) {
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_INTERNALTRIGGER_HANDLING,
&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) {
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);
} else if (index == hSubarrayMode) {
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYMODE, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
//-- ALU
else if (index == hDefectCorrectMode) {
m_err =
dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_DEFECTCORRECT_MODE, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
} else if (index == hHotPixelCorrectLevel) {
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_HOTPIXELCORRECT_LEVEL,
&dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
} else if (index == hIntensityLutMode) {
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);
}
}
//-- Output trigger
else if (index == hOutputTriggerSource0) {
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_SOURCE,
&dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
} else if (index == hOutputTriggerSource1) {
m_err = dcamprop_setgetvalue(
m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_SOURCE + 0x100, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
} else if (index == hOutputTriggerSource2) {
m_err = dcamprop_setgetvalue(
m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_SOURCE + 0x200, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
else if (index == hOutputTriggerPolarity0) {
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_POLARITY,
&dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
} else if (index == hOutputTriggerPolarity1) {
m_err = dcamprop_setgetvalue(
m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_POLARITY + 0x100, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
} else if (index == hOutputTriggerPolarity2) {
m_err = dcamprop_setgetvalue(
m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_POLARITY + 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) {
m_err =
dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_KIND, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
} else if (index == hOutputTriggerKind1) {
m_err = dcamprop_setgetvalue(
m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_KIND + 0x100, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
} else if (index == hOutputTriggerKind2) {
m_err = dcamprop_setgetvalue(
m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_KIND + 0x200, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
} else if (index == hOutputTriggerBaseSensor0) {
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_BASESENSOR,
&dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
} else if (index == hOutputTriggerBaseSensor1) {
m_err = dcamprop_setgetvalue(
m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_BASESENSOR + 0x100, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
} else if (index == hOutputTriggerBaseSensor2) {
m_err = dcamprop_setgetvalue(
m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_BASESENSOR + 0x200, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
} else if (index == hOutputTriggerPreHsyncCount) {
m_err = dcamprop_setgetvalue(
m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_PREHSYNCCOUNT, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
//-- Master pulse
else if (index == hMasterPulseMode) {
m_err =
dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_MASTERPULSE_MODE, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
} else if (index == hMasterPulseTriggerSource) {
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_MASTERPULSE_TRIGGERSOURCE,
&dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
else if (index == hMasterPulseBurstTimes) {
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_MASTERPULSE_BURSTTIMES,
&dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
//-- Synchronous timing - nothing to implement either is in writeFloat64
//-- System information
else if (index == hBitPerChannel) {
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_BITSPERCHANNEL, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
else if (index == hImagePixelType) {
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_IMAGE_PIXELTYPE, &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::writeInt32(pasynUser, value);
}
}
/* Do callbacks so higher layers see any changes */
status = (asynStatus)callParamCallbacks();
if (status)
asynPrint(pasynUser, ASYN_TRACE_ERROR,
"%s:%s: error, status=%d function=%d, paramName=%s, value=%d\n",
driverName, functionName, status, index, paramName, value);
else
asynPrint(pasynUser, ASYN_TRACEIO_DRIVER,
"%s:%s: function=%d, paramName=%s, value=%d\n", driverName,
functionName, index, paramName, value);
return status;
}
//============================================================================
asynStatus Orca::writeFloat64(asynUser* pasynUser, epicsFloat64 value) {
asynStatus status = asynSuccess;
const char* functionName = "writeFloat64";
const char* paramName;
int index = pasynUser->reason;
double dvalue = value;
getParamName(index, &paramName);
//-- Sensor mode and speed
//-- Feature
if (index == ADAcquireTime) {
int trigger_mode = 0;
double acquire_period = 0;
status = getDoubleParam(ADAcquirePeriod, &acquire_period);
status = getIntegerParam(hTriggerSource, &trigger_mode);
if (trigger_mode == DCAMPROP_TRIGGERSOURCE__EXTERNAL) {
if (value >= acquire_period)
status = asynError;
else {
status = setFeature(DCAM_IDPROP_EXPOSURETIME, value);
}
}
else {
status = setFeature(DCAM_IDPROP_EXPOSURETIME, value);
if (value >= acquire_period) {
status = setFeature(DCAM_IDPROP_TRIGGERSOURCE,
DCAMPROP_TRIGGERSOURCE__INTERNAL);
status =
setIntegerParam(hTriggerSource, DCAMPROP_TRIGGERSOURCE__INTERNAL);
callParamCallbacks();
}
}
readParameter(DCAM_IDPROP_TIMING_READOUTTIME, false);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_EXPOSURETIME, &value);
}
else if (index == ADAcquirePeriod) {
int trigger_mode = 0;
getIntegerParam(hTriggerSource, &trigger_mode);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_EXPOSURETIME, &dvalue);
if (trigger_mode != DCAMPROP_TRIGGERSOURCE__EXTERNAL) {
if (value <= dvalue) {
status = setFeature(DCAM_IDPROP_TRIGGERSOURCE,
DCAMPROP_TRIGGERSOURCE__INTERNAL);
status =
setIntegerParam(hTriggerSource, DCAMPROP_TRIGGERSOURCE__INTERNAL);
} else {
status = setFeature(DCAM_IDPROP_TRIGGERSOURCE,
DCAMPROP_TRIGGERSOURCE__MASTERPULSE);
status = setIntegerParam(hTriggerSource,
DCAMPROP_TRIGGERSOURCE__MASTERPULSE);
status = setFeature(DCAM_IDPROP_MASTERPULSE_INTERVAL, value);
status = setDoubleParam(hMasterPulseInterval, value);
status = setFeature(DCAM_IDPROP_MASTERPULSE_MODE,
DCAMPROP_MASTERPULSE_MODE__CONTINUOUS);
status = setIntegerParam(hMasterPulseMode,
DCAMPROP_MASTERPULSE_MODE__CONTINUOUS);
}
} else {
if (value <= dvalue) status = asynError;
}
}
//-- Trigger
else if (index == hTriggerDelay) {
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TRIGGERDELAY, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
//-- Output trigger
else if (index == hOutputTriggerDelay0) {
m_err =
dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_DELAY, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
} else if (index == hOutputTriggerDelay1) {
m_err = dcamprop_setgetvalue(
m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_DELAY + 0x100, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
} else if (index == hOutputTriggerDelay2) {
m_err = dcamprop_setgetvalue(
m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_DELAY + 0x200, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
else if (index == hOutputTriggerPeriod0) {
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_PERIOD,
&dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
} else if (index == hOutputTriggerPeriod1) {
m_err = dcamprop_setgetvalue(
m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_PERIOD + 0x100, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
} else if (index == hOutputTriggerPeriod2) {
m_err = dcamprop_setgetvalue(
m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_PERIOD + 0x200, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
//-- Master Pulse
else if (index == hMasterPulseInterval) {
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_MASTERPULSE_INTERVAL,
&dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
//-- Synchronous timing
else if (index == hInternalLineSpeed) {
m_err =
dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_INTERNALLINESPEED, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
else if (index == hInternalLineInterval) {
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 < FIRST_HAMA_PARAM) {
status = ADDriver::writeFloat64(pasynUser, value);
}
}
if (status)
asynPrint(pasynUser, ASYN_TRACE_ERROR,
"%s:%s: error, status=%d function=%d, paramName=%s, value=%f\n",
driverName, functionName, status, index, paramName, value);
else {
setDoubleParam(index, value);
callParamCallbacks();
asynPrint(pasynUser, ASYN_TRACEIO_DRIVER,
"%s:%s: function=%d, paramName=%s, value=%f\n", driverName,
functionName, index, paramName, value);
}
return status;
}
//============================================================================
void Orca::report(FILE* fp, int details) {
double dvalue = 0;
fprintf(fp, "Hammamatsu Orca Flash4.0 driver\n");
if (details < 1) return;
// Sensor mode and speed
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SENSORMODE, &dvalue);
fprintf(fp, "SENSOR MODE:\t%f\n", dvalue);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_READOUTSPEED, &dvalue);
fprintf(fp, "READOUT SPEED:\t%f\n", dvalue);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_READOUT_DIRECTION, &dvalue);
fprintf(fp, "READOUT DIRECTION:\t%f\n", dvalue);
// Trigger
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGERSOURCE, &dvalue);
fprintf(fp, "TRIGGER SOURCE:\t%f\n", dvalue);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGER_MODE, &dvalue);
fprintf(fp, "TRIGGER MODE:\t%f\n", dvalue);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGERACTIVE, &dvalue);
fprintf(fp, "TRIGGER ACTIVE:\t%f\n", dvalue);
m_err =
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGER_GLOBALEXPOSURE, &dvalue);
fprintf(fp, "TRIGGER GLOBAL EXPOSURE:\t%f\n", dvalue);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGERPOLARITY, &dvalue);
fprintf(fp, "TRIGGER POLARITY:\t%f\n", dvalue);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGER_CONNECTOR, &dvalue);
fprintf(fp, "TRIGGER CONNECTOR:\t%f\n", dvalue);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGERTIMES, &dvalue);
fprintf(fp, "TRIGGER TIMES:\t%f\n", dvalue);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGERDELAY, &dvalue);
fprintf(fp, "TRIGGER DELAY:\t%f\n", dvalue);
m_err =
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_INTERNALTRIGGER_HANDLING, &dvalue);
fprintf(fp, "TRIGGER HANDLING:\t%f\n", dvalue);
// Sensor cooler
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SENSORCOOLERSTATUS, &dvalue);
fprintf(fp, "SENSOR COOLER STATUS:\t%f\n", dvalue);
// Binning and ROI
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_BINNING, &dvalue);
fprintf(fp, "BINNING:\t%f\n", dvalue);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHSIZE, &dvalue);
fprintf(fp, "SUBARRAY HSIZE:\t%f\n", dvalue);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVSIZE, &dvalue);
fprintf(fp, "SUBARRAY VSIZE:\t%f\n", dvalue);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHPOS, &dvalue);
fprintf(fp, "SUBARRAY HPOS:\t%f\n", dvalue);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVPOS, &dvalue);
fprintf(fp, "SUBARRAY MODE:\t%f\n", dvalue);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYMODE, &dvalue);
fprintf(fp, "SUBARRAY MODE:\t%f\n", dvalue);
// Feature
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_EXPOSURETIME, &dvalue);
fprintf(fp, "EXPOSURE TIME:\t%f\n", dvalue);
// ALU
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_DEFECTCORRECT_MODE, &dvalue);
fprintf(fp, "DEFECT CORRETION MODE:\t%f\n", dvalue);
m_err =
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_HOTPIXELCORRECT_LEVEL, &dvalue);
fprintf(fp, "HOT PIXEL CORRECTION LEVEL:\t%f\n", dvalue);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_INTENSITYLUT_MODE, &dvalue);
fprintf(fp, "INTENSITY LUT MODE:\t%f\n", dvalue);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_INTENSITYLUT_PAGE, &dvalue);
fprintf(fp, "INTENSITY LUT PAGE:\t%f\n", dvalue);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_EXTRACTION_MODE, &dvalue);
fprintf(fp, "EXTRACTION MODE:\t%f\n", dvalue);
// Output Trigger
m_err = dcamprop_getvalue(
m_hdcam, DCAM_IDPROP_NUMBEROF_OUTPUTTRIGGERCONNECTOR, &dvalue);
fprintf(fp, "OUTPUT TRIGGER CONNECTOR:\t%f\n", dvalue);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_ACTIVE, &dvalue);
fprintf(fp, "OUTPUT TRIGGER ACTIVE:\t%f\n", dvalue);
// - master pulse
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_MASTERPULSE_MODE, &dvalue);
fprintf(fp, "MASTER PULSE MODE:\t%f\n", dvalue);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_MASTERPULSE_TRIGGERSOURCE,
&dvalue);
fprintf(fp, "MASTER MODE TRIGGERSOURCE:\t%f\n", dvalue);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_MASTERPULSE_INTERVAL, &dvalue);
fprintf(fp, "MASTER MODE INTERVAL:\t%f\n", dvalue);
m_err =
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_MASTERPULSE_BURSTTIMES, &dvalue);
fprintf(fp, "MASTER MODE BURSTTIMES:\t%f\n", dvalue);
// - synchronous timing
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TIMING_READOUTTIME, &dvalue);
fprintf(fp, "TIMING READOUT TIME:\t%f\n", dvalue);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TIMING_CYCLICTRIGGERPERIOD,
&dvalue);
fprintf(fp, "TIMING CYCLIN TRIGGER PERIOD:\t%f\n", dvalue);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TIMING_MINTRIGGERBLANKING,
&dvalue);
fprintf(fp, "TIMING MIN TRIGGER BLANKING:\t%f\n", dvalue);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TIMING_MINTRIGGERINTERVAL,
&dvalue);
fprintf(fp, "TIMING MIN TRIGGER INTERVAL:\t%f\n", dvalue);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TIMING_GLOBALEXPOSUREDELAY,
&dvalue);
fprintf(fp, "TIMING GLOBAL EXPOSURE DELAY:\t%f\n", dvalue);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TIMING_EXPOSURE, &dvalue);
fprintf(fp, "TIMING EXPOSURE:\t%f\n", dvalue);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TIMING_INVALIDEXPOSUREPERIOD,
&dvalue);
fprintf(fp, "TIMING INVALID EXPOSURE PERIOD:\t%f\n", dvalue);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_INTERNALFRAMERATE, &dvalue);
fprintf(fp, "INTERNAL FRAME RATE:\t%f\n", dvalue);
m_err =
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_INTERNAL_FRAMEINTERVAL, &dvalue);
fprintf(fp, "INTERNAL FRAME INTERVAL:\t%f\n", dvalue);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_INTERNALLINESPEED, &dvalue);
fprintf(fp, "INTERNAL LINE SPEED:\t%f\n", dvalue);
m_err =
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_INTERNAL_LINEINTERVAL, &dvalue);
fprintf(fp, "INTERNAL LINE INTERVAL:\t%f\n", dvalue);
// - system information
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_COLORTYPE, &dvalue);
fprintf(fp, "COLOR TYPE:\t%f\n", dvalue);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_BITSPERCHANNEL, &dvalue);
fprintf(fp, "BITS PER CHANNEL:\t%f\n", dvalue);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_ROWBYTES, &dvalue);
fprintf(fp, "IMAGE ROW BYTES:\t%f\n", dvalue);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &dvalue);
fprintf(fp, "IMAGE FRAME BYTES:\t%f\n", dvalue);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_TOPOFFSETBYTES, &dvalue);
fprintf(fp, "IMAGE TOP OFFSET BYTES:\t%f\n", dvalue);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_PIXELTYPE, &dvalue);
fprintf(fp, "IMAGE PIXEL TYPE:\t%f\n", dvalue);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_BUFFER_ROWBYTES, &dvalue);
fprintf(fp, "BUFFER ROW BYTES:\t%f\n", dvalue);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_BUFFER_FRAMEBYTES, &dvalue);
fprintf(fp, "BUFER FRAME BYTES:\t%f\n", dvalue);
m_err =
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_BUFFER_TOPOFFSETBYTES, &dvalue);
fprintf(fp, "BUFFER TOP OFFSET BYTES:\t%f\n", dvalue);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_BUFFER_PIXELTYPE, &dvalue);
fprintf(fp, "BUFFER PIXEL TYPE:\t%f\n", dvalue);
m_err =
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_RECORDFIXEDBYTES_PERFILE, &dvalue);
fprintf(fp, "RECORD FIXED BYTES PER FILE:\t%f\n", dvalue);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_RECORDFIXEDBYTES_PERSESSION,
&dvalue);
fprintf(fp, "RECORD FIXED BYTES PER SESSION:\t%f\n", dvalue);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_RECORDFIXEDBYTES_PERFRAME,
&dvalue);
fprintf(fp, "RECORD FIXED BYTES PER FRAME:\t%f\n", dvalue);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SYSTEM_ALIVE, &dvalue);
fprintf(fp, "SYSTEM ALIVE:\t%f\n", dvalue);
m_err =
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_CONVERSIONFACTOR_COEFF, &dvalue);
fprintf(fp, "CONVERSION FACTOR COEFFICIENT:\t%f\n", dvalue);
m_err =
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_CONVERSIONFACTOR_OFFSET, &dvalue);
fprintf(fp, "CONVERSION FACTOR OFFSET:\t%f\n", dvalue);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_NUMBEROF_VIEW, &dvalue);
fprintf(fp, "NUMBER OF VIEW:\t%f\n", dvalue);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_WIDTH, &dvalue);
fprintf(fp, "IMAGE WIDTH:\t%f\n", dvalue);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_HEIGHT, &dvalue);
fprintf(fp, "IMAGE HEIGHT:\t%f\n", dvalue);
m_err = dcamprop_getvalue(m_hdcam, DETECTOR_PIXEL_NUM_HORZ, &dvalue);
fprintf(fp, "PIXEL NUM HORZ:\t%f\n", dvalue);
m_err = dcamprop_getvalue(m_hdcam, DETECTOR_PIXEL_NUM_VERT, &dvalue);
fprintf(fp, "PIXEL NUM VERT:\t%f\n", dvalue);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TIMESTAMP_PRODUCER, &dvalue);
fprintf(fp, "TIMESTAMP PRODUCER:\t%f\n", dvalue);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_FRAMESTAMP_PRODUCER, &dvalue);
fprintf(fp, "FRAMESTAMP PRODUCER:\t%f\n", dvalue);
ADDriver::report(fp, details);
}
//============================================================================
int Orca::connectCamera(void) {
static const char* functionName = "connectCamera";
int nDevices = 0;
int iDevice = 0;
/* disconnect any connected camera first */
disconnectCamera();
/* initialize api */
memset(&m_apiInit, 0, sizeof(m_apiInit));
m_apiInit.size = sizeof(m_apiInit);
m_err = dcamapi_init(&m_apiInit);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamapi_init()", NULL);
} else {
nDevices = m_apiInit.iDeviceCount;
FLOW_ARGS("dcamapi_init() found %d device(s)", nDevices);
iDevice = 0;
}
/* open handle to camera */
memset(&m_devOpen, 0, sizeof(m_devOpen));
m_devOpen.size = sizeof(m_devOpen);
m_devOpen.index = iDevice;
m_err = dcamdev_open(&m_devOpen);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamapi_init()");
} else {
m_hdcam = m_devOpen.hdcam;
printInfo(m_hdcam);
}
// open wait handle
DCAMWAIT_OPEN waitopen;
memset(&waitopen, 0, sizeof(waitopen));
waitopen.size = sizeof(waitopen);
waitopen.hdcam = m_hdcam;
m_err = dcamwait_open(&waitopen);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamwait_open()");
} else {
hwait = waitopen.hwait;
}
return 0;
}
//============================================================================
int Orca::disconnectCamera(void) {
int status = 0;
if (m_hdcam == NULL) {
return status;
}
dcamdev_close(m_hdcam);
m_hdcam = NULL;
return status;
}
//============================================================================
int Orca::allocateBuffers(unsigned int nBuffers) {
m_err = dcambuf_alloc(m_hdcam, nBuffers);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcambuf_alloc()");
return asynError;
}
return asynSuccess;
}
//============================================================================
int Orca::freeBuffers() {
m_err = dcambuf_release(m_hdcam);
if (failed(m_err)) printError(m_hdcam, m_err, "dcambuf_release()");
return 0;
}
//============================================================================
asynStatus Orca::stopAcquire(void) {
asynStatus status = asynSuccess;
m_err = dcamcap_stop(m_hdcam);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamcap_stop()");
status = asynError;
}
freeBuffers();
return status;
}
//============================================================================
asynStatus Orca::startAcquire(void) {
asynStatus status = asynSuccess;
// release buffer
freeBuffers();
// allocate buffer
allocateBuffers(1);
// start capture
m_err = dcamcap_start(m_hdcam, DCAMCAP_START_SEQUENCE);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamcap_start()");
status = asynError;
}
return status;
}
//============================================================================
inline void* memcpy_s(void* dst, size_t dstsize, const void* src,
size_t srclen) {
if (dstsize < srclen)
return memcpy(dst, src, dstsize);
else
return memcpy(dst, src, srclen);
}
//============================================================================
asynStatus Orca::accessCapturedImage(HDCAM hdcam, int32 iFrame, void* buf,
int32 rowbytes, int32 cx, int32 cy,
epicsUInt32& ts_sec,
epicsUInt32& ts_microsec) {
const char* functionName = "accessCapturedImage";
DCAMERR err;
// prepare frame param
DCAMBUF_FRAME bufframe;
memset(&bufframe, 0, sizeof(bufframe));
bufframe.size = sizeof(bufframe);
bufframe.iFrame = iFrame;
// access image
err = dcambuf_lockframe(hdcam, &bufframe);
if (failed(err)) {
printError(hdcam, err, "dcambuf_lockframe()");
return asynError;
}
if (bufframe.type != DCAM_PIXELTYPE_MONO16) {
FLOW("not implement pixel type");
return asynError;
}
// Get timestamp from the the frame
ts_sec = bufframe.timestamp.sec;
ts_microsec = bufframe.timestamp.microsec;
// copy target ROI
int32 copyrowbytes = cx * 2;
char* pSrc = (char*)bufframe.buf;
char* pDst = (char*)buf;
for (int y = 0; y < cy; y++) {
memcpy_s(pDst, rowbytes, pSrc, copyrowbytes);
pSrc += bufframe.rowbytes;
pDst += rowbytes;
}
return asynSuccess;
}
//========================================================================================================
void Orca::getImageInformation(HDCAM hdcam, int32& pixeltype, int32& width,
int32& rowbytes, int32& height,
int32& framebytes) {
DCAMERR err;
double property_value;
// image pixel type(DCAM_PIXELTYPE_MONO16, MONO8, ... )
err = dcamprop_getvalue(hdcam, DCAM_IDPROP_IMAGE_PIXELTYPE, &property_value);
if (failed(err)) {
printError(hdcam, err, "dcamprop_getvalue()", "IDPROP:IMAGE_PIXELTYPE");
return;
} else
pixeltype = (int32)property_value;
// image width
err = dcamprop_getvalue(hdcam, DCAM_IDPROP_IMAGE_WIDTH, &property_value);
if (failed(err)) {
printError(hdcam, err, "dcamprop_getvalue()", "IDPROP:IMAGE_WIDTH");
return;
} else
width = (int32)property_value;
// image row bytes
err = dcamprop_getvalue(hdcam, DCAM_IDPROP_IMAGE_ROWBYTES, &property_value);
if (failed(err)) {
printError(hdcam, err, "dcamprop_getvalue()", "IDPROP:IMAGE_ROWBYTES");
return;
} else
rowbytes = (int32)property_value;
// image height
err = dcamprop_getvalue(hdcam, DCAM_IDPROP_IMAGE_HEIGHT, &property_value);
if (failed(err)) {
printError(hdcam, err, "dcamprop_getvalue()", "IDPROP:IMAGE_HEIGHT");
return;
} else
height = (int32)property_value;
// image framebytes
err = dcamprop_getvalue(hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &property_value);
if (failed(err)) {
printError(hdcam, err, "dcamprop_getvalue()", "IDPROP:IMAGE_FRAMEBYTES");
return;
} else
framebytes = (int32)property_value;
}
//============================================================================
asynStatus Orca::imageTransferStatus(HDCAM hdcam,
DCAMCAP_TRANSFERINFO& captransferinfo) {
DCAMERR err;
// transferinfo param
memset(&captransferinfo, 0, sizeof(captransferinfo));
captransferinfo.size = sizeof(captransferinfo);
// get number of captured image
err = dcamcap_transferinfo(m_hdcam, &captransferinfo);
if (failed(err)) {
printError(m_hdcam, err, "dcamcap_transferinfo()");
return asynError;
}
if (captransferinfo.nFrameCount < 1) {
return asynError;
}
return asynSuccess;
}
//============================================================================
void Orca::printError(HDCAM hdcam, DCAMERR errid, const char* apiname,
const char* fmt, ...) {
char errtext[256];
DCAMERR err;
dcamdev_string(err, hdcam, errid, errtext, sizeof(errtext));
printf("-[ERROR]- -(DCAMERR)- -0x%08X- -%s- -%s-\n", errid, errtext, apiname);
if (fmt != NULL) {
printf(" : ");
va_list arg;
va_start(arg, fmt);
vprintf(fmt, arg);
va_end(arg);
}
}
//============================================================================
void Orca::printInfo(HDCAM hdcam) {
const char* functionName = "printInfo";
char model[256];
char cameraid[64];
char bus[64];
DCAMERR err;
if (!dcamdev_string(err, hdcam, DCAM_IDSTR_MODEL, model, sizeof(model))) {
printError(hdcam, err, "dcamdev_getstring(DCAM_IDSTR_MODEL)\n");
} else if (!dcamdev_string(err, hdcam, DCAM_IDSTR_CAMERAID, cameraid,
sizeof(cameraid))) {
printError(hdcam, err, "dcamdev_getstring(DCAM_IDSTR_CAMERAID)\n");
} else if (!dcamdev_string(err, hdcam, DCAM_IDSTR_BUS, bus, sizeof(bus))) {
printError(hdcam, err, "dcamdev_getstring(DCAM_IDSTR_BUS)\n");
} else {
FLOW_ARGS("%s (%s) on %s\n", model, cameraid, bus);
}
}
//============================================================================
int Orca::dcamdev_string(DCAMERR& err, HDCAM hdcam, int32 idStr, char* text,
int32 textbytes) {
DCAMDEV_STRING param;
memset(&param, 0, sizeof(param));
param.size = sizeof(param);
param.text = text;
param.textbytes = textbytes;
param.iString = idStr;
err = dcamdev_getstring(hdcam, &param);
return !failed(err);
}
//============================================================================
asynStatus Orca::setFeature(int featureIndex, double value) {
DCAMERR err;
err = dcamprop_setvalue(m_hdcam, featureIndex, value);
if (failed(err)) {
printError(m_hdcam, err, "dcamprop_setvalue()", "IDPROP:0x%08x, VALUE:%f\n",
featureIndex, value);
return asynError;
}
return asynSuccess;
}
int Orca::roundToNearestMultipleOfFour(int value) {
int remainder = value % 4;
if (remainder == 0)
return value;
else if (remainder <= 2)
return value - remainder;
else
return value + (4 - remainder);
}
/* Code for iocsh registration */
extern "C" int OrcaConfig(const char* portName, int maxBuffers,
size_t maxMemory, int priority, int stackSize,
int maxFrames) {
new Orca(portName, maxBuffers, maxMemory, priority, stackSize, maxFrames);
return (asynSuccess);
}
//============================================================================
static const iocshArg OrcaConfigArg0 = {"Port name", iocshArgString};
static const iocshArg OrcaConfigArg1 = {"maxBuffers", iocshArgInt};
static const iocshArg OrcaConfigArg2 = {"maxMemory", iocshArgInt};
static const iocshArg OrcaConfigArg3 = {"priority", iocshArgInt};
static const iocshArg OrcaConfigArg4 = {"stackSize", iocshArgInt};
static const iocshArg OrcaConfigArg5 = {"maxFrames", iocshArgInt};
static const iocshArg* const OrcaConfigArgs[] = {
&OrcaConfigArg0, &OrcaConfigArg1, &OrcaConfigArg2,
&OrcaConfigArg3, &OrcaConfigArg4, &OrcaConfigArg5};
static const iocshFuncDef configorca = {"devOrcaConfig", 6, OrcaConfigArgs};
static void configorcaCallFunc(const iocshArgBuf* args) {
OrcaConfig(args[0].sval, args[1].ival, args[2].ival, args[3].ival,
args[4].ival, args[5].ival);
}
static void orcaRegister(void) {
iocshRegister(&configorca, configorcaCallFunc);
}
extern "C" {
epicsExportRegistrar(orcaRegister);
}
Reference in New Issue View Git Blame Copy Permalink