lin-epics-modules/adorca
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Replace printf to asynPrint

Browse Source
This commit is contained in:
Douglas Araujo
2024-09-12 12:59:05 +02:00
parent 481b7722c5
commit 9225d07a0d
1 changed files with 93 additions and 102 deletions
Download Patch File Download Diff File Expand all files Collapse all files
ADOrcaApp/src/orca.cpp
+93 -102
View File
@@ -8,6 +8,15 @@ using namespace std;
static const char* driverName = "drvOrca";
// Flow message formatters
#define FLOW(msg) \
asynPrint(pasynUserSelf, ASYN_TRACE_FLOW, "%s::%s: %s\n", driverName, \
functionName, msg)
#define FLOW_ARGS(fmt, ...) \
asynPrint(pasynUserSelf, ASYN_TRACE_FLOW, "%s::%s: " fmt "\n", driverName, \
functionName, __VA_ARGS__);
static void c_imagetask(void* arg) {
Orca* p = (Orca*)arg;
p->imageTask();
@@ -31,18 +40,11 @@ Orca::Orca(const char* portName, int cameraId, int maxBuffers, size_t maxMemory,
{
const char* functionName = "orcaDetector::orcaDetector";
printf("[DEBUG] === Constructor ADOrca ===\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);
FLOW("epicsEventCreate failure for acquire start event");
return;
}
@@ -53,14 +55,9 @@ Orca::Orca(const char* portName, int cameraId, int maxBuffers, size_t maxMemory,
callParamCallbacks();
connectCamera();
printf(
"\n\n============================ Init Camera "
"=========================\n");
FLOW("Init Camera");
initCamera();
printf(
"\n\n============================ Start Threads "
"=======================\n");
/* launch image read task */
epicsThreadCreate("OrcaImageTask", epicsThreadPriorityMedium,
epicsThreadGetStackSize(epicsThreadStackMedium),
@@ -70,13 +67,6 @@ Orca::Orca(const char* portName, int cameraId, int maxBuffers, size_t maxMemory,
epicsThreadCreate("OrcaTemperatureTask", epicsThreadPriorityMedium,
epicsThreadGetStackSize(epicsThreadStackMedium),
c_temperaturetask, this);
/* shutdown on exit */
// epicsAtExit(c_shutdown, this);
printf("\n\n=== END Constructor ADOrca ===\n");
printf(
"===================================================================\n");
}
void Orca::createAsynParams() {
@@ -341,6 +331,7 @@ int Orca::initCamera() {
//============================================================================
int Orca::readParameterStr(int propertyID) {
const char* functionName = "readParameterStr";
asynStatus status = asynSuccess;
char text[256];
@@ -355,45 +346,45 @@ int Orca::readParameterStr(int propertyID) {
case DCAM_IDSTR_VENDOR:
dcamdev_getstring(m_hdcam, &param);
status = setStringParam(hVendor, text);
printf("[DEBUG]::VENDOR %s\n", text);
FLOW_ARGS("Vendor %s\n", text);
break;
case DCAM_IDSTR_MODEL:
dcamdev_getstring(m_hdcam, &param);
status = setStringParam(hModel, text);
printf("[DEBUG]::MODEL %s\n", text);
FLOW_ARGS("Model %s\n", text);
break;
case DCAM_IDSTR_CAMERAID:
dcamdev_getstring(m_hdcam, &param);
status = setStringParam(hCameraID, text);
printf("[DEBUG]::CAMERAID %s\n", text);
FLOW_ARGS("CameraID %s\n", text);
break;
case DCAM_IDSTR_BUS:
dcamdev_getstring(m_hdcam, &param);
status = setStringParam(hBus, text);
printf("[DEBUG]::BUS %s\n", text);
FLOW_ARGS("Bus %s\n", text);
break;
case DCAM_IDSTR_CAMERAVERSION:
dcamdev_getstring(m_hdcam, &param);
status = setStringParam(hCameraVersion, text);
printf("[DEBUG]::CAMERAVERSION %s\n", text);
FLOW_ARGS("CameraVersion %s\n", text);
break;
case DCAM_IDSTR_DRIVERVERSION:
dcamdev_getstring(m_hdcam, &param);
status = setStringParam(hDriverVersion, text);
printf("[DEBUG]::DRIVERVERSION %s\n", text);
FLOW_ARGS("DriverVersion %s\n", text);
break;
case DCAM_IDSTR_MODULEVERSION:
dcamdev_getstring(m_hdcam, &param);
status = setStringParam(hModuleVersion, text);
printf("[DEBUG]::MODULEVERSION %s\n", text);
FLOW_ARGS("ModuleVersion %s\n", text);
break;
case DCAM_IDSTR_DCAMAPIVERSION:
dcamdev_getstring(m_hdcam, &param);
status = setStringParam(hDcamApiVersion, text);
printf("[DEBUG]::DCAMPVERSION %s\n", text);
FLOW_ARGS("DCAMP Version %s\n", text);
break;
default:
printf("[DEBUG]::NOT SUPPORTED\n");
FLOW("NOT SUPPORTED\n");
break;
}
@@ -404,6 +395,7 @@ int Orca::readParameterStr(int propertyID) {
//============================================================================
int Orca::readParameter(int propertyID, bool processPV) {
const char* functionName = "readParameter";
asynStatus status = asynSuccess;
double dvalue = 0;
@@ -814,8 +806,8 @@ int Orca::readParameter(int propertyID, bool processPV) {
default:
char text[256];
dcamprop_getname(m_hdcam, propertyID, text, sizeof(text));
printf("Parameter not recognised, IDPROP:0x%08x, NAME:%s\n", propertyID,
text);
FLOW_ARGS("Parameter not recognised, IDPROP:0x%08x, NAME:%s\n",
propertyID, text);
break;
}
@@ -832,6 +824,7 @@ int Orca::readParameter(int propertyID, bool processPV) {
//============================================================================
void Orca::imageTask() {
const char* functionName = "imageTask";
int status;
unsigned char* image;
int acquire;
@@ -893,7 +886,7 @@ void Orca::imageTask() {
lock();
if (prevAcquisitionCount < (uint64_t)captransferinfo.nFrameCount) {
printf("\nOrca Frame Count: %d\n", captransferinfo.nFrameCount);
FLOW_ARGS("\nOrca Frame Count: %d\n", captransferinfo.nFrameCount);
prevAcquisitionCount = captransferinfo.nFrameCount;
// get image information
@@ -902,7 +895,7 @@ void Orca::imageTask() {
framebytes);
if (pixeltype != DCAM_PIXELTYPE_MONO16) {
printf("not implement\n");
FLOW("not implement");
return;
}
@@ -930,9 +923,9 @@ void Orca::imageTask() {
evr_counts_since_last_start = evr_counts - initial_evr_counters;
evr_trigger_dropped =
evr_counts_since_last_start - captransferinfo.nFrameCount;
printf("EVR event count: %d\n", evr_counts);
printf("evr_counts_since_last_start: %d\n",
evr_counts_since_last_start);
FLOW_ARGS("EVR event count: %d\n", evr_counts);
FLOW_ARGS("evr_counts_since_last_start: %d\n",
evr_counts_since_last_start);
setIntegerParam(evrCountsSinceAcqStart, evr_counts_since_last_start);
setIntegerParam(evrTriggerDropped, evr_trigger_dropped);
char buf[256];
@@ -941,17 +934,17 @@ void Orca::imageTask() {
// remember parsed timestamp values
sscanf(buf, "%u.%u", &mTimeStampSec, &mTimeStampNsec);
timestamp = mTimeStampSec + mTimeStampNsec / 1.e9;
printf("mTimeStampSec: %u - mTimeStampNsec: %u\n", mTimeStampSec,
mTimeStampNsec);
printf("Timestamp from evr: %f\n", timestamp);
FLOW_ARGS("mTimeStampSec: %u - mTimeStampNsec: %u\n", mTimeStampSec,
mTimeStampNsec);
FLOW_ARGS("Timestamp from evr: %f\n", timestamp);
} else {
timestamp =
(ts_sec + ts_microsec / 1.0e6) - (exposure_time + readout_time);
printf("Timestamp from camera: %f\n", timestamp);
FLOW_ARGS("Timestamp from camera: %f\n", timestamp);
}
printf("readout_time: %f - exposure_time: %f\n", readout_time,
exposure_time);
FLOW_ARGS("readout_time: %f - exposure_time: %f\n", readout_time,
exposure_time);
epicsTimeGetCurrent(&currentAcqTime);
elapsedTime = epicsTimeDiffInSeconds(&currentAcqTime, &prevAcqTime);
prevAcqTime = currentAcqTime;
@@ -1003,7 +996,7 @@ void Orca::imageTask() {
if ((epicsTimeDiffInSeconds(&currentAcqTime, &prevAcqTime) >
maxAcqusitionTime) &&
acqStatus != ADStatusAborted) {
printf("[DEBUG]::maxAcqusitionTime %f\n", maxAcqusitionTime);
FLOW_ARGS("maxAcqusitionTime %f\n", maxAcqusitionTime);
setShutter(0);
stopAcquire();
setIntegerParam(ADAcquire, 0);
@@ -1208,9 +1201,8 @@ asynStatus Orca::writeInt32(asynUser* pasynUser, epicsInt32 value) {
value = (int)dsizeY;
}
readParameter(DCAM_IDPROP_TIMING_READOUTTIME, false);
else if (index == hSensorMode) {
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SENSORMODE, &dvalue);
} else if (index == hSensorMode) {
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SENSORMODE, &dvalue);
if (failed(m_err))
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
@@ -1218,7 +1210,7 @@ asynStatus Orca::writeInt32(asynUser* pasynUser, epicsInt32 value) {
}
else if (index == hReadoutSpeed) {
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_READOUTSPEED, &dvalue);
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);
@@ -1226,7 +1218,7 @@ asynStatus Orca::writeInt32(asynUser* pasynUser, epicsInt32 value) {
}
else if (index == hReadoutDirection) {
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_READOUT_DIRECTION,
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_READOUT_DIRECTION,
&dvalue, 0);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
@@ -1235,51 +1227,51 @@ asynStatus Orca::writeInt32(asynUser* pasynUser, epicsInt32 value) {
}
//-- Trigger
else if (index == hTriggerSource) {
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TRIGGERSOURCE, &dvalue);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TRIGGERSOURCE, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
} else if (index == hTriggerMode) {
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TRIGGER_MODE, &dvalue);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TRIGGER_MODE, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
} else if (index == hTriggerActive) {
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TRIGGERACTIVE, &dvalue);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TRIGGERACTIVE, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
} else if (index == hTriggerGlobalExposure) {
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TRIGGER_GLOBALEXPOSURE,
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TRIGGER_GLOBALEXPOSURE,
&dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
} else if (index == hTriggerPolarity) {
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TRIGGERPOLARITY, &dvalue);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TRIGGERPOLARITY, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
} else if (index == hTriggerConnector) {
m_err =
m_err =
dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TRIGGER_CONNECTOR, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
} else if (index == hTriggerTimes) {
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TRIGGERTIMES, &dvalue);
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TRIGGERTIMES, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
} else if (index == hInternalTriggerHandling) {
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_INTERNALTRIGGER_HANDLING,
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_INTERNALTRIGGER_HANDLING,
&dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
@@ -1303,8 +1295,8 @@ asynStatus Orca::writeInt32(asynUser* pasynUser, epicsInt32 value) {
status = setIntegerParam(hImageFramebytes, dFrameBytes);
status = setIntegerParam(hBinning, dbinning);
} else if (index == hSubarrayMode) {
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYMODE, &dvalue);
} else if (index == hSubarrayMode) {
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_SUBARRAYMODE, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
@@ -1315,19 +1307,19 @@ asynStatus Orca::writeInt32(asynUser* pasynUser, epicsInt32 value) {
else if (index == hDefectCorrectMode) {
m_err =
dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_DEFECTCORRECT_MODE, &dvalue);
if (failed(m_err)) {
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
} else if (index == hHotPixelCorrectLevel) {
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_HOTPIXELCORRECT_LEVEL,
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_HOTPIXELCORRECT_LEVEL,
&dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
} else if (index == hIntensityLutMode) {
m_err =
m_err =
dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_INTENSITYLUT_MODE, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
@@ -1337,21 +1329,21 @@ asynStatus Orca::writeInt32(asynUser* pasynUser, epicsInt32 value) {
//-- Output trigger
else if (index == hOutputTriggerSource0) {
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_SOURCE,
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_SOURCE,
&dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
} else if (index == hOutputTriggerSource1) {
m_err = dcamprop_setgetvalue(
m_err = dcamprop_setgetvalue(
m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_SOURCE + 0x100, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
} else if (index == hOutputTriggerSource2) {
m_err = dcamprop_setgetvalue(
m_err = dcamprop_setgetvalue(
m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_SOURCE + 0x200, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
@@ -1360,21 +1352,21 @@ asynStatus Orca::writeInt32(asynUser* pasynUser, epicsInt32 value) {
}
else if (index == hOutputTriggerPolarity0) {
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_POLARITY,
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_POLARITY,
&dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
} else if (index == hOutputTriggerPolarity1) {
m_err = dcamprop_setgetvalue(
m_err = dcamprop_setgetvalue(
m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_POLARITY + 0x100, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
} else if (index == hOutputTriggerPolarity2) {
m_err = dcamprop_setgetvalue(
m_err = dcamprop_setgetvalue(
m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_POLARITY + 0x200, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
@@ -1383,49 +1375,49 @@ asynStatus Orca::writeInt32(asynUser* pasynUser, epicsInt32 value) {
}
else if (index == hOutputTriggerKind0) {
m_err =
m_err =
dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_KIND, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
} else if (index == hOutputTriggerKind1) {
m_err = dcamprop_setgetvalue(
m_err = dcamprop_setgetvalue(
m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_KIND + 0x100, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
} else if (index == hOutputTriggerKind2) {
m_err = dcamprop_setgetvalue(
m_err = dcamprop_setgetvalue(
m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_KIND + 0x200, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
} else if (index == hOutputTriggerBaseSensor0) {
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_BASESENSOR,
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_BASESENSOR,
&dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
} else if (index == hOutputTriggerBaseSensor1) {
m_err = dcamprop_setgetvalue(
m_err = dcamprop_setgetvalue(
m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_BASESENSOR + 0x100, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
} else if (index == hOutputTriggerBaseSensor2) {
m_err = dcamprop_setgetvalue(
m_err = dcamprop_setgetvalue(
m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_BASESENSOR + 0x200, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
} else if (index == hOutputTriggerPreHsyncCount) {
m_err = dcamprop_setgetvalue(
m_err = dcamprop_setgetvalue(
m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_PREHSYNCCOUNT, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
@@ -1435,14 +1427,14 @@ asynStatus Orca::writeInt32(asynUser* pasynUser, epicsInt32 value) {
//-- Master pulse
else if (index == hMasterPulseMode) {
m_err =
m_err =
dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_MASTERPULSE_MODE, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
} else if (index == hMasterPulseTriggerSource) {
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_MASTERPULSE_TRIGGERSOURCE,
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_MASTERPULSE_TRIGGERSOURCE,
&dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
@@ -1451,7 +1443,7 @@ asynStatus Orca::writeInt32(asynUser* pasynUser, epicsInt32 value) {
}
else if (index == hMasterPulseBurstTimes) {
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_MASTERPULSE_BURSTTIMES,
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_MASTERPULSE_BURSTTIMES,
&dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
@@ -1461,7 +1453,7 @@ asynStatus Orca::writeInt32(asynUser* pasynUser, epicsInt32 value) {
//-- Synchronous timing - nothing to implement either is in writeFloat64
//-- System information
else if (index == hBitPerChannel) {
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_BITSPERCHANNEL, &dvalue);
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);
@@ -1469,7 +1461,7 @@ asynStatus Orca::writeInt32(asynUser* pasynUser, epicsInt32 value) {
}
else if (index == hImagePixelType) {
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_IMAGE_PIXELTYPE, &dvalue);
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);
@@ -1479,7 +1471,7 @@ asynStatus Orca::writeInt32(asynUser* pasynUser, epicsInt32 value) {
else {
if (index < FIRST_HAMA_PARAM) {
status = ADDriver::writeInt32(pasynUser, value);
}
}
}
/* Do callbacks so higher layers see any changes */
@@ -1512,7 +1504,7 @@ asynStatus Orca::writeFloat64(asynUser* pasynUser, epicsFloat64 value) {
//-- Sensor mode and speed
//-- Feature
if (index == ADAcquireTime) {
int trigger_mode = 0;
int trigger_mode = 0;
double acquire_period = 0;
status = getDoubleParam(ADAcquirePeriod, &acquire_period);
status = getIntegerParam(hTriggerSource, &trigger_mode);
@@ -1541,7 +1533,7 @@ asynStatus Orca::writeFloat64(asynUser* pasynUser, epicsFloat64 value) {
}
else if (index == ADAcquirePeriod) {
int trigger_mode = 0;
int trigger_mode = 0;
getIntegerParam(hTriggerSource, &trigger_mode);
m_err = dcamprop_getvalue(m_hdcam, DCAM_IDPROP_EXPOSURETIME, &dvalue);
@@ -1572,7 +1564,7 @@ asynStatus Orca::writeFloat64(asynUser* pasynUser, epicsFloat64 value) {
//-- Trigger
else if (index == hTriggerDelay) {
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_TRIGGERDELAY, &dvalue);
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);
@@ -1581,21 +1573,21 @@ asynStatus Orca::writeFloat64(asynUser* pasynUser, epicsFloat64 value) {
//-- Output trigger
else if (index == hOutputTriggerDelay0) {
m_err =
m_err =
dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_DELAY, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
} else if (index == hOutputTriggerDelay1) {
m_err = dcamprop_setgetvalue(
m_err = dcamprop_setgetvalue(
m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_DELAY + 0x100, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
} else if (index == hOutputTriggerDelay2) {
m_err = dcamprop_setgetvalue(
m_err = dcamprop_setgetvalue(
m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_DELAY + 0x200, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
@@ -1604,21 +1596,21 @@ asynStatus Orca::writeFloat64(asynUser* pasynUser, epicsFloat64 value) {
}
else if (index == hOutputTriggerPeriod0) {
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_PERIOD,
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_PERIOD,
&dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
} else if (index == hOutputTriggerPeriod1) {
m_err = dcamprop_setgetvalue(
m_err = dcamprop_setgetvalue(
m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_PERIOD + 0x100, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
"IDPROP:0x%08x, VALUE:%f\n", index, dvalue);
}
} else if (index == hOutputTriggerPeriod2) {
m_err = dcamprop_setgetvalue(
m_err = dcamprop_setgetvalue(
m_hdcam, DCAM_IDPROP_OUTPUTTRIGGER_PERIOD + 0x200, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
@@ -1627,7 +1619,7 @@ asynStatus Orca::writeFloat64(asynUser* pasynUser, epicsFloat64 value) {
}
//-- Master Pulse
else if (index == hMasterPulseInterval) {
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_MASTERPULSE_INTERVAL,
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_MASTERPULSE_INTERVAL,
&dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
@@ -1637,7 +1629,7 @@ asynStatus Orca::writeFloat64(asynUser* pasynUser, epicsFloat64 value) {
//-- Synchronous timing
else if (index == hInternalLineSpeed) {
m_err =
m_err =
dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_INTERNALLINESPEED, &dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
@@ -1646,7 +1638,7 @@ asynStatus Orca::writeFloat64(asynUser* pasynUser, epicsFloat64 value) {
}
else if (index == hInternalLineInterval) {
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_INTERNAL_LINEINTERVAL,
m_err = dcamprop_setgetvalue(m_hdcam, DCAM_IDPROP_INTERNAL_LINEINTERVAL,
&dvalue);
if (failed(m_err)) {
printError(m_hdcam, m_err, "dcamprop_setgetvalue()",
@@ -1657,7 +1649,7 @@ asynStatus Orca::writeFloat64(asynUser* pasynUser, epicsFloat64 value) {
else {
if (index < FIRST_HAMA_PARAM) {
status = ADDriver::writeFloat64(pasynUser, value);
}
}
}
if (status)
@@ -1678,7 +1670,7 @@ asynStatus Orca::writeFloat64(asynUser* pasynUser, epicsFloat64 value) {
//============================================================================
void Orca::report(FILE* fp, int details) {
double dvalue = 0;
fprintf(fp, "Orcamatsu Orca Flash4.0 driver\n");
fprintf(fp, "Hammamatsu Orca Flash4.0 driver\n");
if (details < 1) return;
// Sensor mode and speed
@@ -1858,16 +1850,14 @@ int Orca::connectCamera(void) {
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);
FLOW_ARGS("connecting camera %d", 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");
FLOW_ARGS("dcamapi_init() found %d device(s)", nDevices);
iDevice = 0;
}
@@ -1951,7 +1941,6 @@ asynStatus Orca::stopAcquire(void) {
printError(m_hdcam, m_err, "dcamcap_stop()");
status = asynError;
}
printf("Stop Capture\n");
freeBuffers();
return status;
@@ -1990,6 +1979,7 @@ asynStatus Orca::accessCapturedImage(HDCAM hdcam, int32 iFrame, void* buf,
int32 rowbytes, int32 cx, int32 cy,
epicsUInt32& ts_sec,
epicsUInt32& ts_microsec) {
const char* functionName = "accessCapturedImage";
DCAMERR err;
// prepare frame param
@@ -2006,7 +1996,7 @@ asynStatus Orca::accessCapturedImage(HDCAM hdcam, int32 iFrame, void* buf,
}
if (bufframe.type != DCAM_PIXELTYPE_MONO16) {
printf("not implement pixel type\n");
FLOW("not implement pixel type");
return asynError;
}
@@ -2122,6 +2112,7 @@ void Orca::printError(HDCAM hdcam, DCAMERR errid, const char* apiname,
//============================================================================
void Orca::printInfo(HDCAM hdcam) {
const char* functionName = "printInfo";
char model[256];
char cameraid[64];
char bus[64];
@@ -2135,7 +2126,7 @@ void Orca::printInfo(HDCAM hdcam) {
} 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);
FLOW_ARGS("%s (%s) on %s\n", model, cameraid, bus);
}
}