From 00b958fe5c4974e0765e8b804c62e2d7f09cc417 Mon Sep 17 00:00:00 2001 From: Iocuser Date: Wed, 11 May 2022 14:17:17 +0200 Subject: [PATCH] added parameters and variables in the hama class --- ADHama.Makefile | 18 ++- ADHamaApp/Db/hama.template | 88 +++++++++++++ ADHamaApp/src/hama.cpp | 257 +++++++++++++++++++++++++++++++++++-- ADHamaApp/src/hama.h | 240 ++++++++++++++++++++++++++++++++-- 4 files changed, 577 insertions(+), 26 deletions(-) diff --git a/ADHama.Makefile b/ADHama.Makefile index 4b08373..3600418 100644 --- a/ADHama.Makefile +++ b/ADHama.Makefile @@ -46,7 +46,7 @@ REQUIRED += busy # ############################################################################ -# EXCLUDE_ARCHS += linux-ppc64e6500 +EXCLUDE_ARCHS += linux-ppc64e6500 ############################################################################ @@ -55,10 +55,10 @@ REQUIRED += busy # ############################################################################ -APP := ADHamaApp -APPDB := $(APP)/Db -APPSRC := $(APP)/src -APPCMDS:= $(APP)/cmds +APP := ADHamaApp +APPDB := $(APP)/Db +APPSRC := $(APP)/src +APPCMDS := $(APP)/cmds ############################################################################ # @@ -77,6 +77,8 @@ TEMPLATES += $(wildcard $(APPDB)/*.template) # USR_INCLUDES += -I $(E3_ASYN_LOCATION)/asyn/asynDriver # USR_INCLUDES += -I $(E3_ASYN_LOCATION)/asyn/asynPortDriver +# USR_INCLUDES += -DLINUX -I/home/iocuser/dcamsdk4/inc/ +USR_INCLUDES += -DLINUX -I ../support/dcamsdk4/inc/ ############################################################################ # @@ -84,7 +86,7 @@ TEMPLATES += $(wildcard $(APPDB)/*.template) # ############################################################################ -SOURCES += $(APPSRC)/ADHamaMain.cpp +# SOURCES += $(APPSRC)/ADHamaMain.cpp SOURCES += $(APPSRC)/hama.cpp @@ -104,7 +106,7 @@ DBDS += $(APPSRC)/hama.dbd # ############################################################################ -# HEADERS += +# HEADERS += /home/iocuser/dcamsdk4/inc ############################################################################ @@ -130,6 +132,8 @@ USR_DBFLAGS += -I $(E3_ADCORE_LOCATION)/db USR_DBFLAGS += -I $(EPICS_BASE)/db USR_DBFLAGS += -I $(APPDB) +USR_LDFLAGS += -L/usr/local/lib -ldcamapi + db: $(SUBS) $(TMPS) $(SUBS): diff --git a/ADHamaApp/Db/hama.template b/ADHamaApp/Db/hama.template index 4dfeccb..a4422fc 100644 --- a/ADHamaApp/Db/hama.template +++ b/ADHamaApp/Db/hama.template @@ -2,4 +2,92 @@ include "ADBase.template" +############################################################################### +# Note: The following are records defined in ADBase.template. # +# We are changing some of the fields here to reflect valid values for # +# Hamamatsu Orca Flash4.0 # +############################################################################### + +############################################################################### +# These records control the data type and color. # +############################################################################### + +# Only unsigned 16 and 32 bit integers are supported. Determined by PixelEncoding +record(mbbo, "$(P)$(R)DataType") { + field(ZRST, "UInt16") + field(ZRVL, "3") + field(ONST, "UInt32") + field(ONVL, "5") + field(TWST, "") + field(TWVL, "") + field(THST, "") + field(THVL, "") + field(FRST, "") + field(FRVL, "") + field(FVST, "") + field(FVVL, "") + field(SXST, "") + field(SXVL, "") + field(SVST, "") + field(SVVL, "") +} + +record(mbbi, "$(P)$(R)DataType_RBV") { + field(ZRST, "UInt16") + field(ZRVL, "3") + field(ONST, "UInt32") + field(ONVL, "5") + field(TWST, "") + field(TWVL, "") + field(THST, "") + field(THVL, "") + field(FRST, "") + field(FRVL, "") + field(FVST, "") + field(FVVL, "") + field(SXST, "") + field(SXVL, "") + field(SVST, "") + field(SVVL, "") +} + +# Only Mono color mode is supported at this time +record(mbbo, "$(P)$(R)ColorMode") { + field(ZRST, "Mono") + field(ZRVL, "0") + field(ONST, "") + field(ONVL, "") + field(TWST, "") + field(TWVL, "") + field(THST, "") + field(THVL, "") + field(FRST, "") + field(FRVL, "") + field(FVST, "") + field(FVVL, "") + field(SXST, "") + field(SXVL, "") + field(SVST, "") + field(SVVL, "") +} + +record(mbbi, "$(P)$(R)ColorMode_RBV") { + field(ZRST, "Mono") + field(ZRVL, "0") + field(ONST, "") + field(ONVL, "") + field(TWST, "") + field(TWVL, "") + field(THST, "") + field(THVL, "") + field(FRST, "") + field(FRVL, "") + field(FVST, "") + field(FVVL, "") + field(SXST, "") + field(SXVL, "") + field(SVST, "") + field(SVVL, "") +} + diff --git a/ADHamaApp/src/hama.cpp b/ADHamaApp/src/hama.cpp index 24a2f1d..4e832d0 100644 --- a/ADHamaApp/src/hama.cpp +++ b/ADHamaApp/src/hama.cpp @@ -2,6 +2,7 @@ #include #include #include +#include #include #include @@ -17,7 +18,7 @@ // -#define NUM_HAMA_PARAMS ((int)(&LAST_PARAM - &FIRST_PARAM + 1)) +#define NUM_HAMA_PARAMS ((int)(&LAST_HAMA_PARAM - &FIRST_HAMA_PARAM + 1)) static const char *driverName="drvHama"; @@ -30,27 +31,89 @@ Hama::Hama(const char* portName, int cameraId, int maxBuffers, size_t maxMemory, ASYN_CANBLOCK, /* ASYN_CANBLOCK=1 ASYN_MULTIDEVICE=0 */ 1, /* autoConnect=1 */ priority, stackSize), - handle(0){ + m_hdcam(NULL), m_id(0){ - createParam( HamaName, asynParamOctet, &p_name); + printf("[DEBUG] === Constructor ADHama ===\n"); + printf("[DEBUG] driverName: %s\n", driverName); + + createParam( HamaName, asynParamOctet, &hHamaName); + createParam( hSensorModeString, asynParamInt32, &hSensorMode); + createParam( hReadoutSpeedString, asynParamInt32, &hReadoutSpeed); + createParam( hReadoutDirectionString, asynParamInt32, &hReadoutDirection); + + 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); + + createParam( hSensorTemperatureString, asynParamFloat64, &hSensorTemperature); + createParam( hSensorCoolerString, asynParamInt32, &hSensorCooler); + createParam( hSensorCoolerStatusString, asynParamInt32, &hSensorCoolerStatus); +// createParam( - printf("=== Constructor ADHama ===\n"); - printf(" driverName: %s\n", driverName); + connectCamera(); + + printf("[DEBUG] === END Constructor ADHama ===\n"); } //============================================================================ Hama::~Hama(){ - + // not sure if the destructor has to be define here... + printf("[DEBUG] === Destructor ADHama ===\n"); } //============================================================================ asynStatus Hama::writeInt32(asynUser *pasynUser, epicsInt32 value){ -//asynPrint(pasynUserSelf, ASYN_TRACE_ERROR, -// "%s:%s: failed to register all features for camera %d\n", -// driverName, functionName, id_); -return(asynSuccess); + const char* functionName = "writeInt32"; + const char *paramName; + + int function = pasynUser->reason; + asynStatus status = asynSuccess; + + // getParamName(index, ¶mName); + + if (function == hSensorMode) { + //set_integration_time(); + } + else if (function == hReadoutSpeed) { + + } + else if (function == hReadoutDirection) { + // Update the calculated spectrum + //update_data_spectrum(); + } + else if (function == hColorType) { + // Check if implmemented in QEPro + } + else if (function == hBitPerChannel) { + // Check if implmemented in QEPro + } + else if (function == hTriggerSource) { + //getIntegerParam(P_triggerMode, &triggerMode); + //api->spectrometerSetTriggerMode( device_id, spectrometer_feature_id, &error, triggerMode); + } + else{ + + } + + + + + + + /* Do callbacks so higher layers see any changes */ + status = (asynStatus) callParamCallbacks(); + + asynPrint(pasynUser, ASYN_TRACEIO_DRIVER, "%s:%s: port=%s, value=%d, status=%d\n", + driverName, functionName, this->portName, value, (int)status); + +return status; } //============================================================================ @@ -76,6 +139,180 @@ void Hama::report(FILE *fp, int 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 ); + } + +// if(status != AT_SUCCESS) { +// asynPrint(pasynUserSelf, ASYN_TRACE_ERROR, +// "%s:%s: unable to open camera %d\n", +// driverName, functionName, m_id); +// return status; +// } + + int ferr = allocateBuffers(10); + if( ferr ){ + printError( m_hdcam, m_err, "dcambuf_alloc()" ); + // return = 1; + } + + /* close api */ //- it should be here?????????????? +// dcamapi_uninit(); +// return status; + return 0; +} + +//============================================================================ +int Hama::disconnectCamera(void){ + + static const char *functionName = "disconnectCamera"; + + int status; + + + 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) ) + return 1; + +return 0; +} + +//============================================================================ +int Hama::freeBuffers(){ + m_err = dcambuf_release( m_hdcam ); + if( failed(m_err) ) + printError( m_hdcam, m_err, "dcambuf_release()" ); + +return 0; +} +//============================================================================ +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( "FAILED: (DCAMERR)0x%08X %s @ %s", 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 ); +} //============================================================================ //============================================================================ diff --git a/ADHamaApp/src/hama.h b/ADHamaApp/src/hama.h index ef2eac1..1ac807e 100644 --- a/ADHamaApp/src/hama.h +++ b/ADHamaApp/src/hama.h @@ -2,11 +2,127 @@ #define DRV_HAMA_H #include "ADDriver.h" +#include "dcamapi4.h" +#define HamaName "Name" /* asynOctet ro */ +#define hFrameRateString "H_FRAME_RATE" /* asynOctet ro */ + +// Sensor mode and speed +#define hSensorModeString "H_SENSOR_MODE" /* asynint32 rw */ +#define hReadoutSpeedString "H_READOUT_SPEED" /* asynInt32 rw */ +#define hReadoutDirectionString "H_READOUT_DIRECTION" /* asynInt32 rw */ + +// Trigger +#define hTriggerSourceString "H_TRIGGER_SOURCE" /* asynInt32 rw */ +#define hTriggerModeString "H_TRIGGER_MODE" /* asynInt32 rw */ +#define hTriggerActiveString "H_TRIGGER_ACTIVE" /* asynInt32 rw */ +#define hTriggerGlobalExposureString "H_TRIGGER_GLOBAR_EXPOSURE" /* asynInt32 rw */ +#define hTriggerPolarityString "H_TRIGGER_POLARITY" /* asynInt32 rw */ +#define hTriggerConnectorString "H_TRIGGER_CONNECTOR" /* asynInt32 rw */ +#define hTriggerTimesString "H_TRIGGER_TIMES" /* asynInt32 rw */ +#define hTriggerDelayString "H_TRIGGER_DELAY" /* asynFloat64 rw */ +#define hInternalTriggerHandlingString "H_INTERNAL_TRIGGER_HANDLING" /* asynInt32 rw */ + +// Sensor cooler +#define hSensorTemperatureString "H_SENSOR_TEMPERATURE" /* asynFloat64 ro */ +#define hSensorCoolerString "H_SENSOR_COOLER" /* asynInt32 rw */ +#define hSensorCoolerStatusString "H_SENSOR_COOLER_STATUS" /* asynInt32 ro */ + +// Binning and ROI +#define hBinningString "H_BINNING" /* asynInt32 rw */ +#define hSubarrayHPosString "H_SUBARRAY_HPOST" /* asynInt32 rw */ +#define hSubarrayHSizeString "H_SUBARRAY_HSIZE" /* asynInt32 rw */ +#define hSubarrayVPosString "H_SUBARRAY_VPOS" /* asynInt32 rw */ +#define hSubarrayVSizeString "H_SUBARRAY_VPOS" /* asynInt32 rw */ +#define hSubarrayModeString "H_SUBARRAY_MODE" /* asynInt32 rw */ +// #define hFrameBundleMode (usb3 only not implemented) +// #define hFrameBundleNumber (usb3 only not implemented) + +// Feature +#define hExposureTimeString "H_EXPOSURE_TIME" /* asynFloat64 rw */ + +// ALU +#define hDefectCorrectModeString "H_DEFECT_CORRECT_MODE" /* asynInt32 rw */ +#define hHotPixelCorrectLevelString "H_HOT_PIXEL_CORRECT_LEVEL" /* asynInt32 rw */ +#define hIntensityLutModeString "H_INTENSITY_LUT_MODE" /* asynInt32 rw */ +#define hIntensityLutPageString "H_INTENSITY_LUT_PAGE" /* asynInt32 ro */ +#define hExtractionModeString "H_EXTRACTION_MODE" /* asynInt32 ro */ + +// output trigger +#define hNumberOfOutputTriggerConnectorsString "H_NUMBER_OUTPUT_TRIGGER_CONNECTORS" /* asynInt32 ro */ +#define hOutputTriggerSource0String "H_OUTPUT_TRIGGER_SOURCE0" /* asynInt32 rw */ +#define hOutputTriggerSource1String "H_OUTPUT_TRIGGER_SOURCE1" /* asynInt32 rw */ +#define hOutputTriggerSource2String "H_OUTPUT_TRIGGER_SOURCE2" /* asynInt32 rw */ +#define hOutputTriggerPolarity0String "H_OUTPUT_TRIGGER_POLARITY0" /* asynInt32 rw */ +#define hOutputTriggerPolarity1String "H_OUTPUT_TRIGGER_POLARITY1" /* asynInt32 rw */ +#define hOutputTriggerPolarity2String "H_OUTPUT_TRIGGER_POLARITY2" /* asynInt32 rw */ +#define hOutputTriggerActive0String "H_OUTPUT_TRIGGER_ACTIVE0" /* asynInt32 ro */ +#define hOutputTriggerActive1String "H_OUTPUT_TRIGGER_ACTIVE1" /* asynInt32 ro */ +#define hOutputTriggerActive2String "H_OUTPUT_TRIGGER_ACTIVE2" /* asynInt32 ro */ +#define hOutputTriggerDelay0String "H_OUTPUT_TRIGGER_DELAY0" /* asynFloat64 rw */ +#define hOutputTriggerDelay1String "H_OUTPUT_TRIGGER_DELAY1" /* asynFloat64 rw */ +#define hOutputTriggerDelay2String "H_OUTPUT_TRIGGER_DELAY2" /* asynFloat64 rw */ +#define hOutputTriggerPeriod0String "H_OUTPUT_TRIGGER_PERIOD0" /* asynFloat64 rw */ +#define hOutputTriggerPeriod1String "H_OUTPUT_TRIGGER_PERIOD1" /* asynFloat64 rw */ +#define hOutputTriggerPeriod2String "H_OUTPUT_TRIGGER_PERIOD2" /* asynFloat64 rw */ +#define hOutputTriggerKind0String "H_OUTPUT_TRIGGER_KIND0" /* asynInt32 rw */ +#define hOutputTriggerKind1String "H_OUTPUT_TRIGGER_KIND1" /* asynInt32 rw */ +#define hOutputTriggerKind2String "H_OUTPUT_TRIGGER_KIND2" /* asynInt32 rw */ +#define hOutputTriggerBaseSensor0String "H_OUTPUT_TRIGGER_BASE_SENSOR0" /* asynInt32 rw */ +#define hOutputTriggerBaseSensor1String "H_OUTPUT_TRIGGER_BASE_SENSOR1" /* asynInt32 rw */ +#define hOutputTriggerBaseSensor2String "H_OUTPUT_TRIGGER_BASE_SENSOR2" /* asynInt32 rw */ +#define hOutTriggerPreHsyncCountString "H_OUTPUT_TRIGGER_PRE_HSYNC_COUNT" /* asynInt32 rw */ + +// Master Puls +#define hMasterPulseModeString "H_MASTERPULSE_MODE" /* asynInt32 rw */ +#define hMasterPulseTriggerSourceString "H_MASTERPULSE_TRIGGER_SOURCE" /* asynInt32 rw */ +#define hMasterPulseIntervalString "H_MASTERPULSE_INTERVAL" /* asynFloat64 rw */ +#define hMasterPulseBurstTimesString "H_MASTERPULSE_BURST_TIMES" /* asynInt32 rw */ + +// Synchronious Timing +#define hTimingReadoutTimeString "H_TIMING_READOUT_TIME" /* asynFloat64 ro */ +#define hTimingCyclicTriggerPeriodString "H_TIMING_CYCLIC_TRIGGER_PERIOD" /* asynFloat64 ro */ +#define hTimingMinTriggerBlankingString "H_TIMING_MIN_TRIGGER_BLANKING" /* asynFloat64 ro */ +#define hTimingMinTriggerIntervalString "H_TIMING_MIN_TRIGGER_INTERVAL" /* asynFloat64 ro */ +#define hTimingGlobalExposureDelayString "H_TIMING_GLOBAL_EXPOSURE_DELAY" /* asynFloat64 ro */ +#define hTimingExposureString "H_TIMING_EXPOSURE" /* asynInt32 ro */ +#define hTimingInvalidExposurePeriodString "H_TIMING_INVALID_EXPOSURE_PERIOD" /* asynFloat64 ro */ +#define hInternalFrameRateString "H_INTERNAL_FRAME_RATE" /* asynFloat64 rw */ +#define hInternalFrameIntervalString "H_INTERNAL_FRAME_INTERVAL" /* asynFloat64 rw */ +#define hInternalLineSpeedString "H_INTERNAL_LINE_SPEED" /* asynFloat64 rw */ +#define hInternalLineIntervalString "H_INTERNAL_LINE_INTERVAL" /* asynFloat64 rw */ + +// System information +#define hColorTypeString "H_COLOR_TYPE" /* asynInt32 ro */ +#define hBitPerChannelString "H_BIT_PER_CHANNEL" /* asynInt32 rw */ +#define hImageWidthString "H_IMAGE_WIDTH" /* asynInt32 ro */ +#define hImageHeightString "H_IMAGE_HEIGHT" /* asynInt32 ro */ +#define hImageRowBytesString "H_IMAGE_ROWBYTES" /* asynInt32 ro */ +#define hImageFrameBytesString "H_IMAGE_FRAMEBYTES" /* asynInt32 ro */ +#define hImageTopOffsetBytesString "H_IMAGE_TOP_OFFSETBYTES" /* asynInt32 ro */ +#define hImagePixelTypeString "H_IMAGE_PIXEL_TYPE" /* asynInt32 rw */ +#define hBufferRowbytesString "H_BUFFER_ROWBYTES" /* asynInt32 ro */ +#define hBufferFramebytesString "H_BUFFER_FRAMEBYTES" /* asynInt32 ro */ +#define hBufferTopOffsetBytesString "H_BUFFER_TOP_OFFSETBYTES" /* asynInt32 ro */ +#define hBufferPixelTypeString "H_BUFFER_PIXEL_TYPE" /* asynInt32 ro */ +#define hRecordFixedBytesPerFileString "H_RECORD_FIXED_BYTES_PER_FILE" /* asynInt32 ro */ +#define hRecordFixedBytesPerSessionString "H_RECORD_FIXED_BYTES_PER_SESION" /* asynInt32 ro */ +#define hRecordFixedBytesPerFrameString "H_RECORD_FIXED_BYTES_PER_FRAME" /* asynInt32 ro */ +#define hSystemAliveString "H_SYSTEM_ALIVE" /* asynInt32 ro */ +#define hConversionFactorCoeffString "H_CONVERSION_FACTOR_COEF" /* asynFloat64 ro */ +#define hConversionFactorOffsetString "H_CONVERSION_FACTOR_OFFSET" /* asynFloat64 ro */ +#define hNumberOfViewString "H_NUMBER_OF_VIEW" /* asynInt32 ro */ +#define hImageDetectorPixelWidthString "H_IMAGE_DETECTOR_PIXEL_WIDTH" /* asynFloat64 ro */ +#define hImageDetectorPixelHeightString "H_IMAGE_DETECTOR_PIXEL_HEIGHT" /* asynFloat64 ro */ +#define hImageDetectorPixelNumHorzString "H_IMAGE_DETECTOR_PIXEL_NUM_HORZ" /* asynInt32 ro */ +#define hImageDetectorPixelNumVertString "H_IMAGE_DETECTOR_PIXEL_NUM_VERT" /* asynInt32 ro */ +#define hTimeStampProducerString "H_TIMESTAMP_PRODUCER" /* asynInt32 ro */ +#define hFrameStampProducerString "H_FRAMESTAMP_PRODUCER" /* asynInt32 ro */ + + -#define HamaName "Name" /* asynOctet ro */ class Hama : public ADDriver { @@ -21,18 +137,124 @@ public: virtual void report(FILE *fp, int details); protected: - int FrameRate; - #define FIRST_PARAM FrameRate - int p_name; - #define LAST_PARAM p_name + int hFrameRate; + #define FIRST_HAMA_PARAM hFrameRate + int hHamaName; + int hSensorMode; + int hReadoutSpeed; + int hReadoutDirection; + int hColorType; + int hBitPerChannel; + int hTriggerSource; + int hTriggerMode; + int hTriggerActive; + int hTriggerGlobalExposure; + int hTriggerPolarity; + int hTriggerConnector; + int hTriggerTimes; + int hTriggerDelay; + int hInternalTriggerHandling; + int hSensorTemperature; + int hSensorCooler; + int hSensorCoolerStatus; + int hExposureTime; + int hDefectCorrectMode; + int hHotPixelCorrectLevel; + int hBinning; + int hSubarrayHPos; + int hSubarrayHSize; + int hSubarrayVPos; + int hSubarrayVSize; + int hSubarrayMode; + int hIntensityLutMode; + int hIntensityLutPage; + int hExtractionMode; + int hTimingReadoutTime; + int hTimingCyclicTriggerPeriod; + int hTimingMinTriggerBlanking; + int hTimingMinTriggerInterval; + int hTimingGlobalExposureDelay; + int hTimingExposure; + int hTimingInvalidExposurePeriod; + int hInternalFrameRate; + int hInternalFrameInterval; + int hInternalLineSpeed; + int hInternalLineInterval; + int hImageWidth; + int hImageHeight; + int hImageRowbytes; + int hImageFramebytes; + int hImageTopOffsetBytes; + int hImagePixelType; + int hBufferRowbytes; + int hBufferFramebytes; + int hBufferTopOffsetBytes; + int hBufferPixelType; + int hRecordFixedBytesPerFile; + int hRecordFixedBytesPerSession; + int hRecordFixedBytesPerFrame; + int hNumberOfOutputTriggerConnectors; + int hOutputTriggerSource0; + int hOutputTriggerSource1; + int hOutputTriggerSource2; + int hOutputTriggerPolarity0; + int hOutputTriggerPolarity1; + int hOutputTriggerPolarity2; + int hOutputTriggerActive0; + int hOutputTriggerActive1; + int hOutputTriggerActive2; + int hOutputTriggerDelay0; + int hOutputTriggerDelay1; + int hOutputTriggerDelay2; + int hOutputTriggerPeriod0; + int hOutputTriggerPeriod1; + int hOutputTriggerPeriod2; + int hOutputTriggerKind0; + int hOutputTriggerKind1; + int hOutputTriggerKind2; + int hOutputTriggerBaseSensor0; + int hOutputTriggerBaseSensor1; + int hOutputTriggerBaseSensor2; + int hOutTriggerPreHsyncCount; + int hMasterPulseMode; + int hMasterPulseTriggerSource; + int hMAsterPulseInterval; + int hMasterPulseBurstTimes; + int hSystemAlive; + int hConversionFactorCoeff; + int hConversionFactorOffset; + int hNumberOfView; + int hImageDetectorPixelWidth; + int hImageDetectorPixelHeight; + int hImageDetectorPixelNumHorz; + int hImageDetectorPixelNumVert; + int hTimeStampProducer; + int hFrameStampProducer; + #define LAST_HAMA_PARAM hFrameStampProducer -private: - int *handle; - int allocateBuffers(); + +private: + + + HDCAM m_hdcam; + DCAMAPI_INIT m_apiInit; + DCAMDEV_OPEN m_devOpen; + DCAMERR m_err; + int m_id; + + // wrapper functions for dcamapi + int allocateBuffers(unsigned int); int freeBuffers(); + int connectCamera(); int disconnectCamera(); - + + // helper functions for dcamapi + void printError(HDCAM hdcam, DCAMERR errid, const char* apiname, const char* fmt=NULL, ...); + void printInfo(HDCAM hdcam); + int dcamdev_string( DCAMERR& err, HDCAM hdcam, int32 idStr, char* text, int32 textbytes ); + int setParameter(int paramIndex); + int getParameter(int paramIndex); }; #endif