#include "orca.h" #include #include "dcamprop.h" using namespace std; static const char* driverName = "drvOrca"; // Error message formatters #define ERR(msg) \ asynPrint(pasynUserSelf, ASYN_TRACE_ERROR, "%s::%s: %s\n", driverName, \ functionName, msg) #define ERR_ARGS(fmt, ...) \ asynPrint(pasynUserSelf, ASYN_TRACE_ERROR, "%s::%s: " fmt "\n", driverName, \ functionName, __VA_ARGS__); // 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(¶m, 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, ¶m); status = setStringParam(hVendor, text); FLOW_ARGS("Vendor %s\n", text); break; case DCAM_IDSTR_MODEL: dcamdev_getstring(m_hdcam, ¶m); status = setStringParam(hModel, text); FLOW_ARGS("Model %s\n", text); break; case DCAM_IDSTR_CAMERAID: dcamdev_getstring(m_hdcam, ¶m); status = setStringParam(hCameraID, text); FLOW_ARGS("CameraID %s\n", text); break; case DCAM_IDSTR_BUS: dcamdev_getstring(m_hdcam, ¶m); status = setStringParam(hBus, text); FLOW_ARGS("Bus %s\n", text); break; case DCAM_IDSTR_CAMERAVERSION: dcamdev_getstring(m_hdcam, ¶m); status = setStringParam(hCameraVersion, text); FLOW_ARGS("CameraVersion %s\n", text); break; case DCAM_IDSTR_DRIVERVERSION: dcamdev_getstring(m_hdcam, ¶m); status = setStringParam(hDriverVersion, text); FLOW_ARGS("DriverVersion %s\n", text); break; case DCAM_IDSTR_MODULEVERSION: dcamdev_getstring(m_hdcam, ¶m); status = setStringParam(hModuleVersion, text); FLOW_ARGS("ModuleVersion %s\n", text); break; case DCAM_IDSTR_DCAMAPIVERSION: dcamdev_getstring(m_hdcam, ¶m); 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(¤tAcqTime); elapsedTime = epicsTimeDiffInSeconds(¤tAcqTime, &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(¤tAcqTime); if ((epicsTimeDiffInSeconds(¤tAcqTime, &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(¤t_trigger_time); if (epicsTimeDiffInSeconds(¤t_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, ¶mName); /* 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, ¶mName); //-- 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; /* 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::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(¶m, 0, sizeof(param)); param.size = sizeof(param); param.text = text; param.textbytes = textbytes; param.iString = idStr; err = dcamdev_getstring(hdcam, ¶m); 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); }