lin-epics-modules/adorca
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
b01e13eb776d205538d8ddacf71a2c3847bcff07
adorca/ADHamaApp/src/hama.cpp
Iocuser b01e13eb77 small update
2023-02-09 09:20:07 +01:00

2268 lines
93 KiB
C++
Raw Blame History

#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>
#include <iostream>
using namespace std;
//#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, 0, 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( hFrameRateString, asynParamFloat64, &hFrameRate);
createParam( hHamaNameString, 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( 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);
//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);
createParam( hTimeStampString, asynParamFloat64, &hTimeStamp);
setIntegerParam(NDArrayCallbacks, 1);
callParamCallbacks();
connectCamera();
printf("\n\n============================ Init Camera =========================\n");
initCamera();
printf("\n\n============================ Start Threads =======================\n");
/* 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("\n\n=== END Constructor ADHama ===\n");
printf("===================================================================\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 |= 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);
// SUBARRAYMODE ------------------------------------------
// FEATURE -----------------------------------------------
// EXPOSURETIME ------------------------------------------
// 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);
// MASTER PULSE ------------------------------------------
// 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){
// 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::readParameterStr(int propertyID){
asynStatus status = asynSuccess;
char text[256];
DCAMDEV_STRING param;
memset( &param, 0, sizeof(param) );
param.size = sizeof(param);
param.text = text;
param.textbytes = sizeof(text);
param.iString = propertyID;
switch (propertyID){
case DCAM_IDSTR_VENDOR:
dcamdev_getstring(m_hdcam, &param);
status = setStringParam(hVendor, text);
printf("[DEBUG]::VENDOR %s\n", text);
break;
case DCAM_IDSTR_MODEL:
dcamdev_getstring(m_hdcam, &param);
status = setStringParam(hModel, text);
printf("[DEBUG]::MODEL %s\n", text);
break;
case DCAM_IDSTR_CAMERAID:
dcamdev_getstring(m_hdcam, &param);
status = setStringParam(hCameraID, text);
printf("[DEBUG]::CAMERAID %s\n", text);
break;
case DCAM_IDSTR_BUS:
dcamdev_getstring(m_hdcam, &param);
status = setStringParam(hBus, text);
printf("[DEBUG]::BUS %s\n", text);
break;
case DCAM_IDSTR_CAMERAVERSION:
dcamdev_getstring(m_hdcam, &param);
status = setStringParam(hCameraVersion, text);
printf("[DEBUG]::CAMERAVERSION %s\n", text);
break;
case DCAM_IDSTR_DRIVERVERSION:
dcamdev_getstring(m_hdcam, &param);
status = setStringParam(hDriverVersion, text);
printf("[DEBUG]::DRIVERVERSION %s\n", text);
break;
case DCAM_IDSTR_MODULEVERSION:
dcamdev_getstring(m_hdcam, &param);
status = setStringParam(hModuleVersion, text);
printf("[DEBUG]::MODULEVERSION %s\n", text);
break;
case DCAM_IDSTR_DCAMAPIVERSION:
dcamdev_getstring(m_hdcam, &param);
status = setStringParam(hDcamApiVersion, text);
printf("[DEBUG]::DCAMPVERSION %s\n", text);
break;
default:
printf("[DEBUG]::NOT SUPPORTED\n");
break;
}
callParamCallbacks();
return status;
}
//============================================================================
int Hama::readParameter(int propertyID){
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;
// - sensor temperature in a thread
// - 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;
// - feature
case DCAM_IDPROP_EXPOSURETIME: //(RW123)
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_EXPOSURETIME, &dvalue);
status = setIntegerParam(hExposureTime, 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));
printf("Parameter not recognised, IDPROP:0x%08x, NAME:%s\n", propertyID, text);
break;
}
if(failed(m_err)) {
char text[256];
dcamprop_getname(m_hdcam, propertyID, text, sizeof(text));
printError(m_hdcam, m_err, "+dcamprop_getvalue()", "IDPROP:0x%08x, VALUE:%s\n", propertyID, text);
}
/* Do callbacks so higher layers see any changes */
status = callParamCallbacks();
/*
if (status)
asynPrint(0, ASYN_TRACE_ERROR,
"%s:%s: error, status=%d function=%d, paramName=%s, value=%d\n",
driverName, functionName, status, index, paramName, value);
else
asynPrint(NULL, ASYN_TRACEIO_DRIVER,
"%s:%s: function=%d, paramName=%s, value=%d\n",
driverName, functionName, index, paramName, value);
*/
return status;
}
//============================================================================
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;
epicsTimeStamp prevAcqTime, currentAcqTime;
double elapsedTime;
//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();
epicsTimeGetCurrent(&prevAcqTime);
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);
getIntegerParam(NDArrayCounter, &count);
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);
double exposure_time, readout_time, timestamp;
//double _readouttime, _internal_frameinternal, _cyclictriggerperiod, _mintriggerblanking;
//dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TIMING_READOUTTIME, &_readouttime);
//dcamprop_getvalue(m_hdcam, DCAM_IDPROP_INTERNAL_FRAMEINTERVAL, &_internal_frameinternal);
//dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TIMING_CYCLICTRIGGERPERIOD, &_cyclictriggerperiod);
//dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TIMING_MINTRIGGERBLANKING, &_mintriggerblanking);
//printf("DCAM_IDPROP_TIMING_READOUTTIME: %f\n", _readouttime);
//printf("DCAM_IDPROP_INTERNAL_FRAMEINTERVAL: %f\n", _internal_frameinternal);
//printf("DCAM_IDPROP_TIMING_CYCLICTRIGGERPERIOD: %f\n", _cyclictriggerperiod);
//printf("DCAM_IDPROP_TIMING_MINTRIGGERBLANKING: %f\n", _mintriggerblanking);
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_TIMING_READOUTTIME, &readout_time);
dcamprop_getvalue(m_hdcam, DCAM_IDPROP_EXPOSURETIME, &exposure_time);
timestamp = (ts_sec + ts_microsec / 1.0e6) - (exposure_time + readout_time);
status = setDoubleParam(hTimeStamp, timestamp);
printf("Timestamp from camera: %f\n", (ts_sec + ts_microsec / 1.0e6));
//printf("Timestamp from camera with correction: %f\n", timestamp);
epicsTimeGetCurrent(&currentAcqTime);
elapsedTime = epicsTimeDiffInSeconds(&currentAcqTime, &prevAcqTime);
prevAcqTime = currentAcqTime;
status = setDoubleParam(hFrameRate, (double)(1 / elapsedTime));
getIntegerParam(NDArrayCallbacks, &callback);
if(callback) {
NDArray *pImage;
size_t dims[2];
int itemp=0;
getIntegerParam(NDArraySizeX, &itemp); dims[0] = itemp;
getIntegerParam(NDArraySizeY, &itemp); dims[1] = itemp;
pImage = pNDArrayPool->alloc(2, dims, NDUInt16, 0, 0);
if(pImage) {
pImage->uniqueId = count;
pImage->timeStamp = 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 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 Hama::readAttributes(){
int status = 0;
readParameter( DCAM_IDPROP_COLORTYPE );
//status |= readParameter( DCAM_IDPROP_BITSPERCHANNEL );
status = readParameter( DCAM_IDPROP_IMAGE_ROWBYTES );
status = readParameter( DCAM_IDPROP_IMAGE_FRAMEBYTES );
status = readParameter( DCAM_IDPROP_IMAGE_TOPOFFSETBYTES );
//status |= readParameter( DCAM_IDPROP_IMAGE_PIXELTYPE );
status = readParameter( DCAM_IDPROP_BUFFER_ROWBYTES );
status = readParameter( DCAM_IDPROP_BUFFER_FRAMEBYTES );
status = readParameter( DCAM_IDPROP_BUFFER_TOPOFFSETBYTES );
status = readParameter( DCAM_IDPROP_BUFFER_PIXELTYPE );
status = readParameter( DCAM_IDPROP_RECORDFIXEDBYTES_PERFILE );
status = readParameter( DCAM_IDPROP_RECORDFIXEDBYTES_PERSESSION );
status = readParameter( DCAM_IDPROP_RECORDFIXEDBYTES_PERFRAME );
status = readParameter( DCAM_IDPROP_SYSTEM_ALIVE );
status = readParameter( DCAM_IDPROP_CONVERSIONFACTOR_COEFF );
status = readParameter( DCAM_IDPROP_CONVERSIONFACTOR_OFFSET );
status = readParameter( DCAM_IDPROP_NUMBEROF_VIEW );
return (asynStatus)status;
}
//============================================================================
asynStatus Hama::readSensor(){
asynStatus status = asynSuccess;
int minH=0, minV=0, sizeH=0, sizeV=0, binning=1, bitPerChannel = 0;
double dminH=0, dminV=0, dsizeH=0, dsizeV=0, dbinning=1;
double dFrameBytes = 0, dRowBytes = 0;
double dvalue = 0;
getIntegerParam(ADMinX, &minH);
getIntegerParam(ADMinY, &minV);
getIntegerParam(ADSizeX, &sizeH);
getIntegerParam(ADSizeY, &sizeV);
getIntegerParam(hBinning, &binning);
getIntegerParam(hBitPerChannel, &bitPerChannel);
dbinning = binning;
dminH = minH;
dminV = minV;
dsizeH = sizeH;
dsizeV = sizeV;
double modeON = DCAMPROP_MODE__ON;
double modeOFF = DCAMPROP_MODE__OFF;
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYMODE, &modeOFF);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_BINNING, &dbinning);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHPOS, &dminH);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVPOS, &dminV);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHSIZE, &dsizeH);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVSIZE, &dsizeV);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_WIDTH, &dvalue);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_HEIGHT, &dvalue);
status = setIntegerParam(ADBinX, dvalue);
status = setIntegerParam(ADBinY, dvalue);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_ROWBYTES, &dRowBytes);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_IMAGE_FRAMEBYTES, &dFrameBytes);
//m_err = dcamprop_getvalue(m_hdcam, , &dvalue);
status = setIntegerParam(hBinning, dbinning);
status = setIntegerParam(hImageFramebytes, dFrameBytes);
status = setIntegerParam(hImageRowbytes, dRowBytes);
unsigned long size = (dsizeH - dminH) * (dsizeV - dminV) * dbinning;
printf("[DEBUG::readSensor] BitPerChannel = %d\n", bitPerChannel);
printf("[DEBUG::readSensor] ImageSize = %ld\n", size);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYMODE, &modeON);
callParamCallbacks();
return status;
}
//============================================================================
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);
getParamName(index, &paramName);
/* Ensure that ADStatus is set correctly before we set ADAcquire.*/
getIntegerParam(ADStatus, &adstatus);
status = setIntegerParam(index, value);
if (index == ADAcquire) {
printf("[DEBUG]::writeInit32 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]::writeInit32 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]::writeInit32 ADNumExposures\n");
}
else if (index == ADMinX) {
readSensor();
}
else if (index == ADMinY) {
readSensor();
}
else if (index == ADSizeX) {
readSensor();
}
else if (index == ADSizeY) {
readSensor();
}
else if (index == ADReadStatus) {
// dcamprop_setvalue(m_hdcam, DCAM_IDPROP_, value);
// dcamprop_getvalue(m_hdcam, DCAM_IDPROP_, &value_d);
printf("[DEBUG]::writeInit32 ADReadStatus\n");
}
//-- Sensor mode and speed
else if (index == hSensorMode) {
printf("[DEBUG]::writeInit32 SensorMode %d\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SENSORMODE, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
else if (index == hReadoutSpeed) {
printf("[DEBUG]::writeInit32 ReadoutSpeed %d\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_READOUTSPEED, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
else if (index == hReadoutDirection) {
printf("[DEBUG]::writeInit32 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);
}
}
//-- Trigger
else if (index == hTriggerSource) {
printf("[DEBUG]::writeInit32 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]::writeInit32 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]::writeInit32 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]::writeInit32 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]::writeInit32 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]::writeInit32 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]::writeInit32 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]::writeInit32 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);
}
}
//-- binning and ROI
else if (index == hBinning) {
readSensor();
printf("[DEBUG]::writeInit32 Binning %d\n", value);
}
else if (index == hSubarrayHPos) {
printf("[DEBUG]::function SubArrayHPos %d\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHPOS, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
else if (index == hSubarrayHSize) {
printf("[DEBUG]::writeInit32 SubarrayHSize %d\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYHSIZE, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
else if (index == hSubarrayVPos) {
printf("[DEBUG]::writeInit32 SubarrayVPos %d\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVPOS, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
else if (index == hSubarrayVSize) {
printf("[DEBUG]::writeInit32 SubarrayVSize %d\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYVSIZE, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
else if (index == hSubarrayMode) {
printf("[DEBUG]::writeInit32 SubarrayMode %d\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYMODE, &dvalue);
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);
}
}
*/
//-- ALU
else if (index == hDefectCorrectMode) {
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_DEFECTCORRECT_MODE, &dvalue);
printf("[DEBUG]::writeInit32 DefectCorrerMode %f\n", 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]::writeInit32 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 == hIntensityLutMode) {
printf("[DEBUG]::writeInit32 IntensityLutMode %d\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_INTENSITYLUT_MODE, &dvalue);
if(failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()", "IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
}
/*
else if (index == hExtractionMode) {
printf("[DEBUG]::writeInit32 ExtractionMode %d\n", value);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_EXTRACTION_MODE, &dvalue);
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) {
printf("[DEBUG]::writeInit32 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 == hOutputTriggerSource1) {
printf("[DEBUG]::writeInit32 OutputTriggerSource1 %d\n", value);
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) {
printf("[DEBUG]::writeInit32 OutputTriggerSource2 %d\n", value);
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) {
printf("[DEBUG]::writeInit32 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 == hOutputTriggerPolarity1) {
printf("[DEBUG]::writeInit32 OutputTriggerPolaroty1 %d\n", value);
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) {
printf("[DEBUG]::writeInit32 OutputTriggerPolaroty2 %d\n", value);
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) {
printf("[DEBUG]::writeInit32 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 == hOutputTriggerKind1) {
printf("[DEBUG]::writeInit32 OutputTriggerKind1 %d\n", value);
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) {
printf("[DEBUG]::writeInit32 OutputTriggerKind2 %d\n", value);
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) {
printf("[DEBUG]::writeInit32 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 == hOutputTriggerBaseSensor1) {
printf("[DEBUG]::writeInit32 OutputTriggerBaseSensor1 %d\n", value);
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) {
printf("[DEBUG]::writeInit32 OutputTriggerBaseSensor2 %d\n", value);
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) {
printf("[DEBUG]::writeInit32 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);
}
}
//-- Master pulse
else if (index == hMasterPulseMode) {
printf("[DEBUG]::writeInit32 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]::writeInit32 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]::writeInit32 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);
}
}
//-- Synchronous timing - nothing to implement either is in writeFloat64
//-- System information
else if (index == hBitPerChannel) {
printf("[DEBUG]::writeInit32 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 == hImagePixelType) {
printf("[DEBUG]::writeInit32 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 < FIRST_HAMA_PARAM){
status = ADDriver::writeInt32(pasynUser, value);
printf("[+DEBUG]:: ADDriver::writeInit32 %s\n", paramName);
//ADDriver::writeInt32(pasynUser, value);
}
else{
printf("[-DEBUG]::function writeInt32 did not find a parameter index = %d, %s\n", index, paramName);
}
}
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, &paramName);
//-- Sensor mode and speed
//-- Feature
if(index == ADAcquireTime) {
printf("[DEBUG]::function ADAcquireTime from camera: %f\n", value);
int trigger_mode = 0;
getIntegerParam(hTriggerSource, &trigger_mode);
if (trigger_mode != DCAMPROP_TRIGGERSOURCE__EXTERNAL) {
status = 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);
}
double acquire_period = 0;
status = getDoubleParam(ADAcquirePeriod, &acquire_period);
if (value >= acquire_period) {
status = setDoubleParam(ADAcquirePeriod, 0);
status = setFeature(DCAM_IDPROP_TRIGGERSOURCE, DCAMPROP_TRIGGERSOURCE__INTERNAL);
status = setIntegerParam(hTriggerSource, DCAMPROP_TRIGGERSOURCE__INTERNAL);
callParamCallbacks();
}
}
else status = asynError;
}
else if(index == ADAcquirePeriod) {
printf("[DEBUG]::function ADAcquirePeriod from camera: %f\n", value);
int trigger_mode = 0;
getIntegerParam(hTriggerSource, &trigger_mode);
if (trigger_mode != DCAMPROP_TRIGGERSOURCE__EXTERNAL) {
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_EXPOSURETIME, &dvalue);
if (value <= dvalue) {
status = setFeature(DCAM_IDPROP_TRIGGERSOURCE, DCAMPROP_TRIGGERSOURCE__INTERNAL);
status = setIntegerParam(hTriggerSource, DCAMPROP_TRIGGERSOURCE__INTERNAL);
value = 0;
}
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 status = asynError;
}
//-- Trigger
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);
}
}
//-- Sensor cooler - nothing
//-- Binning and ROI - nothing
//-- ALU - nothing
//-- Output trigger
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 == hOutputTriggerDelay1) {
printf("[DEBUG]::function OutputTriggerDelay1 %f\n", value);
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) {
printf("[DEBUG]::function OutputTriggerDelay2 %f\n", value);
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) {
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 == hOutputTriggerPeriod1) {
printf("[DEBUG]::function OutputTriggerPeriod1 %f\n", value);
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) {
printf("[DEBUG]::function OutputTriggerPeriod2 %f\n", value);
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) {
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);
}
}
//-- Synchronous timing
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 < FIRST_HAMA_PARAM){
status = ADDriver::writeFloat64(pasynUser, value);
printf("[+DEBUG]:: ADDriver::writeInit32 %s\n", paramName);
}
else{
printf("[-DEBUG]::function writeInt32 did not find a parameter index = %d, %s\n", index, paramName);
}
}
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 Hama::report(FILE *fp, int details){
double dvalue = 0;
fprintf(fp, "Hamamatsu 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);
//m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_ACTIVE+4, &dvalue);
//fprintf(fp, ":\t%f\n", dvalue);
//m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_ACTIVE+6, &dvalue);
//fprintf(fp, ":\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 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( &param, 0, sizeof(param) );
param.size = sizeof(param);
param.text = text;
param.textbytes = textbytes;
param.iString = idStr;
err = dcamdev_getstring( hdcam, &param );
return ! failed( err );
}
//============================================================================
asynStatus 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;
}
//============================================================================
//============================================================================
/* 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);
}
Reference in New Issue View Git Blame Copy Permalink