1997 lines
76 KiB
C++
1997 lines
76 KiB
C++
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <wchar.h>
|
|
#include <stdarg.h>
|
|
|
|
#include <epicsEvent.h>
|
|
#include <epicsTime.h>
|
|
#include <epicsThread.h>
|
|
#include <iocsh.h>
|
|
#include <epicsString.h>
|
|
#include <epicsExit.h>
|
|
#include <epicsExport.h>
|
|
|
|
#include "hama.h"
|
|
// --- includes from DCMAPI ----
|
|
#include "dcamprop.h"
|
|
//
|
|
#include <unistd.h>
|
|
|
|
|
|
#define NUM_HAMA_PARAMS ((int)(&LAST_HAMA_PARAM - &FIRST_HAMA_PARAM + 1))
|
|
|
|
static const char *driverName="drvHama";
|
|
|
|
static void c_imagetask(void *arg) {
|
|
Hama *p = (Hama *)arg;
|
|
p->imageTask();
|
|
}
|
|
|
|
static void c_temperaturetask(void *arg) {
|
|
Hama *p = (Hama *)arg;
|
|
p->temperatureTask();
|
|
}
|
|
|
|
|
|
//============================================================================
|
|
Hama::Hama(const char* portName, int cameraId, int maxBuffers, size_t maxMemory,
|
|
int priority, int stackSize, int maxFrames)
|
|
: ADDriver(portName, 1, NUM_HAMA_PARAMS, maxBuffers, maxMemory,
|
|
asynEnumMask, asynEnumMask,
|
|
ASYN_CANBLOCK, /* ASYN_CANBLOCK=1 ASYN_MULTIDEVICE=0 */
|
|
1, /* autoConnect=1 */
|
|
priority, stackSize),
|
|
m_hdcam(NULL), m_id(0)
|
|
|
|
{
|
|
const char *functionName = "hamaDetector::hamaDetector";
|
|
|
|
printf("[DEBUG] === Constructor ADHama ===\n");
|
|
printf("[DEBUG] driverName: %s\n", driverName);
|
|
|
|
stopThread = 0;
|
|
|
|
/* Create the epicsEvents for signaling to task when acquisition starts and stops */
|
|
startEvent_ = epicsEventCreate(epicsEventEmpty);
|
|
if (!startEvent_) {
|
|
printf("%s:%s epicsEventCreate failure for acquire start event\n",
|
|
driverName, functionName);
|
|
return;
|
|
}
|
|
|
|
//General
|
|
|
|
createParam( HamaName, asynParamOctet, &hHamaName);
|
|
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( hTriggerModeString, asynParamInt32, &hTriggerMode);
|
|
createParam( hTriggerSourceString, asynParamInt32, &hTriggerSource);
|
|
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);
|
|
|
|
//Feature
|
|
createParam( hExposureTimeString, asynParamFloat64, &hExposureTime);
|
|
|
|
//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( hImageWidthString, asynParamInt32, &hImageWidth);
|
|
createParam( hImageHeightString, asynParamInt32, &hImageHeight);
|
|
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);
|
|
|
|
|
|
setIntegerParam(NDArrayCallbacks, 1);
|
|
callParamCallbacks();
|
|
|
|
connectCamera();
|
|
initCamera();
|
|
|
|
/* launch image read task */
|
|
epicsThreadCreate("HamaImageTask",
|
|
epicsThreadPriorityMedium,
|
|
epicsThreadGetStackSize(epicsThreadStackMedium),
|
|
c_imagetask, this);
|
|
|
|
/* launch temp read task */
|
|
epicsThreadCreate("HamaTemperatureTask",
|
|
epicsThreadPriorityMedium,
|
|
epicsThreadGetStackSize(epicsThreadStackMedium),
|
|
c_temperaturetask, this);
|
|
|
|
/* shutdown on exit */
|
|
//epicsAtExit(c_shutdown, this);
|
|
|
|
printf("[DEBUG] === END Constructor ADHama ===\n");
|
|
}
|
|
//============================================================================
|
|
//Hama::~Hama(){
|
|
// // not sure if the destructor has to be define here...
|
|
// printf("[DEBUG] === Destructor ADHama ===\n");
|
|
//}
|
|
|
|
//========================================================================================================
|
|
int Hama::initCamera(){
|
|
|
|
int err = 0;
|
|
|
|
err |= getParameterStr(DCAM_IDSTR_VENDOR);
|
|
err |= getParameterStr(DCAM_IDSTR_MODEL);
|
|
err |= getParameterStr(DCAM_IDSTR_CAMERAID);
|
|
err |= getParameterStr(DCAM_IDSTR_BUS);
|
|
err |= getParameterStr(DCAM_IDSTR_CAMERAVERSION);
|
|
err |= getParameterStr(DCAM_IDSTR_DRIVERVERSION);
|
|
err |= getParameterStr(DCAM_IDSTR_MODULEVERSION);
|
|
err |= getParameterStr(DCAM_IDSTR_DCAMAPIVERSION);
|
|
|
|
err |= getParameter(DETECTOR_PIXEL_NUM_HORZ);
|
|
err |= getParameter(DETECTOR_PIXEL_NUM_VERT);
|
|
|
|
err |= getParameter( DCAM_IDPROP_IMAGE_PIXELTYPE);
|
|
err |= getParameter( DCAM_IDPROP_IMAGE_WIDTH);
|
|
err |= getParameter( DCAM_IDPROP_IMAGE_ROWBYTES);
|
|
err |= getParameter( DCAM_IDPROP_IMAGE_HEIGHT);
|
|
err |= getParameter( DCAM_IDPROP_BINNING);
|
|
err |= getParameter( DCAM_IDPROP_IMAGE_FRAMEBYTES);
|
|
err |= getParameter( DCAM_IDPROP_SUBARRAYHPOS);
|
|
err |= getParameter( DCAM_IDPROP_SUBARRAYVPOS);
|
|
err |= getParameter( DCAM_IDPROP_SUBARRAYHSIZE);
|
|
err |= getParameter( DCAM_IDPROP_SUBARRAYVSIZE);
|
|
|
|
|
|
err |= getParameter(DCAM_IDPROP_SENSORMODE);
|
|
err |= getParameter(DCAM_IDPROP_READOUTSPEED);
|
|
err |= getParameter(DCAM_IDPROP_READOUT_DIRECTION);
|
|
err |= getParameter(DCAM_IDPROP_TRIGGERSOURCE);
|
|
err |= getParameter(DCAM_IDPROP_TRIGGER_MODE);
|
|
err |= getParameter(DCAM_IDPROP_TRIGGERACTIVE);
|
|
err |= getParameter(DCAM_IDPROP_TRIGGER_GLOBALEXPOSURE);
|
|
err |= getParameter(DCAM_IDPROP_OUTPUTTRIGGER_POLARITY);
|
|
err |= getParameter(DCAM_IDPROP_TRIGGER_CONNECTOR);
|
|
err |= getParameter(DCAM_IDPROP_TRIGGERTIMES);
|
|
err |= getParameter(DCAM_IDPROP_TRIGGERDELAY);
|
|
err |= getParameter(DCAM_IDPROP_INTERNALTRIGGER_HANDLING);
|
|
|
|
err |= getParameter(DCAM_IDPROP_TIMESTAMP_PRODUCER);
|
|
|
|
if(err){
|
|
// asynPrint(pasynUser, ASYN_TRACEIO_DRIVER, "%s:%s: port=%s, value=%d, status=%d\n",
|
|
// driverName, functionName, this->portName, value, (int)status);
|
|
}
|
|
return err;
|
|
}
|
|
|
|
//============================================================================
|
|
int Hama::getParameterStr(int propertyID){
|
|
|
|
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);
|
|
printf("[DEBUG]::VENDOR %s\n", text);
|
|
break;
|
|
case DCAM_IDSTR_MODEL:
|
|
dcamdev_getstring(m_hdcam, ¶m);
|
|
status = setStringParam(hModel, text);
|
|
printf("[DEBUG]::MODEL %s\n", text);
|
|
break;
|
|
case DCAM_IDSTR_CAMERAID:
|
|
dcamdev_getstring(m_hdcam, ¶m);
|
|
status = setStringParam(hCameraID, text);
|
|
printf("[DEBUG]::CAMERAID %s\n", text);
|
|
break;
|
|
case DCAM_IDSTR_BUS:
|
|
dcamdev_getstring(m_hdcam, ¶m);
|
|
status = setStringParam(hBus, text);
|
|
printf("[DEBUG]::BUS %s\n", text);
|
|
break;
|
|
case DCAM_IDSTR_CAMERAVERSION:
|
|
dcamdev_getstring(m_hdcam, ¶m);
|
|
status = setStringParam(hCameraVersion, text);
|
|
printf("[DEBUG]::CAMERAVERSION %s\n", text);
|
|
break;
|
|
case DCAM_IDSTR_DRIVERVERSION:
|
|
dcamdev_getstring(m_hdcam, ¶m);
|
|
status = setStringParam(hDriverVersion, text);
|
|
printf("[DEBUG]::DRIVERVERSION %s\n", text);
|
|
break;
|
|
case DCAM_IDSTR_MODULEVERSION:
|
|
dcamdev_getstring(m_hdcam, ¶m);
|
|
status = setStringParam(hModuleVersion, text);
|
|
printf("[DEBUG]::MODULEVERSION %s\n", text);
|
|
break;
|
|
case DCAM_IDSTR_DCAMAPIVERSION:
|
|
dcamdev_getstring(m_hdcam, ¶m);
|
|
status = setStringParam(hDcamApiVersion, text);
|
|
printf("[DEBUG]::DCAMPVERSION %s\n", text);
|
|
break;
|
|
default:
|
|
printf("[DEBUG]::NOT SUPPORTED\n");
|
|
break;
|
|
|
|
}
|
|
// asynPrint(pasynUser, ASYN_TRACEIO_DRIVER, "%s:%s: port=%s, value=%d, status=%d\n",
|
|
// driverName, functionName, this->portName, value, (int)status);
|
|
return int(status);
|
|
}
|
|
//============================================================================
|
|
int Hama::getParameter(int propertyID){
|
|
printf("\n[DEBUG] *** Function:getProperty\n");
|
|
|
|
|
|
asynStatus status = asynSuccess;
|
|
|
|
double value_d = 0;
|
|
/*
|
|
dcamprop_getvalue(m_hdcam, propertyID, &value);
|
|
setIntegerParameter(ADMaxSizeX, value);
|
|
printf("PropertyID = %f\n", value);
|
|
*/
|
|
|
|
|
|
switch (propertyID){
|
|
case DETECTOR_PIXEL_NUM_HORZ:
|
|
dcamprop_getvalue(m_hdcam, DETECTOR_PIXEL_NUM_HORZ, &value_d);
|
|
status = setIntegerParam(ADMaxSizeX, value_d);
|
|
printf("SENSOR SIZE_X = %f\n", value_d);
|
|
break;
|
|
|
|
case DETECTOR_PIXEL_NUM_VERT:
|
|
dcamprop_getvalue(m_hdcam, DETECTOR_PIXEL_NUM_VERT, &value_d);
|
|
status = setIntegerParam(ADMaxSizeY, value_d);
|
|
printf("SENSOR SIZE_Y = %f\n", value_d);
|
|
break;
|
|
|
|
case DCAM_IDPROP_IMAGE_PIXELTYPE:
|
|
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_PIXELTYPE, &value_d);
|
|
status = setIntegerParam(hImagePixelType, value_d);
|
|
printf("The PIXELTYPE = %f\n", value_d);
|
|
break;
|
|
|
|
case DCAM_IDPROP_IMAGE_WIDTH:
|
|
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_WIDTH, &value_d);
|
|
status = setIntegerParam(hImageWidth, value_d);
|
|
printf("The IMAGE_WIDTH = %f\n", value_d);
|
|
break;
|
|
|
|
case DCAM_IDPROP_IMAGE_HEIGHT:
|
|
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_HEIGHT, &value_d);
|
|
status = setIntegerParam(hImageHeight, value_d);
|
|
printf("The IMAGE_HEIGHT = %f\n", value_d);
|
|
break;
|
|
|
|
case DCAM_IDPROP_IMAGE_ROWBYTES:
|
|
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_ROWBYTES, &value_d);
|
|
status = setIntegerParam(hImageRowbytes, value_d);
|
|
printf("The IMAGE_ROWBYTES = %f\n", value_d);
|
|
break;
|
|
|
|
case DCAM_IDPROP_IMAGE_FRAMEBYTES:
|
|
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &value_d);
|
|
status = setIntegerParam(hImageFramebytes, value_d);
|
|
printf("The IMAGE FRAMEBYTES = %f\n", value_d);
|
|
break;
|
|
|
|
case DCAM_IDPROP_SUBARRAYHSIZE:
|
|
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHSIZE, &value_d);
|
|
status = setIntegerParam(ADSizeX, value_d);
|
|
printf("The SENSOR HSIZE = %f\n", value_d);
|
|
break;
|
|
|
|
case DCAM_IDPROP_SUBARRAYVSIZE:
|
|
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVSIZE, &value_d);
|
|
status = setIntegerParam(ADSizeY, value_d);
|
|
printf("The SENSOR VSIZE = %f\n", value_d);
|
|
break;
|
|
|
|
case DCAM_IDPROP_SUBARRAYHPOS:
|
|
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHPOS, &value_d);
|
|
status = setIntegerParam(ADMinX, value_d);
|
|
printf("The SENSOR HPOS = %f\n", value_d);
|
|
break;
|
|
|
|
case DCAM_IDPROP_SUBARRAYVPOS:
|
|
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVPOS, &value_d);
|
|
status = setIntegerParam(ADMinY, value_d);
|
|
printf("The SENSOR VPOS = %f\n", value_d);
|
|
break;
|
|
|
|
case DCAM_IDPROP_SENSORMODE:
|
|
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SENSORMODE, &value_d);
|
|
status = setIntegerParam(hSensorMode, value_d);
|
|
//printf("The SENSOR MODE = %f\n", value_d);
|
|
break;
|
|
|
|
case DCAM_IDPROP_READOUTSPEED:
|
|
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_READOUTSPEED, &value_d);
|
|
status = setIntegerParam(hReadoutSpeed, value_d);
|
|
//printf("The READOUT SPEED = %f\n", value_d);
|
|
break;
|
|
|
|
case DCAM_IDPROP_READOUT_DIRECTION:
|
|
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_READOUT_DIRECTION, &value_d);
|
|
status = setIntegerParam(hReadoutDirection, value_d);
|
|
//printf("The READOUT DIRECTION = %f\n", value_d);
|
|
break;
|
|
|
|
case DCAM_IDPROP_TRIGGERSOURCE:
|
|
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGERSOURCE, &value_d);
|
|
status = setIntegerParam(hTriggerSource, value_d);
|
|
//printf("The = TRIGGER SOURCE = %f\n", value_d);
|
|
break;
|
|
|
|
case DCAM_IDPROP_TRIGGER_MODE:
|
|
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGER_MODE, &value_d);
|
|
status = setIntegerParam(hTriggerMode, value_d);
|
|
//printf("The TRIGGER MODE = %f\n", value_d);
|
|
break;
|
|
|
|
case DCAM_IDPROP_TRIGGERACTIVE:
|
|
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGERACTIVE, &value_d);
|
|
status = setIntegerParam(hTriggerActive, value_d);
|
|
//printf("The TRIGGER ACTIVE = %f\n", value_d);
|
|
break;
|
|
|
|
case DCAM_IDPROP_TRIGGER_GLOBALEXPOSURE:
|
|
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGER_GLOBALEXPOSURE, &value_d);
|
|
status = setIntegerParam(hTriggerGlobalExposure, value_d);
|
|
//printf("The TRIGGER GLOBAL EXPOSURE = %f\n", value_d);
|
|
break;
|
|
|
|
case DCAM_IDPROP_TRIGGERPOLARITY:
|
|
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGERPOLARITY, &value_d);
|
|
status = setIntegerParam(hTriggerPolarity, value_d);
|
|
//printf("The TRIGGER POLARITY = %f\n", value_d);
|
|
break;
|
|
|
|
case DCAM_IDPROP_TRIGGER_CONNECTOR:
|
|
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGER_CONNECTOR, &value_d);
|
|
status = setIntegerParam(hTriggerConnector, value_d);
|
|
//printf("The TRIGGER CONNECTOR = %f\n", value_d);
|
|
break;
|
|
|
|
case DCAM_IDPROP_TRIGGERTIMES:
|
|
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGERTIMES, &value_d);
|
|
status = setIntegerParam(hTriggerTimes, value_d);
|
|
//printf("The TRIGGER TIMES = %f\n", value_d);
|
|
break;
|
|
|
|
case DCAM_IDPROP_TRIGGERDELAY:
|
|
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGERDELAY, &value_d);
|
|
status = setDoubleParam(hTriggerDelay, value_d);
|
|
//printf("The TRIGGER DELAY = %f\n", value_d);
|
|
break;
|
|
|
|
case DCAM_IDPROP_INTERNALTRIGGER_HANDLING:
|
|
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_INTERNALTRIGGER_HANDLING, &value_d);
|
|
status = setIntegerParam(hInternalTriggerHandling, value_d);
|
|
//printf("The INTERNAL TRIGGE HANDLING = %f\n", value_d);
|
|
break;
|
|
|
|
case DCAM_IDPROP_TIMESTAMP_PRODUCER:
|
|
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TIMESTAMP_PRODUCER, &value_d);
|
|
status = setIntegerParam(hTimeStampProducer, value_d);
|
|
break;
|
|
|
|
default:
|
|
printf("The init parameter not recognised.... = %d\n", propertyID);
|
|
break;
|
|
}
|
|
|
|
/* Do callbacks so higher layers see any changes */
|
|
status = (asynStatus) callParamCallbacks();
|
|
return int(status);
|
|
}
|
|
|
|
//============================================================================
|
|
int Hama::setParameter(int paramIndex){
|
|
/*
|
|
setIntegerParam(ADBinY, 2048);
|
|
setIntegerParam(ADBinX, 2048);
|
|
setIntegerParam(NDNDimensions, 1);
|
|
setIntegerParam(NDArrayCounter, 1);
|
|
setIntegerParam(NDDataType, NDUInt16);
|
|
setIntegerParam(NDColorMode, NDColorModeMono);
|
|
setIntegerParam(NDArraySizeZ, 0);
|
|
setIntegerParam(NDArraySize, 5000000);
|
|
setStringParam(ADStringToServer, "<not used by driver>");
|
|
setStringParam(ADStringFromServer, "<not used by driver>");
|
|
setStringParam(ADManufacturer, "Hamamatsu");
|
|
*/
|
|
|
|
|
|
return 0;
|
|
}
|
|
|
|
//============================================================================
|
|
int Hama::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 Hama::getProperties(){
|
|
printf("\n[DEBUG] Function:getProperties\n");
|
|
|
|
int32 iProp = 0; // property IDs
|
|
|
|
double value = 50;
|
|
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SENSORTEMPERATURE, &value);
|
|
printf("The SENSOR TEMPERATURE = %f\n", value);
|
|
|
|
DCAMERR err;
|
|
err = dcamprop_getnextid( m_hdcam, &iProp, DCAMPROP_OPTION_SUPPORT );
|
|
if( failed(err) ) {
|
|
printError( m_hdcam, err, "dcamprop_getnextid()", "IDPROP:0x%08x, OPTION:SUPPORT", 0 );
|
|
return err;
|
|
}
|
|
|
|
do{
|
|
// get property name
|
|
char text[ 64 ];
|
|
err = dcamprop_getname( m_hdcam, iProp, text, sizeof(text) );
|
|
if( failed(err) ) {
|
|
printError( m_hdcam, err, "dcamprop_getname()", "IDPROP:0x%08x", iProp );
|
|
return err;
|
|
}
|
|
|
|
printf( "0x%08x: %s\n", iProp, text );
|
|
|
|
// get property attribute
|
|
DCAMPROP_ATTR basepropattr;
|
|
memset( &basepropattr, 0, sizeof(basepropattr) );
|
|
basepropattr.cbSize = sizeof(basepropattr);
|
|
basepropattr.iProp = iProp;
|
|
|
|
err = dcamprop_getattr( m_hdcam, &basepropattr );
|
|
if( !failed(err) ) {
|
|
|
|
#if SHOW_PROPERTY_ATTRIBUTE
|
|
// show property attribute
|
|
//dcamcon_show_propertyattr( basepropattr );
|
|
#endif
|
|
|
|
#if SHOW_PROPERTY_MODEVALUELIST
|
|
// show mode value list of property
|
|
//if( (basepropattr.attribute & DCAMPROP_TYPE_MASK) == DCAMPROP_TYPE_MODE )
|
|
// dcamcon_show_supportmodevalues( m_hdcam, iProp, basepropattr.valuemin );
|
|
#endif
|
|
|
|
#if SHOW_PROPERTY_ARRAYELEMENT
|
|
// show array element
|
|
//if( basepropattr.attribute2 & DCAMPROP_ATTR2_ARRAYBASE )
|
|
// dcamcon_show_arrayelement( m_hdcam, basepropattr );
|
|
#endif
|
|
}
|
|
|
|
// get next property id
|
|
err = dcamprop_getnextid( m_hdcam, &iProp, DCAMPROP_OPTION_SUPPORT );
|
|
if( failed(err) ) {
|
|
// no more supported property id
|
|
return err;
|
|
}
|
|
|
|
} while( iProp != 0 );
|
|
|
|
return 0;
|
|
}
|
|
//============================================================================
|
|
void Hama::imageTask(){
|
|
int status;
|
|
unsigned char *image;
|
|
int acquire;
|
|
int count = 0;
|
|
int callback;
|
|
//int acquireStatusError = 0;
|
|
int imageMode=0;
|
|
int totalImages=0;
|
|
uint64_t prevAcquisitionCount = 0;
|
|
DCAMCAP_TRANSFERINFO captransferinfo;
|
|
|
|
//static const char *functionName = "imageTask";
|
|
|
|
lock();
|
|
|
|
while(1) {
|
|
getIntegerParam(ADAcquire, &acquire);
|
|
if(!acquire) {
|
|
puts("Waiting start");
|
|
|
|
unlock();
|
|
status = epicsEventWait(startEvent_);
|
|
puts("Starting request received");
|
|
lock();
|
|
|
|
/* We are acquiring. */
|
|
//acquireStatusError = 0;
|
|
setIntegerParam(ADStatus, ADStatusAcquire);
|
|
|
|
status = startAcquire();
|
|
printf("Status: %d\n", status);
|
|
if (status != asynSuccess) {
|
|
//acquireStatusError = 1;
|
|
epicsThreadSleep(.1);
|
|
}
|
|
else {
|
|
acquire = 1;
|
|
/* Get the current time */
|
|
prevAcquisitionCount = 0;
|
|
}
|
|
}
|
|
|
|
/* Added this delay for the thread not to hog the processor. No need to run on full speed. */
|
|
//epicsThreadSleep(0.001);
|
|
|
|
// get image transfer status.
|
|
unlock();
|
|
imageTransferStatus(m_hdcam, captransferinfo);
|
|
lock();
|
|
|
|
if (prevAcquisitionCount < (uint64_t)captransferinfo.nFrameCount) {
|
|
//printf("nFrameCount: %d, nNewestFrameIndex: %d\n", captransferinfo.nFrameCount, captransferinfo.nNewestFrameIndex);
|
|
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 ) {
|
|
printf( "not implement\n" );
|
|
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);
|
|
|
|
count++;
|
|
setIntegerParam(NDArrayCounter, count);
|
|
|
|
int32 ts_sec = 0, ts_microsec = 0;
|
|
accessCapturedImage(m_hdcam, captransferinfo.nNewestFrameIndex, image,
|
|
width * 2, width, height, ts_sec, ts_microsec);
|
|
|
|
// printf("Timestamp from camera: %d\n", ts_sec + ts_microsec);
|
|
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 = ts_sec + (ts_microsec / 1.0e6);
|
|
updateTimeStamp(&pImage->epicsTS);
|
|
|
|
memcpy(pImage->pData, (epicsUInt16 *)image, pImage->dataSize);
|
|
|
|
getAttributes(pImage->pAttributeList);
|
|
doCallbacksGenericPointer(pImage, NDArrayData, 0);
|
|
pImage->release();
|
|
}
|
|
}
|
|
|
|
delete[] image;
|
|
}
|
|
|
|
getIntegerParam(ADNumImages, &totalImages);
|
|
getIntegerParam(ADImageMode, &imageMode);
|
|
|
|
if ((imageMode == ADImageMultiple && totalImages == captransferinfo.nFrameCount) ||
|
|
(imageMode == ADImageSingle && captransferinfo.nFrameCount == 1)) {
|
|
setShutter(0);
|
|
stopAcquire();
|
|
setIntegerParam(ADAcquire, 0);
|
|
}
|
|
|
|
callParamCallbacks();
|
|
}
|
|
}
|
|
//============================================================================
|
|
void Hama::temperatureTask(){
|
|
static const char *functionName = "tempTask";
|
|
// asynStatus status = asynSuccess;
|
|
double value = 0;
|
|
|
|
while( !stopThread ) {
|
|
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SENSORTEMPERATURE, &value);
|
|
|
|
if(m_err != DCAMERR_SUCCESS){
|
|
asynPrint(pasynUserSelf, ASYN_TRACE_ERROR,
|
|
"%s:%s: temperature read error = %d\n",
|
|
driverName, functionName, m_err);
|
|
}
|
|
else{
|
|
setDoubleParam(hSensorTemperature, value);
|
|
//printf("Temperature = %f\n",value);
|
|
}
|
|
|
|
callParamCallbacks();
|
|
epicsThreadSleep(1.0);
|
|
|
|
}
|
|
|
|
}
|
|
//============================================================================
|
|
|
|
asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value){
|
|
|
|
|
|
printf("[DEBUG]::writeInt32\t");
|
|
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);
|
|
double value_d = 0;
|
|
|
|
getParamName(index, ¶mName);
|
|
|
|
/* Ensure that ADStatus is set correctly before we set ADAcquire.*/
|
|
getIntegerParam(ADStatus, &adstatus);
|
|
|
|
status = setIntegerParam(index, value);
|
|
|
|
if (index == ADAcquire) {
|
|
printf("[DEBUG]::function ADAcquire\n");
|
|
if (value) {
|
|
/* Send an event to wake up the acq task.*/
|
|
puts("Requested acquire start event. Sending acquire start event signal to thread");
|
|
epicsEventSignal(this->startEvent_);
|
|
}
|
|
else if (!value && (adstatus == ADStatusAcquire || adstatus == ADStatusError)) {
|
|
/* This was a command to stop acquisition */
|
|
setShutter(0);
|
|
stopAcquire();
|
|
}
|
|
}
|
|
/*
|
|
else if (index == ADMaxSizeX_RBV) {
|
|
dcamprop_setvalue(m_hdcam, DETECTOR_PIXEL_NUM_HORZ, value);
|
|
dcamprop_getvalue(m_hdcam, DETECTOR_PIXEL_NUM_HORZ, &value_d);
|
|
printf("[DEBUG]::function ADNumExposures\n");
|
|
}
|
|
else if (index == ADMaxSizeY_RBV) {
|
|
dcamprop_setvalue(m_hdcam, DETECTOR_PIXEL_NUM_VERT, value);
|
|
dcamprop_getvalue(m_hdcam, DETECTOR_PIXEL_NUM_VERT, &value_d);
|
|
printf("[DEBUG]::function ADMinX\n");
|
|
}
|
|
*/
|
|
else if (index == ADImageMode) {
|
|
// dcamprop_setvalue(m_hdcam, DCAM_IDPROP_, value);
|
|
// dcamprop_getvalue(m_hdcam, DCAM_IDPROP_, &value_d);
|
|
printf("[DEBUG]::function ADImageMode\n");
|
|
}
|
|
else if (index == ADNumExposures) {
|
|
//camprop_setvalue(m_hdcam, DCAM_IDPROP_EXPOSURETIME, value);
|
|
//dcamprop_getvalue(m_hdcam, DCAM_IDPROP_EXPOSURETIME, &value_d);
|
|
printf("[DEBUG]::function ADNumExposures\n");
|
|
}
|
|
else if (index == ADMinX) {
|
|
updateSensorSize();
|
|
printf("[DEBUG]::function ADMinX\n");
|
|
}
|
|
else if (index == ADMinY) {
|
|
updateSensorSize();
|
|
printf("[DEBUG]::function ADMinY\n");
|
|
}
|
|
else if (index == ADSizeX) {
|
|
updateSensorSize();
|
|
printf("[DEBUG]::function ADSizeX\n");
|
|
}
|
|
else if (index == ADSizeY) {
|
|
updateSensorSize();
|
|
printf("[DEBUG]::function ADSizeY\n");
|
|
}
|
|
else if (index == ADReadStatus) {
|
|
// dcamprop_setvalue(m_hdcam, DCAM_IDPROP_, value);
|
|
// dcamprop_getvalue(m_hdcam, DCAM_IDPROP_, &value_d);
|
|
printf("[DEBUG]::function ADReadStatus\n");
|
|
}
|
|
else if (index == hSensorMode) {
|
|
printf("[DEBUG]::function SensorMode %d\n", value);
|
|
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SENSORMODE, &dvalue);
|
|
if(failed(m_err)) {
|
|
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
|
|
}
|
|
}
|
|
else if (index == hReadoutSpeed) {
|
|
printf("[DEBUG]::function ReadoutSpeed %d\n", value);
|
|
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_READOUTSPEED, &dvalue);
|
|
if(failed(m_err)) {
|
|
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
|
|
}
|
|
|
|
}
|
|
else if (index == hReadoutDirection) {
|
|
printf("[DEBUG]::function ReadoutDirection %d\n", value);
|
|
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);
|
|
}
|
|
}
|
|
else if (index == hColorType) {
|
|
printf("[DEBUG]::function ColorType %d\n", value);
|
|
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_COLORTYPE, &dvalue);
|
|
if(failed(m_err)) {
|
|
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
|
|
}
|
|
}
|
|
else if (index == hBitPerChannel) {
|
|
printf("[DEBUG]::function BitPerChannel %d\n", value);
|
|
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 == hTriggerSource) {
|
|
printf("[DEBUG]::function TriggerSource %d\n", value);
|
|
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) {
|
|
printf("[DEBUG]::function TriggerMode %d\n", value);
|
|
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) {
|
|
printf("[DEBUG]::function TriggerActive %d\n", value);
|
|
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) {
|
|
printf("[DEBUG]::function TriggerGlobalExposure %d\n", value);
|
|
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) {
|
|
printf("[DEBUG]::function TriggerPolarity %d\n", value);
|
|
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) {
|
|
printf("[DEBUG]::function TriggerConnector %d\n", value);
|
|
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) {
|
|
printf("[DEBUG]::function TriggerTimes %d\n", value);
|
|
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) {
|
|
printf("[DEBUG]::function TriggerHandling %d\n", value);
|
|
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);
|
|
}
|
|
}
|
|
else if (index == hSensorCoolerStatus) {
|
|
printf("[DEBUG]::function SensorCoolerStatus %d\n", value);
|
|
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SENSORCOOLERSTATUS, &dvalue);
|
|
if(failed(m_err)) {
|
|
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
|
|
}
|
|
}
|
|
else if (index == hDefectCorrectMode) {
|
|
printf("[DEBUG]::function DefectCorrerMode %d\n", value);
|
|
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) {
|
|
printf("[DEBUG]::function HotPixelCorrectLevel %d\n", value);
|
|
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 == hBinning) {
|
|
updateSensorSize();
|
|
printf("[DEBUG]::function Binning %d\n", value);
|
|
}
|
|
else if (index == hSubarrayHPos) {
|
|
printf("[DEBUG]::function SubArrayHPos %d\n", value);
|
|
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHPOS, &dvalue);
|
|
if(failed(m_err)) {
|
|
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
|
|
}
|
|
}
|
|
else if (index == hSubarrayHSize) {
|
|
printf("[DEBUG]::function SubarrayHSize %d\n", value);
|
|
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHSIZE, &dvalue);
|
|
if(failed(m_err)) {
|
|
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
|
|
}
|
|
}
|
|
else if (index == hSubarrayVPos) {
|
|
printf("[DEBUG]::function SubarrayVPos %d\n", value);
|
|
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVPOS, &dvalue);
|
|
if(failed(m_err)) {
|
|
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
|
|
}
|
|
}
|
|
else if (index == hSubarrayVSize) {
|
|
printf("[DEBUG]::function SubarrayVSize %d\n", value);
|
|
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVSIZE, &dvalue);
|
|
if(failed(m_err)) {
|
|
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
|
|
}
|
|
}
|
|
else if (index == hSubarrayMode) {
|
|
printf("[DEBUG]::function SubarrayMode %d\n", value);
|
|
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);
|
|
}
|
|
}
|
|
else if (index == hIntensityLutMode) {
|
|
printf("[DEBUG]::function IntensityLutMode %d\n", value);
|
|
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_INTENSITYLUT_MODE, &dvalue);
|
|
if(failed(m_err)) {
|
|
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
|
|
}
|
|
}
|
|
else if (index == hIntensityLutPage) {
|
|
printf("[DEBUG]::function IntensityLutPage %d\n", value);
|
|
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_INTENSITYLUT_PAGE, &dvalue);
|
|
if(failed(m_err)) {
|
|
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
|
|
}
|
|
}
|
|
else if (index == hExtractionMode) {
|
|
printf("[DEBUG]::function ExtractionMode %d\n", value);
|
|
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_EXTRACTION_MODE, &dvalue);
|
|
if(failed(m_err)) {
|
|
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
|
|
}
|
|
}
|
|
else if (index == hTimingExposure) {
|
|
printf("[DEBUG]::function TimingExposure %d\n", value);
|
|
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TIMING_EXPOSURE, &dvalue);
|
|
if(failed(m_err)) {
|
|
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
|
|
}
|
|
}
|
|
else if (index == hImageWidth) {
|
|
printf("[DEBUG]::function ImageWidth %d\n", value);
|
|
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_IMAGE_WIDTH, &dvalue);
|
|
if(failed(m_err)) {
|
|
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
|
|
}
|
|
}
|
|
else if (index == hImageHeight) {
|
|
printf("[DEBUG]::function ImageHeight %d\n", value);
|
|
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_IMAGE_HEIGHT, &dvalue);
|
|
if(failed(m_err)) {
|
|
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
|
|
}
|
|
}
|
|
else if (index == hImageRowbytes) {
|
|
printf("[DEBUG]::function ImageRowBytes %d\n", value);
|
|
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_IMAGE_ROWBYTES, &dvalue);
|
|
if(failed(m_err)) {
|
|
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
|
|
}
|
|
}
|
|
else if (index == hImageFramebytes) {
|
|
printf("[DEBUG]::function ImageFramBytes %d\n", value);
|
|
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &dvalue);
|
|
if(failed(m_err)) {
|
|
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
|
|
}
|
|
}
|
|
else if (index == hImageTopOffsetBytes) {
|
|
printf("[DEBUG]::function ImageTopOffsetBytes %d\n", value);
|
|
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_IMAGE_TOPOFFSETBYTES, &dvalue);
|
|
if(failed(m_err)) {
|
|
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
|
|
}
|
|
}
|
|
else if (index == hImagePixelType) {
|
|
printf("[DEBUG]::function ImagePixelType %d\n", value);
|
|
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 == hBufferRowbytes) {
|
|
printf("[DEBUG]::function BufferRowBytes %d\n", value);
|
|
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_BUFFER_ROWBYTES, &dvalue);
|
|
if(failed(m_err)) {
|
|
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
|
|
}
|
|
}
|
|
else if (index == hBufferFramebytes) {
|
|
printf("[DEBUG]::function BufferFrameBytes %d\n", value);
|
|
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_BUFFER_FRAMEBYTES, &dvalue);
|
|
if(failed(m_err)) {
|
|
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
|
|
}
|
|
}
|
|
else if (index == hBufferTopOffsetBytes) {
|
|
printf("[DEBUG]::function BufferTopOffsetBytes %d\n", value);
|
|
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_BUFFER_TOPOFFSETBYTES, &dvalue);
|
|
if(failed(m_err)) {
|
|
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
|
|
}
|
|
}
|
|
else if (index == hBufferPixelType) {
|
|
printf("[DEBUG]::function BufferPixelType %d\n", value);
|
|
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_BUFFER_PIXELTYPE, &dvalue);
|
|
if(failed(m_err)) {
|
|
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
|
|
}
|
|
}
|
|
else if (index == hRecordFixedBytesPerFile) {
|
|
printf("[DEBUG]::function ecordFixedBytesPerFile %d\n", value);
|
|
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_RECORDFIXEDBYTES_PERFILE, &dvalue);
|
|
if(failed(m_err)) {
|
|
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
|
|
}
|
|
}
|
|
else if (index == hRecordFixedBytesPerSession) {
|
|
printf("[DEBUG]::function RecordFixedBytesPerSesion %d\n", value);
|
|
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_RECORDFIXEDBYTES_PERSESSION, &dvalue);
|
|
if(failed(m_err)) {
|
|
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
|
|
}
|
|
}
|
|
else if (index == hRecordFixedBytesPerFrame) {
|
|
printf("[DEBUG]::function RecordFixedBytesPerFrame %d\n", value);
|
|
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_RECORDFIXEDBYTES_PERFRAME, &dvalue);
|
|
if(failed(m_err)) {
|
|
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
|
|
}
|
|
}
|
|
else if (index == hNumberOfOutputTriggerConnector) {
|
|
printf("[DEBUG]::function NumberOutputTriggerConnector %d\n", value);
|
|
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_NUMBEROF_OUTPUTTRIGGERCONNECTOR, &dvalue);
|
|
if(failed(m_err)) {
|
|
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
|
|
}
|
|
}
|
|
else if (index == hOutputTriggerSource0) {
|
|
printf("[DEBUG]::function OutputTriggerSource0 %d\n", value);
|
|
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 == hOutputTriggerPolarity0) {
|
|
printf("[DEBUG]::function OutputTriggerPolaroty0 %d\n", value);
|
|
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 == hOutputTriggerActive0) {
|
|
printf("[DEBUG]::function OutputTriggerActive0 %d\n", value);
|
|
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_ACTIVE, &dvalue);
|
|
if(failed(m_err)) {
|
|
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
|
|
}
|
|
}
|
|
else if (index == hOutputTriggerKind0) {
|
|
printf("[DEBUG]::function OutputTriggerKind0 %d\n", value);
|
|
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 == hOutputTriggerBaseSensor0) {
|
|
printf("[DEBUG]::function OutputTriggerBaseSensor0 %d\n", value);
|
|
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 == hOutputTriggerPreHsyncCount) {
|
|
printf("[DEBUG]::function OutputTriggerPreHsynCount %d\n", value);
|
|
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);
|
|
}
|
|
}
|
|
else if (index == hMasterPulseMode) {
|
|
printf("[DEBUG]::function MasterPulseMode %d\n", value);
|
|
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) {
|
|
printf("[DEBUG]::function MasterPulseTriggerSource %d\n", value);
|
|
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) {
|
|
printf("[DEBUG]::function MasterPulseBurstTimes %d\n", value);
|
|
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);
|
|
}
|
|
}
|
|
else if (index == hSystemAlive) {
|
|
printf("[DEBUG]::function SystemAlive %d\n", value);
|
|
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SYSTEM_ALIVE, &dvalue);
|
|
if(failed(m_err)) {
|
|
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
|
|
}
|
|
}
|
|
else if (index == hNumberOfView) {
|
|
printf("[DEBUG]::function NumberOfView %d\n", value);
|
|
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_NUMBEROF_VIEW, &dvalue);
|
|
if(failed(m_err)) {
|
|
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
|
|
}
|
|
}
|
|
else if (index == hImageDetectorPixelNumHorz) {
|
|
printf("[DEBUG]::function ImageDetectorPixelNumHorz %d\n", value);
|
|
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_IMAGEDETECTOR_PIXELHEIGHT, &dvalue);
|
|
if(failed(m_err)) {
|
|
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
|
|
}
|
|
}
|
|
else if (index == hImageDetectorPixelNumVert) {
|
|
printf("[DEBUG]::function ImageDetectorPixelNumVert %d\n", value);
|
|
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_IMAGEDETECTOR_PIXELWIDTH, &dvalue);
|
|
if(failed(m_err)) {
|
|
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
|
|
}
|
|
}
|
|
else if (index == hTimeStampProducer) {
|
|
printf("[DEBUG]::function TimeStampProducer %d\n", value);
|
|
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TIMESTAMP_PRODUCER, &dvalue);
|
|
if(failed(m_err)) {
|
|
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
|
|
}
|
|
}
|
|
else if (index == hFrameStampProducer) {
|
|
printf("[DEBUG]::function FrameStampProducer %d\n", value);
|
|
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_FRAMESTAMP_PRODUCER, &dvalue);
|
|
if(failed(m_err)) {
|
|
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
|
|
}
|
|
}
|
|
else{
|
|
printf("[DEBUG]::function writeInt32 did not find a parameter\n");
|
|
}
|
|
|
|
setIntegerParam(index, 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 Hama::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);
|
|
|
|
|
|
if(index == ADAcquireTime) {
|
|
printf("[DEBUG]::function ADAcquireTime from camera: %f\n", value);
|
|
status = (asynStatus)setFeature(DCAM_IDPROP_EXPOSURETIME, value);
|
|
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_EXPOSURETIME, &dvalue);
|
|
if(failed(m_err)) {
|
|
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
|
|
}
|
|
}
|
|
else if (index == hTriggerDelay) {
|
|
printf("[DEBUG]::function TriggerDelay %f\n", value);
|
|
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);
|
|
}
|
|
}
|
|
/*
|
|
else if (index == hExposureTime) {
|
|
printf("[DEBUG]::function ADImageMode %f\n", value);
|
|
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_EXPOSURETIME, &dvalue);
|
|
if(failed(m_err)) {
|
|
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
|
|
}
|
|
}
|
|
*/
|
|
|
|
else if (index == hTimingReadoutTime) {
|
|
printf("[DEBUG]::function TimingReadoutTime %f\n", value);
|
|
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TIMING_READOUTTIME, &dvalue);
|
|
if(failed(m_err)) {
|
|
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
|
|
}
|
|
}
|
|
else if (index == hTimingCyclicTriggerPeriod) {
|
|
printf("[DEBUG]::function TimingCyclicTriggerPeriod %f\n", value);
|
|
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TIMING_CYCLICTRIGGERPERIOD, &dvalue);
|
|
if(failed(m_err)) {
|
|
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
|
|
}
|
|
}
|
|
else if (index == hTimingMinTriggerBlanking) {
|
|
printf("[DEBUG]::function TimingMinTriggerBlanking %f\n", value);
|
|
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TIMING_MINTRIGGERBLANKING, &dvalue);
|
|
if(failed(m_err)) {
|
|
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
|
|
}
|
|
}
|
|
else if (index == hTimingMinTriggerInterval) {
|
|
printf("[DEBUG]::function TimingMinTriggerInterval %f\n", value);
|
|
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TIMING_MINTRIGGERINTERVAL, &dvalue);
|
|
if(failed(m_err)) {
|
|
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
|
|
}
|
|
}
|
|
else if (index == hTimingGlobalExposureDelay) {
|
|
printf("[DEBUG]::function TimingGlobalExposureDelay %f\n", value);
|
|
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TIMING_GLOBALEXPOSUREDELAY, &dvalue);
|
|
if(failed(m_err)) {
|
|
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
|
|
}
|
|
}
|
|
else if (index == hTimingInvalidExposurePeriod) {
|
|
printf("[DEBUG]::function TimingEnvalidExposurePeriod %f\n", value);
|
|
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TIMING_INVALIDEXPOSUREPERIOD, &dvalue);
|
|
if(failed(m_err)) {
|
|
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
|
|
}
|
|
}
|
|
else if (index == hInternalFrameRate) {
|
|
printf("[DEBUG]::function InternalFrameRate %f\n", value);
|
|
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_INTERNALFRAMERATE, &dvalue);
|
|
if(failed(m_err)) {
|
|
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
|
|
}
|
|
}
|
|
else if (index == hInternalFrameInterval) {
|
|
printf("[DEBUG]::function InternalFrameRate %f\n", value);
|
|
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_INTERNAL_FRAMEINTERVAL, &dvalue);
|
|
if(failed(m_err)) {
|
|
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
|
|
}
|
|
}
|
|
else if (index == hInternalLineSpeed) {
|
|
printf("[DEBUG]::function InternalLineSpeed %f\n", value);
|
|
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) {
|
|
printf("[DEBUG]::function InternalLineInterupt %f\n", value);
|
|
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 == hOutputTriggerDelay0) {
|
|
printf("[DEBUG]::function OutputTriggerDelay0 %f\n", value);
|
|
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 == hOutputTriggerPeriod0) {
|
|
printf("[DEBUG]::function OutputTriggerPeriod0 %f\n", value);
|
|
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 == hMasterPulseInterval) {
|
|
printf("[DEBUG]::function MasterPulseInterval %f\n", value);
|
|
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);
|
|
}
|
|
}
|
|
else if (index == hConversionFactorCoeff) {
|
|
printf("[DEBUG]::function ConversionFactorCoeff %f\n", value);
|
|
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_CONVERSIONFACTOR_COEFF, &dvalue);
|
|
if(failed(m_err)) {
|
|
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
|
|
}
|
|
}
|
|
else if (index == hConversionFactorOffset) {
|
|
printf("[DEBUG]::function ConversionFactorOffset %f\n", value);
|
|
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_CONVERSIONFACTOR_OFFSET, &dvalue);
|
|
if(failed(m_err)) {
|
|
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
|
|
}
|
|
}
|
|
else if (index == hImageDetectorPixelWidth) {
|
|
printf("[DEBUG]::function ImageDetectorPixelWidth %f\n", value);
|
|
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_IMAGEDETECTOR_PIXELWIDTH, &dvalue);
|
|
if(failed(m_err)) {
|
|
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
|
|
}
|
|
}
|
|
else if (index == hImageDetectorPixelHeight) {
|
|
printf("[DEBUG]::function ImageDetectorPixelHeight %f\n", value);
|
|
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_IMAGEDETECTOR_PIXELHEIGHT, &dvalue);
|
|
if(failed(m_err)) {
|
|
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
|
|
}
|
|
}
|
|
else{
|
|
printf("[DEBUG]::function writeFloat64 did not find a parameter\n");
|
|
}
|
|
|
|
setDoubleParam(index, value);
|
|
status = (asynStatus) callParamCallbacks();
|
|
|
|
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
|
|
asynPrint(pasynUser, ASYN_TRACEIO_DRIVER,
|
|
"%s:%s: function=%d, paramName=%s, value=%f\n",
|
|
driverName, functionName, index, paramName, value);
|
|
|
|
|
|
|
|
return(asynSuccess);
|
|
}
|
|
|
|
//============================================================================
|
|
int Hama::updateSensorSize(){
|
|
|
|
int minH=0, minV=0, sizeH=0, sizeV=0, binning=1;
|
|
int status = 0;
|
|
|
|
double v1,v2,v3,v4,b1;
|
|
double a1,a2,a3,a4;
|
|
|
|
status |= getIntegerParam(ADMinX, &minH);
|
|
status |= getIntegerParam(ADMinY, &minV);
|
|
status |= getIntegerParam(ADSizeX, &sizeH);
|
|
status |= getIntegerParam(ADSizeY, &sizeV);
|
|
status |= getIntegerParam(hBinning, &binning);
|
|
|
|
printf("minH = %d\nminV = %d\nSizeV = %d\nSizeH = %d\n", minH, minV, sizeV, sizeH);
|
|
|
|
double value = 0;
|
|
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_BINNING_INDEPENDENT, &value);
|
|
printf("DCAM_IDPROP_BINNING_INDEPENDENT: %d\n", value);
|
|
|
|
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYMODE, &value);
|
|
printf("DCAM_IDPROP_SUBARRAYMODE: %d\n", value);
|
|
|
|
// set subarray mode off. This setting is not mandatory,
|
|
// but you have to control the setting order of offset and size when mode is on.
|
|
m_err = dcamprop_setvalue(m_hdcam, DCAM_IDPROP_SUBARRAYMODE, DCAMPROP_MODE__OFF);
|
|
|
|
m_err = dcamprop_setvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHPOS, minH);
|
|
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHPOS, &v1);
|
|
if( failed(m_err) )
|
|
printError( m_hdcam, m_err, "dcambuf_release()" );
|
|
|
|
|
|
m_err = dcamprop_setvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVPOS, minV);
|
|
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVPOS, &v2);
|
|
if( failed(m_err) )
|
|
printError( m_hdcam, m_err, "dcambuf_release()" );
|
|
|
|
m_err = dcamprop_setvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHSIZE, sizeH);
|
|
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHSIZE, &v3);
|
|
if( failed(m_err) )
|
|
printError( m_hdcam, m_err, "dcambuf_release()" );
|
|
|
|
m_err = dcamprop_setvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVSIZE, sizeV);
|
|
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVSIZE, &v4);
|
|
if( failed(m_err) )
|
|
printError( m_hdcam, m_err, "dcambuf_release()" );
|
|
|
|
// set subarray mode on. The combination of offset and size is checked on this timing.
|
|
m_err = dcamprop_setvalue(m_hdcam, DCAM_IDPROP_SUBARRAYMODE, DCAMPROP_MODE__ON);
|
|
|
|
m_err = dcamprop_setvalue(m_hdcam, DCAM_IDPROP_BINNING, (double)binning);
|
|
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_BINNING, &b1);
|
|
if( failed(m_err) )
|
|
printError( m_hdcam, m_err, "dcambuf_release()" );
|
|
|
|
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_WIDTH, &a1);
|
|
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_HEIGHT, &a2);
|
|
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_ROWBYTES, &a3);
|
|
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &a4);
|
|
|
|
status = (asynStatus) callParamCallbacks();
|
|
printf("status = %d\n", status);
|
|
|
|
printf("\n");
|
|
printf("updateSensorSize, hPos = %d\n", int(v1) );
|
|
printf("updateSensorSize, hSize = %d\n", int(v3) );
|
|
printf("updateSensorSize, vPos = %d\n", int(v2) );
|
|
printf("updateSensorSize, vSize = %d\n", int(v4) );
|
|
printf("updateSensorSize, binning = %d\n", int(b1) );
|
|
printf("updateSensorSize, imageSizeH = %d\n", int(a1) );
|
|
printf("updateSensorSize, imageSizeV = %d\n", int(a2) );
|
|
printf("updateSensorSize, imageSize = %d\n", int(a1*a2) );
|
|
printf("updateSensorSize, rowBytes = %d\n", int(a3) );
|
|
printf("updateSensorSize, frameBytes = %d\n", int(a4) );
|
|
return 0;
|
|
}
|
|
|
|
//============================================================================
|
|
/*
|
|
asynStatus Hama::readEnum(asynUser *pasynUser, char *strings[], int values[],
|
|
int severities[], size_t nElements, size_t *nIn){
|
|
|
|
printf("[DEBUG]::readEnum\t");
|
|
const char* functionName = "readEnum";
|
|
const char *paramName;
|
|
|
|
int function = pasynUser->reason;
|
|
asynStatus status = asynSuccess;
|
|
|
|
|
|
getParamName(function, ¶mName);
|
|
|
|
|
|
double value = 0;
|
|
dcamprop_getvalue(m_hdcam, function, &value);
|
|
|
|
// dcamprop_setvalue(m_hdcam, function, value);
|
|
|
|
if (function == hSensorMode) {
|
|
printf("function Sensor Mode\n");
|
|
}
|
|
else if (function == hReadoutDirection) {
|
|
printf("function Readout Direction\n");
|
|
}
|
|
else if (function == hTriggerSource) {
|
|
printf("function Trigger Source\n");
|
|
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TRIGGERSOURCE, &value);
|
|
setIntegerParam(function, value);
|
|
|
|
}
|
|
else if (function == hTriggerMode) {
|
|
printf("function Trigger Mode\n");
|
|
}
|
|
else if (function == hTriggerActive) {
|
|
printf("function Trigger Active\n");
|
|
}
|
|
else if (function == hTriggerGlobalExposure) {
|
|
printf("function Trigger Global Exposure\n");
|
|
}
|
|
else if (function == hTriggerPolarity) {
|
|
printf("function Trigger Polarity\n");
|
|
}
|
|
else if (function == hTriggerConnector) {
|
|
printf("function TriggerConnector\n");
|
|
}
|
|
else if (function == hInternalTriggerHandling) {
|
|
printf("function Internal Trigger Handling\n");
|
|
}
|
|
else if (function == hSensorCooler) {
|
|
printf("function Sensor Cooler\n");
|
|
}
|
|
else if (function == hSensorCoolerStatus){
|
|
printf("function Sensor Cooler Status\n");
|
|
}
|
|
///////////////////////////////////////////////////////////////////
|
|
else if (function == hColorType) {
|
|
printf("function Color Type\n");
|
|
}
|
|
else if (function == hImagePixelType) {
|
|
printf("function Image Pixel Type\n");
|
|
}
|
|
else if (function == hBufferPixelType) {
|
|
printf("function Buffer Pixel Type\n");
|
|
}
|
|
else if (function == hSystemAlive) {
|
|
printf("function System Alive\n");
|
|
}
|
|
else if (function == hTimeStampProducer) {
|
|
printf("function Time Stamp Producer\n");
|
|
}
|
|
else if (function == hFrameStampProducer) {
|
|
printf("function Frame Stamp producer\n");
|
|
}
|
|
// else if (function == ) {
|
|
// printf("function \n");
|
|
// }
|
|
// else if (function == ) {
|
|
// printf("function \n");
|
|
// }
|
|
// else if (function == ) {
|
|
// printf("function \n");
|
|
// }
|
|
else {
|
|
printf("function ELSE....\n");
|
|
}
|
|
*nIn = 0;
|
|
|
|
status = (asynStatus) callParamCallbacks();
|
|
|
|
asynPrint(pasynUserSelf, ASYN_TRACEIO_DRIVER,
|
|
"%s:%s: entry, function=%d, string=%s\n", driverName, functionName, function, strings[0]);
|
|
|
|
return(asynSuccess);
|
|
}
|
|
*/
|
|
//============================================================================
|
|
|
|
void Hama::report(FILE *fp, int details){
|
|
|
|
printf("[DEBUG]::report\n");
|
|
}
|
|
|
|
//============================================================================
|
|
int Hama::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);
|
|
|
|
asynPrint(pasynUserSelf, ASYN_TRACE_FLOW,
|
|
"%s:%s: connecting camera %d\n",
|
|
driverName, functionName, m_id);
|
|
|
|
m_err = dcamapi_init( &m_apiInit);
|
|
if( failed(m_err) ){
|
|
printError( m_hdcam, m_err, "dcamapi_init()", NULL );
|
|
} else {
|
|
nDevices = m_apiInit.iDeviceCount;
|
|
printf("dcamapi_init() found %d device(s). \n", nDevices);
|
|
printf("camera with index 0 will be used\n");
|
|
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;
|
|
}
|
|
|
|
/* close api */ //- it should be here??????????????
|
|
// dcamapi_uninit();
|
|
// return status;
|
|
return 0;
|
|
}
|
|
|
|
//============================================================================
|
|
int Hama::disconnectCamera(void){
|
|
|
|
static const char *functionName = "disconnectCamera";
|
|
|
|
int status = 0;
|
|
|
|
|
|
if(m_hdcam == NULL) {
|
|
return status;
|
|
}
|
|
|
|
asynPrint(pasynUserSelf, ASYN_TRACE_FLOW,
|
|
"%s:%s: disconnecting camera %d\n",
|
|
driverName, functionName, m_id);
|
|
|
|
// status = AT_GetBool(handle_, L"CameraAcquiring", &acquiring);
|
|
// if(status == AT_SUCCESS && acquiring) {
|
|
// status |= AT_Command(handle_, L"Acquisition Stop");
|
|
// }
|
|
|
|
// status |= freeBuffers();
|
|
dcamdev_close( m_hdcam );
|
|
|
|
if(status) {
|
|
asynPrint(pasynUserSelf, ASYN_TRACE_ERROR,
|
|
"%s:%s: error closing camera %d\n",
|
|
driverName, functionName, m_id);
|
|
}
|
|
|
|
m_hdcam = NULL;
|
|
return status;
|
|
|
|
|
|
}
|
|
//============================================================================
|
|
int Hama::allocateBuffers(unsigned int nBuffers) {
|
|
m_err = dcambuf_alloc(m_hdcam, nBuffers);
|
|
if(failed(m_err)) {
|
|
puts("banana");
|
|
printError(m_hdcam, m_err, "dcambuf_alloc()");
|
|
return asynError;
|
|
}
|
|
return asynSuccess;
|
|
}
|
|
|
|
//============================================================================
|
|
int Hama::freeBuffers(){
|
|
m_err = dcambuf_release( m_hdcam );
|
|
if( failed(m_err) )
|
|
printError( m_hdcam, m_err, "dcambuf_release()" );
|
|
|
|
return 0;
|
|
}
|
|
|
|
asynStatus Hama::stopAcquire(void)
|
|
{
|
|
asynStatus status = asynSuccess;
|
|
dcamcap_stop(m_hdcam);
|
|
printf("Stop Capture\n");
|
|
return status;
|
|
}
|
|
|
|
asynStatus Hama::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;
|
|
}
|
|
else {
|
|
printf( "\nStart Capture\n" );
|
|
// set wait param
|
|
DCAMWAIT_START waitstart;
|
|
memset( &waitstart, 0, sizeof(waitstart) );
|
|
waitstart.size = sizeof(waitstart);
|
|
waitstart.eventmask = DCAMWAIT_CAPEVENT_FRAMEREADY;
|
|
waitstart.timeout = DCAMWAIT_TIMEOUT_INFINITE;
|
|
|
|
m_err = dcamwait_start(hwait, &waitstart);
|
|
if(failed(m_err)) {
|
|
printError(m_hdcam, m_err, "dcamwait_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 Hama::accessCapturedImage(HDCAM hdcam, int32 iFrame, void* buf,
|
|
int32 rowbytes, int32 cx, int32 cy,
|
|
int32& ts_sec, int32& ts_microsec)
|
|
{
|
|
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 ) {
|
|
printf("not implement pixel type\n");
|
|
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 Hama::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 Hama::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) {
|
|
printf( "not capture image\n" );
|
|
return asynError;
|
|
}
|
|
|
|
return asynSuccess;
|
|
}
|
|
|
|
//============================================================================
|
|
void Hama::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 Hama::printInfo(HDCAM hdcam){
|
|
|
|
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 {
|
|
printf( "%s (%s) on %s\n", model, cameraid, bus );
|
|
}
|
|
|
|
}
|
|
|
|
|
|
//============================================================================
|
|
|
|
int Hama::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 );
|
|
}
|
|
|
|
//============================================================================
|
|
//============================================================================
|
|
/* Code for iocsh registration */
|
|
|
|
|
|
|
|
extern "C" int HamaConfig(const char *portName, int cameraId, int maxBuffers,
|
|
size_t maxMemory, int priority, int stackSize,
|
|
int maxFrames) {
|
|
new Hama(portName, cameraId, maxBuffers, maxMemory, priority, stackSize,
|
|
maxFrames);
|
|
|
|
return(asynSuccess);
|
|
}
|
|
|
|
//============================================================================
|
|
static const iocshArg HamaConfigArg0 = {"Port name", iocshArgString};
|
|
static const iocshArg HamaConfigArg1 = {"CameraId", iocshArgInt};
|
|
static const iocshArg HamaConfigArg2 = {"maxBuffers", iocshArgInt};
|
|
static const iocshArg HamaConfigArg3 = {"maxMemory", iocshArgInt};
|
|
static const iocshArg HamaConfigArg4 = {"priority", iocshArgInt};
|
|
static const iocshArg HamaConfigArg5 = {"stackSize", iocshArgInt};
|
|
static const iocshArg HamaConfigArg6 = {"maxFrames", iocshArgInt};
|
|
static const iocshArg * const HamaConfigArgs[] = { &HamaConfigArg0,
|
|
&HamaConfigArg1,
|
|
&HamaConfigArg2,
|
|
&HamaConfigArg3,
|
|
&HamaConfigArg4,
|
|
&HamaConfigArg5,
|
|
&HamaConfigArg6 };
|
|
//============================================================================
|
|
static const iocshFuncDef confighama = {"devHamamatsuConfig", 7, HamaConfigArgs};
|
|
|
|
//============================================================================
|
|
static void confighamaCallFunc(const iocshArgBuf *args) {
|
|
HamaConfig(args[0].sval, args[1].ival, args[2].ival, args[3].ival,
|
|
args[4].ival, args[5].ival, args[6].ival);
|
|
}
|
|
|
|
//============================================================================
|
|
static void hamaRegister(void) {
|
|
|
|
iocshRegister(&confighama, confighamaCallFunc);
|
|
}
|
|
|
|
//============================================================================
|
|
extern "C" {
|
|
|
|
epicsExportRegistrar(hamaRegister);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|