detectors/slsDetectorPackage
25
0
Fork 0
mirror of https://github.com/slsdetectorgroup/slsDetectorPackage.git synced 2025-06-13 13:27:14 +02:00
Code Issues Actions Packages Releases Activity

WIP

Browse Source
This commit is contained in:
maliakal_d
2020-06-29 17:40:41 +02:00
parent 902366fede
commit 0c045f0faa
11 changed files with 318 additions and 346 deletions
Download Patch File Download Diff File Expand all files Collapse all files

90
slsDetectorServers/ctbDetectorServer/slsDetectorFunctionList.c
View File

@ -45,6 +45,7 @@ pthread_t pthread_virtual_tid;
int virtual_status = 0; int virtual_status = 0;
int virtual_stop = 0; int virtual_stop = 0;
uint64_t virtual_pattern[MAX_PATTERN_LENGTH]; uint64_t virtual_pattern[MAX_PATTERN_LENGTH];
int64_t virtual_currentFrameNumber = 2;
#endif #endif
// 1g readout // 1g readout
@ -2304,60 +2305,59 @@ void *start_timer(void *arg) {
} }
// Send data // Send data
{ // loop over number of frames
// loop over number of frames for (int frameNr = 0; frameNr != numFrames; ++frameNr) {
for (int frameNr = 0; frameNr != numFrames; ++frameNr) {
// update the virtual stop from stop server // update the virtual stop from stop server
lockSharedMemory(thisMem); lockSharedMemory(thisMem);
virtual_stop = thisMem->stop; virtual_stop = thisMem->stop;
unlockSharedMemory(thisMem); unlockSharedMemory(thisMem);
// check if virtual_stop is high // check if virtual_stop is high
if (virtual_stop == 1) { if (virtual_stop == 1) {
break; break;
} }
// sleep for exposure time // sleep for exposure time
struct timespec begin, end; struct timespec begin, end;
clock_gettime(CLOCK_REALTIME, &begin); clock_gettime(CLOCK_REALTIME, &begin);
usleep(expUs); usleep(expUs);
int srcOffset = 0; int srcOffset = 0;
// loop packet // loop packet
for (int i = 0; i != packetsPerFrame; ++i) { for (int i = 0; i != packetsPerFrame; ++i) {
char packetData[packetSize]; char packetData[packetSize];
memset(packetData, 0, packetSize); memset(packetData, 0, packetSize);
// set header // set header
sls_detector_header *header = sls_detector_header *header = (sls_detector_header *)(packetData);
(sls_detector_header *)(packetData); header->detType = (uint16_t)myDetectorType;
header->detType = (uint16_t)myDetectorType; header->version = SLS_DETECTOR_HEADER_VERSION - 1;
header->version = SLS_DETECTOR_HEADER_VERSION - 1; header->frameNumber = virtual_currentFrameNumber;
header->frameNumber = frameNr; header->packetNumber = i;
header->packetNumber = i; header->modId = 0;
header->modId = 0; header->row = detPos[X];
header->row = detPos[X]; header->column = detPos[Y];
header->column = detPos[Y];
// fill data // fill data
memcpy(packetData + sizeof(sls_detector_header), memcpy(packetData + sizeof(sls_detector_header),
imageData + srcOffset, dataSize); imageData + srcOffset, dataSize);
srcOffset += dataSize; srcOffset += dataSize;
sendUDPPacket(0, packetData, packetSize); sendUDPPacket(0, packetData, packetSize);
} }
LOG(logINFO, ("Sent frame: %d\n", frameNr)); LOG(logINFO, ("Sent frame: %d [%lld]\n", frameNr,
clock_gettime(CLOCK_REALTIME, &end); (long long unsigned int)virtual_currentFrameNumber));
int64_t timeNs = ((end.tv_sec - begin.tv_sec) * 1E9 + clock_gettime(CLOCK_REALTIME, &end);
(end.tv_nsec - begin.tv_nsec)); int64_t timeNs =
((end.tv_sec - begin.tv_sec) * 1E9 + (end.tv_nsec - begin.tv_nsec));
// sleep for (period - exptime) // sleep for (period - exptime)
if (frameNr < numFrames) { // if there is a next frame if (frameNr < numFrames) { // if there is a next frame
if (periodNs > timeNs) { if (periodNs > timeNs) {
usleep((periodNs - timeNs) / 1000); usleep((periodNs - timeNs) / 1000);
}
} }
} }
++virtual_currentFrameNumber;
} }
closeUDPSocket(0); closeUDPSocket(0);

137
slsDetectorServers/gotthard2DetectorServer/slsDetectorFunctionList.c
View File

@ -40,6 +40,7 @@ sharedMem *thisMem;
pthread_t pthread_virtual_tid; pthread_t pthread_virtual_tid;
int virtual_status = 0; int virtual_status = 0;
int virtual_stop = 0; int virtual_stop = 0;
int64_t virtual_currentFrameNumber = 2;
#endif #endif
enum detectorSettings thisSettings = UNINITIALIZED; enum detectorSettings thisSettings = UNINITIALIZED;
@ -2321,88 +2322,84 @@ void *start_timer(void *arg) {
*((uint16_t *)(vetoData + i)) = i; *((uint16_t *)(vetoData + i)) = i;
} }
{ // loop over number of repeats
int frameHeaderNr = 0; for (int repeatNr = 0; repeatNr != numRepeats; ++repeatNr) {
// loop over number of repeats
for (int repeatNr = 0; repeatNr != numRepeats; ++repeatNr) {
struct timespec rbegin, rend; struct timespec rbegin, rend;
clock_gettime(CLOCK_REALTIME, &rbegin); clock_gettime(CLOCK_REALTIME, &rbegin);
// loop over number of frames // loop over number of frames
for (int frameNr = 0; frameNr != numFrames; ++frameNr) { for (int frameNr = 0; frameNr != numFrames; ++frameNr) {
// update the virtual stop from stop server // update the virtual stop from stop server
lockSharedMemory(thisMem); lockSharedMemory(thisMem);
virtual_stop = thisMem->stop; virtual_stop = thisMem->stop;
unlockSharedMemory(thisMem); unlockSharedMemory(thisMem);
// check if virtual_stop is high // check if virtual_stop is high
if (virtual_stop == 1) { if (virtual_stop == 1) {
break; break;
} }
// sleep for exposure time // sleep for exposure time
struct timespec begin, end; struct timespec begin, end;
clock_gettime(CLOCK_REALTIME, &begin); clock_gettime(CLOCK_REALTIME, &begin);
usleep(expUs); usleep(expUs);
// first interface // first interface
char packetData[packetsize]; char packetData[packetsize];
memset(packetData, 0, packetsize); memset(packetData, 0, packetsize);
// set header
sls_detector_header *header = (sls_detector_header *)(packetData);
header->detType = (uint16_t)myDetectorType;
header->version = SLS_DETECTOR_HEADER_VERSION - 1;
header->frameNumber = virtual_currentFrameNumber;
header->packetNumber = 0;
header->modId = 0;
header->row = detPos[X];
header->column = detPos[Y];
// fill data
memcpy(packetData + sizeof(sls_detector_header), imageData,
datasize);
// send 1 packet = 1 frame
sendUDPPacket(0, packetData, packetsize);
// second interface (veto)
char packetData2[vetopacketsize];
memset(packetData2, 0, vetopacketsize);
if (vetoEnabled && numInterfaces == 2) {
// set header // set header
sls_detector_header *header = veto_header *header = (veto_header *)(packetData2);
(sls_detector_header *)(packetData); header->frameNumber = virtual_currentFrameNumber;
header->detType = (uint16_t)myDetectorType; header->bunchId = 0;
header->version = SLS_DETECTOR_HEADER_VERSION - 1;
header->frameNumber = frameHeaderNr;
header->packetNumber = 0;
header->modId = 0;
header->row = detPos[X];
header->column = detPos[Y];
// fill data // fill data
memcpy(packetData + sizeof(sls_detector_header), imageData, memcpy(packetData2 + sizeof(veto_header), vetoData,
datasize); vetodatasize);
// send 1 packet = 1 frame // send 1 packet = 1 frame
sendUDPPacket(0, packetData, packetsize); sendUDPPacket(1, packetData2, vetopacketsize);
}
LOG(logINFO,
("Sent frame: %d (bursts: %d) [%lld]\n", frameNr, repeatNr,
(long long unsigned int)virtual_currentFrameNumber));
clock_gettime(CLOCK_REALTIME, &end);
int64_t timeNs = ((end.tv_sec - begin.tv_sec) * 1E9 +
(end.tv_nsec - begin.tv_nsec));
// second interface (veto) // sleep for (period - exptime)
char packetData2[vetopacketsize]; if (frameNr < numFrames) { // if there is a next frame
memset(packetData2, 0, vetopacketsize); if (periodNs > timeNs) {
if (vetoEnabled && numInterfaces == 2) { usleep((periodNs - timeNs) / 1000);
// set header
veto_header *header = (veto_header *)(packetData2);
header->frameNumber = frameHeaderNr;
header->bunchId = 0;
// fill data
memcpy(packetData2 + sizeof(veto_header), vetoData,
vetodatasize);
// send 1 packet = 1 frame
sendUDPPacket(1, packetData2, vetopacketsize);
}
++frameHeaderNr;
clock_gettime(CLOCK_REALTIME, &end);
LOG(logINFO,
("Sent frame: %d (bursts: %d)\n", frameNr, repeatNr));
int64_t timeNs = ((end.tv_sec - begin.tv_sec) * 1E9 +
(end.tv_nsec - begin.tv_nsec));
// sleep for (period - exptime)
if (frameNr < numFrames) { // if there is a next frame
if (periodNs > timeNs) {
usleep((periodNs - timeNs) / 1000);
}
} }
} }
clock_gettime(CLOCK_REALTIME, &rend); ++virtual_currentFrameNumber;
int64_t timeNs = ((rend.tv_sec - rbegin.tv_sec) * 1E9 + }
(rend.tv_nsec - rbegin.tv_nsec)); clock_gettime(CLOCK_REALTIME, &rend);
int64_t timeNs = ((rend.tv_sec - rbegin.tv_sec) * 1E9 +
(rend.tv_nsec - rbegin.tv_nsec));
// sleep for (repeatPeriodNs - time remaining) // sleep for (repeatPeriodNs - time remaining)
if (repeatNr < numRepeats) { // if there is a next repeat if (repeatNr < numRepeats) { // if there is a next repeat
if (repeatPeriodNs > timeNs) { if (repeatPeriodNs > timeNs) {
usleep((repeatPeriodNs - timeNs) / 1000); usleep((repeatPeriodNs - timeNs) / 1000);
}
} }
} }
} }

75
slsDetectorServers/gotthardDetectorServer/slsDetectorFunctionList.c
View File

@ -38,6 +38,7 @@ pthread_t pthread_virtual_tid;
int virtual_status = 0; int virtual_status = 0;
int virtual_stop = 0; int virtual_stop = 0;
int highvoltage = 0; int highvoltage = 0;
int64_t virtual_currentFrameNumber = 2;
#endif #endif
int detPos[2] = {}; int detPos[2] = {};
@ -1587,51 +1588,49 @@ void *start_timer(void *arg) {
} }
// Send data // Send data
{ // loop over number of frames
uint16_t frameHeaderNr = 2; for (int frameNr = 0; frameNr != numFrames; ++frameNr) {
// loop over number of frames
for (int frameNr = 0; frameNr != numFrames; ++frameNr) {
// update the virtual stop from stop server // update the virtual stop from stop server
lockSharedMemory(thisMem); lockSharedMemory(thisMem);
virtual_stop = thisMem->stop; virtual_stop = thisMem->stop;
unlockSharedMemory(thisMem); unlockSharedMemory(thisMem);
// check if virtual_stop is high // check if virtual_stop is high
if (virtual_stop == 1) { if (virtual_stop == 1) {
break; break;
} }
// sleep for exposure time // sleep for exposure time
struct timespec begin, end; struct timespec begin, end;
clock_gettime(CLOCK_REALTIME, &begin); clock_gettime(CLOCK_REALTIME, &begin);
usleep(expUs); usleep(expUs);
int srcOffset = 0; int srcOffset = 0;
// loop packet // loop packet
for (int i = 0; i != packetsPerFrame; ++i) { for (int i = 0; i != packetsPerFrame; ++i) {
char packetData[packetSize]; char packetData[packetSize];
memset(packetData, 0, packetSize); memset(packetData, 0, packetSize);
// set header // set header
*((uint16_t *)(packetData)) = frameHeaderNr; *((uint16_t *)(packetData)) = virtual_currentFrameNumber;
++frameHeaderNr; ++virtual_currentFrameNumber;
// fill data // fill data
memcpy(packetData + 4, imageData + srcOffset, dataSize); memcpy(packetData + 4, imageData + srcOffset, dataSize);
srcOffset += dataSize; srcOffset += dataSize;
sendUDPPacket(0, packetData, packetSize); sendUDPPacket(0, packetData, packetSize);
} }
LOG(logINFO, ("Sent frame: %d\n", frameNr)); LOG(logINFO,
clock_gettime(CLOCK_REALTIME, &end); ("Sent frame: %d [%d]\n", frameNr, virtual_currentFrameNumber));
int64_t timeNs = ((end.tv_sec - begin.tv_sec) * 1E9 + clock_gettime(CLOCK_REALTIME, &end);
(end.tv_nsec - begin.tv_nsec)); int64_t timeNs =
((end.tv_sec - begin.tv_sec) * 1E9 + (end.tv_nsec - begin.tv_nsec));
// sleep for (period - exptime) // sleep for (period - exptime)
if (frameNr < numFrames) { // if there is a next frame if (frameNr < numFrames) { // if there is a next frame
if (periodNs > timeNs) { if (periodNs > timeNs) {
usleep((periodNs - timeNs) / 1000); usleep((periodNs - timeNs) / 1000);
}
} }
} }
} }

7
slsDetectorServers/moenchDetectorServer/slsDetectorFunctionList.c
View File

@ -43,6 +43,7 @@ pthread_t pthread_virtual_tid;
int virtual_status = 0; int virtual_status = 0;
int virtual_stop = 0; int virtual_stop = 0;
uint64_t virtual_pattern[MAX_PATTERN_LENGTH]; uint64_t virtual_pattern[MAX_PATTERN_LENGTH];
int64_t virtual_currentFrameNumber = 2;
#endif #endif
// 1g readout // 1g readout
@ -1963,7 +1964,7 @@ void *start_timer(void *arg) {
sls_detector_header *header = (sls_detector_header *)(packetData); sls_detector_header *header = (sls_detector_header *)(packetData);
header->detType = (uint16_t)myDetectorType; header->detType = (uint16_t)myDetectorType;
header->version = SLS_DETECTOR_HEADER_VERSION - 1; header->version = SLS_DETECTOR_HEADER_VERSION - 1;
header->frameNumber = frameNr; header->frameNumber = virtual_currentFrameNumber;
header->packetNumber = i; header->packetNumber = i;
header->modId = 0; header->modId = 0;
header->row = detPos[X]; header->row = detPos[X];
@ -1976,7 +1977,8 @@ void *start_timer(void *arg) {
sendUDPPacket(0, packetData, packetSize); sendUDPPacket(0, packetData, packetSize);
} }
LOG(logINFO, ("Sent frame: %d\n", frameNr)); LOG(logINFO, ("Sent frame: %d [%lld]\n", frameNr,
(long long unsigned int)virtual_currentFrameNumber));
clock_gettime(CLOCK_REALTIME, &end); clock_gettime(CLOCK_REALTIME, &end);
int64_t timeNs = int64_t timeNs =
((end.tv_sec - begin.tv_sec) * 1E9 + (end.tv_nsec - begin.tv_nsec)); ((end.tv_sec - begin.tv_sec) * 1E9 + (end.tv_nsec - begin.tv_nsec));
@ -1987,6 +1989,7 @@ void *start_timer(void *arg) {
usleep((periodNs - timeNs) / 1000); usleep((periodNs - timeNs) / 1000);
} }
} }
++virtual_currentFrameNumber;
} }
closeUDPSocket(0); closeUDPSocket(0);

7
slsDetectorServers/mythen3DetectorServer/slsDetectorFunctionList.c
View File

@ -38,6 +38,7 @@ sharedMem *thisMem;
pthread_t pthread_virtual_tid; pthread_t pthread_virtual_tid;
int virtual_status = 0; int virtual_status = 0;
int virtual_stop = 0; int virtual_stop = 0;
int64_t virtual_currentFrameNumber = 2;
#endif #endif
sls_detector_module *detectorModules = NULL; sls_detector_module *detectorModules = NULL;
@ -2073,7 +2074,7 @@ void *start_timer(void *arg) {
sls_detector_header *header = (sls_detector_header *)(packetData); sls_detector_header *header = (sls_detector_header *)(packetData);
header->detType = (uint16_t)myDetectorType; header->detType = (uint16_t)myDetectorType;
header->version = SLS_DETECTOR_HEADER_VERSION - 1; header->version = SLS_DETECTOR_HEADER_VERSION - 1;
header->frameNumber = frameNr + 1; header->frameNumber = virtual_currentFrameNumber;
header->packetNumber = i; header->packetNumber = i;
header->modId = 0; header->modId = 0;
header->row = detPos[X]; header->row = detPos[X];
@ -2086,7 +2087,8 @@ void *start_timer(void *arg) {
sendUDPPacket(0, packetData, packetSize); sendUDPPacket(0, packetData, packetSize);
} }
LOG(logINFO, ("Sent frame: %d\n", frameNr)); LOG(logINFO, ("Sent frame: %d [%lld]\n", frameNr,
(long long unsigned int)virtual_currentFrameNumber));
clock_gettime(CLOCK_REALTIME, &end); clock_gettime(CLOCK_REALTIME, &end);
int64_t timeNs = int64_t timeNs =
((end.tv_sec - begin.tv_sec) * 1E9 + (end.tv_nsec - begin.tv_nsec)); ((end.tv_sec - begin.tv_sec) * 1E9 + (end.tv_nsec - begin.tv_nsec));
@ -2097,6 +2099,7 @@ void *start_timer(void *arg) {
usleep((periodNs - timeNs) / 1000); usleep((periodNs - timeNs) / 1000);
} }
} }
++virtual_currentFrameNumber;
} }
closeUDPSocket(0); closeUDPSocket(0);

2
slsDetectorServers/slsDetectorServer/include/slsDetectorServer_funcs.h
View File

@ -36,6 +36,7 @@ int set_firmware_test(int);
int set_bus_test(int); int set_bus_test(int);
int set_image_test_mode(int); int set_image_test_mode(int);
int get_image_test_mode(int); int get_image_test_mode(int);
enum DACINDEX getDACIndex(enum dacIndex ind);
int set_dac(int); int set_dac(int);
int get_adc(int); int get_adc(int);
int write_register(int); int write_register(int);
@ -43,6 +44,7 @@ int read_register(int);
int set_module(int); int set_module(int);
int set_settings(int); int set_settings(int);
int get_threshold_energy(int); int get_threshold_energy(int);
int start_state_machine(int blocking, int file_des);
int start_acquisition(int); int start_acquisition(int);
int stop_acquisition(int); int stop_acquisition(int);
int get_run_status(int); int get_run_status(int);

309
slsDetectorServers/slsDetectorServer/src/slsDetectorServer_funcs.c
View File

@ -710,20 +710,8 @@ int get_image_test_mode(int file_des) {
return Server_SendResult(file_des, INT32, &retval, sizeof(retval)); return Server_SendResult(file_des, INT32, &retval, sizeof(retval));
} }
int set_dac(int file_des) { enum DACINDEX getDACIndex(enum dacIndex ind) {
ret = OK;
memset(mess, 0, sizeof(mess));
int args[3] = {-1, -1, -1};
int retval = -1;
if (receiveData(file_des, args, sizeof(args), INT32) < 0)
return printSocketReadError();
enum dacIndex ind = args[0];
int mV = args[1];
int val = args[2];
enum DACINDEX serverDacIndex = 0; enum DACINDEX serverDacIndex = 0;
// check if dac exists for this detector // check if dac exists for this detector
switch (ind) { switch (ind) {
#ifdef GOTTHARDD #ifdef GOTTHARDD
@ -1000,6 +988,22 @@ int set_dac(int file_des) {
modeNotImplemented("Dac Index", (int)ind); modeNotImplemented("Dac Index", (int)ind);
break; break;
} }
return serverDacIndex;
}
int set_dac(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
int args[3] = {-1, -1, -1};
int retval = -1;
if (receiveData(file_des, args, sizeof(args), INT32) < 0)
return printSocketReadError();
enum dacIndex ind = args[0];
int mV = args[1];
int val = args[2];
enum DACINDEX serverDacIndex = getDACIndex(ind);
// index exists // index exists
if (ret == OK) { if (ret == OK) {
@ -1647,11 +1651,14 @@ int get_threshold_energy(int file_des) {
return Server_SendResult(file_des, INT32, &retval, sizeof(retval)); return Server_SendResult(file_des, INT32, &retval, sizeof(retval));
} }
int start_acquisition(int file_des) { int start_state_machine(int blocking, int file_des) {
ret = OK; ret = OK;
memset(mess, 0, sizeof(mess)); memset(mess, 0, sizeof(mess));
if (blocking) {
LOG(logDEBUG1, ("Starting Acquisition\n")); LOG(logINFOBLUE, ("Blocking Acquisition\n"));
} else {
LOG(logINFOBLUE, ("Unblocking Acquisition\n"));
}
// only set // only set
if (Server_VerifyLock() == OK) { if (Server_VerifyLock() == OK) {
#if defined(MOENCHD) #if defined(MOENCHD)
@ -1723,21 +1730,27 @@ int start_acquisition(int file_des) {
} }
for (int i = 0; i != times; ++i) { for (int i = 0; i != times; ++i) {
if (scanTrimbits) { if (scanTrimbits) {
LOG(logINFOBLUE, ("Trimbits scan %d/%d: [%d]\n", i, times,
scanSteps[i]));
#ifdef EIGERD #ifdef EIGERD
setAllTrimbits(scanSteps[i]); setAllTrimbits(scanSteps[i]);
#else #else
LOG(logERROR, ("trimbit scan not implemented!\n")); LOG(logERROR, ("trimbit scan not implemented!\n"));
#endif #endif
} else { } else if (numScanSteps > 0) {
setDac(scanDac, scanSteps[i], 0); LOG(logINFOBLUE, ("Dac [%d] scan %d/%d: [%d]\n", scanDac, i,
times, scanSteps[i]));
setDAC(scanDac, scanSteps[i], 0);
int retval = getDAC(scanDac, 0); int retval = getDAC(scanDac, 0);
if (abs(retval - val) > 5) { if (abs(retval - scanSteps[i]) > 5) {
ret = FAIL; ret = FAIL;
sprintf(mess, "Setting dac %d : wrote %d but read %d\n", sprintf(mess, "Setting dac %d : wrote %d but read %d\n",
dacIndex, scanSteps[i], retval); scanDac, scanSteps[i], scanSteps[i]);
LOG(logERROR, (mess)); LOG(logERROR, (mess));
break; break;
} }
} else {
LOG(logINFOBLUE, ("Normal Acquisition (not scan)\n"));
} }
ret = startStateMachine(); ret = startStateMachine();
if (ret == FAIL) { if (ret == FAIL) {
@ -1752,6 +1765,10 @@ int start_acquisition(int file_des) {
LOG(logERROR, (mess)); LOG(logERROR, (mess));
break; break;
} }
// blocking or scan
if (blocking || times > 1) {
readFrame(&ret, mess);
}
} }
} }
LOG(logDEBUG2, ("Starting Acquisition ret: %d\n", ret)); LOG(logDEBUG2, ("Starting Acquisition ret: %d\n", ret));
@ -1759,6 +1776,8 @@ int start_acquisition(int file_des) {
return Server_SendResult(file_des, INT32, NULL, 0); return Server_SendResult(file_des, INT32, NULL, 0);
} }
int start_acquisition(int file_des) { return start_state_machine(0, file_des); }
int stop_acquisition(int file_des) { int stop_acquisition(int file_des) {
ret = OK; ret = OK;
memset(mess, 0, sizeof(mess)); memset(mess, 0, sizeof(mess));
@ -1789,98 +1808,7 @@ int get_run_status(int file_des) {
} }
int start_and_read_all(int file_des) { int start_and_read_all(int file_des) {
ret = OK; return start_state_machine(1, file_des);
memset(mess, 0, sizeof(mess));
LOG(logDEBUG1, ("Starting Acquisition and read all frames\n"));
// start state machine
LOG(logDEBUG1, ("Starting Acquisition\n"));
// only set
if (Server_VerifyLock() == OK) {
#if defined(MOENCHD)
if (getNumAnalogSamples() <= 0) {
ret = FAIL;
sprintf(mess,
"Could not start acquisition. Invalid number of analog "
"samples: %d.\n",
getNumAnalogSamples());
LOG(logERROR, (mess));
} else
#endif
#if defined(CHIPTESTBOARDD)
if ((getReadoutMode() == ANALOG_AND_DIGITAL ||
getReadoutMode() == ANALOG_ONLY) &&
(getNumAnalogSamples() <= 0)) {
ret = FAIL;
sprintf(mess,
"Could not start acquisition. Invalid number of analog "
"samples: %d.\n",
getNumAnalogSamples());
LOG(logERROR, (mess));
} else if ((getReadoutMode() == ANALOG_AND_DIGITAL ||
getReadoutMode() == DIGITAL_ONLY) &&
(getNumDigitalSamples() <= 0)) {
ret = FAIL;
sprintf(mess,
"Could not start acquisition. Invalid number of digital "
"samples: %d.\n",
getNumDigitalSamples());
LOG(logERROR, (mess));
} else
#endif
#ifdef EIGERD
// check for hardware mac and hardware ip
if (udpDetails.srcmac != getDetectorMAC()) {
ret = FAIL;
uint64_t sourcemac = getDetectorMAC();
char src_mac[50];
getMacAddressinString(src_mac, 50, sourcemac);
sprintf(mess,
"Invalid udp source mac address for this detector. Must be "
"same as hardware detector mac address %s\n",
src_mac);
LOG(logERROR, (mess));
} else if (!enableTenGigabitEthernet(GET_FLAG) &&
(udpDetails.srcip != getDetectorIP())) {
ret = FAIL;
uint32_t sourceip = getDetectorIP();
char src_ip[INET_ADDRSTRLEN];
getIpAddressinString(src_ip, sourceip);
sprintf(
mess,
"Invalid udp source ip address for this detector. Must be same "
"as hardware detector ip address %s in 1G readout mode \n",
src_ip);
LOG(logERROR, (mess));
} else
#endif
if (configured == FAIL) {
ret = FAIL;
strcpy(mess, "Could not start acquisition because ");
strcat(mess, configureMessage);
LOG(logERROR, (mess));
} else {
ret = startStateMachine();
if (ret == FAIL) {
#if defined(VIRTUAL) || defined(CHIPTESTBOARDD) || defined(MOENCHD)
sprintf(mess,
"Could not start acquisition. Could not create udp "
"socket in server. Check udp_dstip & udp_dstport.\n");
#else
sprintf(mess, "Could not start acquisition\n");
#endif
LOG(logERROR, (mess));
}
}
LOG(logDEBUG2, ("Starting Acquisition ret: %d\n", ret));
}
// lock or acquisition start error
if (ret == FAIL)
return Server_SendResult(file_des, INT32, NULL, 0);
// read all (again validate lock, but should pass and not fail)
return read_all(file_des);
} }
int read_all(int file_des) { int read_all(int file_des) {
@ -7542,7 +7470,8 @@ int disable_scan(int file_des) {
free(scanSteps); free(scanSteps);
scanSteps = NULL; scanSteps = NULL;
} }
setNumFrames(1); int64_t arg = 1;
setNumFrames(arg);
int64_t retval = getNumFrames(); int64_t retval = getNumFrames();
LOG(logDEBUG1, ("retval num frames %lld\n", (long long int)retval)); LOG(logDEBUG1, ("retval num frames %lld\n", (long long int)retval));
validate64(arg, retval, "set number of frames", DEC); validate64(arg, retval, "set number of frames", DEC);
@ -7564,89 +7493,125 @@ int enable_scan(int file_des) {
int endOffset = args[2]; int endOffset = args[2];
int stepSize = args[3]; int stepSize = args[3];
scanTrimbits = 0; scanTrimbits = 0;
// trimbit scan
if (args[0] == TRIMBIT_SCAN) { if ((startOffset < endOffset && stepSize <= 0) ||
#ifdef EIGERD (endOffset < startOffset && stepSize >= 0)) {
if (startOffset < 0 || startOffset > MAX_TRIMBITS_VALUE ||
endOffset < 0 || endOffset > MAX_TRIMBITS_VALUE) {
ret = FAIL;
sprintf(mess, "Invalid trimbits scan values\n");
LOG(logERROR, (mess));
} else {
scanTrimbits = 1;
// changes settings to undefined
setSettings(UNDEFINED);
LOG(logERROR,
("Settings has been changed to undefined (change all "
"trimbits)\n"));
}
#else
ret = FAIL; ret = FAIL;
sprintf(mess, "Cannot enable trimbit scan. Not implemented for " sprintf(mess, "Invalid scan parameters\n");
"this detector\n");
LOG(logERROR, (mess)); LOG(logERROR, (mess));
#endif
} else { } else {
ret = converttodac(args[0], &scanDac); // trimbit scan
if (ret == FAIL) { if (args[0] == TRIMBIT_SCAN) {
sprintf(mess,
"Cannot enable scan. Dac index %d not implemented for "
"this detector\n",
args[0]);
LOG(logERROR, (mess));
} else if (startOffset < 0 || startOffset > getMaxDacSteps() ||
endOffset < 0 || endOffset > getMaxDacSteps()) {
ret = FAIL;
sprintf(mess, "Invalid dac scan values\n");
LOG(logERROR, (mess));
}
#if defined(CHIPTESTBOARDD) || defined(MOENCHD)
else if (checkVLimitDacCompliant(startOffset) == FAIL ||
checkVLimitDacCompliant(endOffset) == FAIL) {
ret = FAIL;
sprintf(mess,
"Invalid scan dac values."
"Exceeds voltage limit %d.\n",
getVLimit());
LOG(logERROR, (mess));
}
#endif
#ifdef EIGERD #ifdef EIGERD
if (ret == OK) { if (startOffset < 0 || startOffset > MAX_TRIMBITS_VALUE ||
// changing dac changes settings to undefined endOffset < 0 || endOffset > MAX_TRIMBITS_VALUE) {
switch (scanDac) { ret = FAIL;
case E_VCMP_LL: sprintf(mess, "Invalid trimbits scan values\n");
case E_VCMP_LR: LOG(logERROR, (mess));
case E_VCMP_RL: } else {
case E_VCMP_RR: scanTrimbits = 1;
case E_VRPREAMP: LOG(logINFOBLUE, ("Trimbit scan enabled\n"));
case E_VCP: // changes settings to undefined
setSettings(UNDEFINED); setSettings(UNDEFINED);
LOG(logERROR, ("Settings has been changed " LOG(logERROR,
"to undefined (changed specific dacs)\n")); ("Settings has been changed to undefined (change all "
"trimbits)\n"));
}
#else
ret = FAIL;
sprintf(mess, "Cannot enable trimbit scan. Not implemented for "
"this detector\n");
LOG(logERROR, (mess));
#endif
} else {
switch ((enum dacIndex)args[0]) {
case HIGH_VOLTAGE:
#ifdef EIGERD
case IO_DELAY:
#elif CHIPTESTBOARDD
case ADC_VPP:
case V_POWER_A:
case V_POWER_B:
case V_POWER_C:
case V_POWER_D:
case V_POWER_IO:
case V_POWER_CHIP:
case V_LIMIT:
#elif MOENCHD
case ADC_VPP:
case V_LIMIT:
#endif
modeNotImplemented("Scan Dac Index", args[0]);
break; break;
default: default:
break; break;
} }
} scanDac = getDACIndex(args[0]);
if (ret == FAIL) {
sprintf(
mess,
"Cannot enable scan. Dac index %d not implemented for "
"this detector for scanning\n",
args[0]);
LOG(logERROR, (mess));
} else if (startOffset < 0 || startOffset > getMaxDacSteps() ||
endOffset < 0 || endOffset > getMaxDacSteps()) {
ret = FAIL;
sprintf(mess, "Invalid dac scan values\n");
LOG(logERROR, (mess));
}
#if defined(CHIPTESTBOARDD) || defined(MOENCHD)
else if (checkVLimitDacCompliant(startOffset) == FAIL ||
checkVLimitDacCompliant(endOffset) == FAIL) {
ret = FAIL;
sprintf(mess,
"Invalid scan dac values."
"Exceeds voltage limit %d.\n",
getVLimit());
LOG(logERROR, (mess));
}
#endif #endif
if (ret == OK) {
#ifdef EIGERD
// changing dac changes settings to undefined
switch (scanDac) {
case E_VCMP_LL:
case E_VCMP_LR:
case E_VCMP_RL:
case E_VCMP_RR:
case E_VRPREAMP:
case E_VCP:
setSettings(UNDEFINED);
LOG(logERROR,
("Settings has been changed "
"to undefined (changed specific dacs)\n"));
break;
default:
break;
}
#endif
LOG(logINFOBLUE, ("Dac [%d] scan enabled\n", scanDac));
}
}
} }
if (ret == OK) { if (ret == OK) {
scan = 1; scan = 1;
numScanSteps = ((startOffset - endOffset) / stepSize) + 1; numScanSteps = (abs(endOffset - startOffset) / abs(stepSize)) + 1;
if (scanSteps != NULL) { if (scanSteps != NULL) {
free(scanSteps); free(scanSteps);
} }
scanSteps = malloc(numScanSteps * sizeof(int)); scanSteps = malloc(numScanSteps * sizeof(int));
for (int i = 0; i != numScanSteps; ++i) { for (int i = 0; i != numScanSteps; ++i) {
scanSteps[i] = startOffset + i * stepSize; scanSteps[i] = startOffset + i * stepSize;
LOG(logDEBUG1, ("scansteps[%d]:%d\n", i, scanSteps[i]));
} }
LOG(logINFOBLUE, LOG(logINFOBLUE,
("Enabling scan for dac[%d], start[%d], end[%d], " ("Enabling scan for dac[%d], start[%d], end[%d], "
"stepsize[%d], nsteps[%d]\n", "stepsize[%d], nsteps[%d]\n",
ind, startOffset, endOffset, stepSize, numScanSteps)); scanDac, startOffset, endOffset, stepSize, numScanSteps));
setNumFrames(1); int64_t arg = 1;
setNumFrames(arg);
int64_t retval = getNumFrames(); int64_t retval = getNumFrames();
LOG(logDEBUG1, ("retval num frames %lld\n", (long long int)retval)); LOG(logDEBUG1, ("retval num frames %lld\n", (long long int)retval));
validate64(arg, retval, "set number of frames", DEC); validate64(arg, retval, "set number of frames", DEC);

16
slsDetectorSoftware/src/CmdProxy.cpp
View File

@ -997,8 +997,10 @@ std::string CmdProxy::Scan(int action) {
if (action == defs::HELP_ACTION) { if (action == defs::HELP_ACTION) {
os << "[dac_name|0|trimbit_scan] [start_val] [stop_val] " os << "[dac_name|0|trimbit_scan] [start_val] [stop_val] "
"[step_size]\n\tConfigures to scan " "[step_size]\n\tConfigures to scan "
"dac. Must acquire after this. To cancel the scan configuration " "dac and sets number of frames to number of steps. Must acquire "
"set dac to '0' without further arguments." "after this. To cancel the scan configuration "
"set dac to '0' without further arguments. This also sets number "
"of frames back to 1."
"\n\t[Eiger]Use trimbit_scan as dac name for a trimbit scan." "\n\t[Eiger]Use trimbit_scan as dac name for a trimbit scan."
<< '\n'; << '\n';
} else if (action == defs::GET_ACTION) { } else if (action == defs::GET_ACTION) {
@ -1014,12 +1016,12 @@ std::string CmdProxy::Scan(int action) {
} else if (args.size() != 4) { } else if (args.size() != 4) {
WrongNumberOfParameters(4); WrongNumberOfParameters(4);
} else { } else {
auto t = det->enableScan( det->enableScan(StringTo<defs::dacIndex>(args[0]),
StringTo<defs::dacIndex>(args[0]), StringTo<int>(args[1]), StringTo<int>(args[1]), StringTo<int>(args[2]),
StringTo<int>(args[2]), StringTo<int>(args[3])); StringTo<int>(args[3]));
auto nsteps = det->getNumScanSteps().tsquash( auto nsteps = det->getNumberOfScanSteps().tsquash(
"inconsistent number of scan steps"); "inconsistent number of scan steps");
os << "scan enabled for " << nsteps << "steps" << '\n'; os << "scan enabled for " << nsteps << " steps" << '\n';
} }
} else { } else {
throw sls::RuntimeError("Unknown action"); throw sls::RuntimeError("Unknown action");

13
slsDetectorSoftware/src/Detector.cpp
View File

@ -562,25 +562,26 @@ void Detector::sendSoftwareTrigger(Positions pos) {
pimpl->Parallel(&Module::sendSoftwareTrigger, pos); pimpl->Parallel(&Module::sendSoftwareTrigger, pos);
} }
Result<bool> getScan(Positions pos = {}) const { Result<bool> Detector::getScan(Positions pos) const {
return pimpl->Parallel(&Module::getScan, pos); return pimpl->Parallel(&Module::getScan, pos);
} }
Result<int> getNumberOfScanSteps(Positions pos = {}) const { Result<int> Detector::getNumberOfScanSteps(Positions pos) const {
return pimpl->Parallel(&Module::getNumberOfScanSteps, pos); return pimpl->Parallel(&Module::getNumberOfScanSteps, pos);
} }
void disableScan() { void Detector::disableScan() {
pimpl->Parallel(&Module::disableScan); pimpl->Parallel(&Module::disableScan, {});
setNumberOfFrames(1); setNumberOfFrames(1);
} }
void Detector::enableScan(const defs::dacIndex dac, const int start_offset, void Detector::enableScan(const defs::dacIndex dac, const int start_offset,
const int end_offset, const int step_size) { const int end_offset, const int step_size) {
pimpl->Parallel(&Module::scan, start_offset, end_offset, step_size, {-1}); pimpl->Parallel(&Module::enableScan, {}, dac, start_offset, end_offset,
step_size);
auto t = auto t =
getNumberOfScanSteps().tsquash("inconsistent number of scan steps"); getNumberOfScanSteps().tsquash("inconsistent number of scan steps");
setNumberOfFrames(nsteps); setNumberOfFrames(t);
} }
// Network Configuration (Detector<->Receiver) // Network Configuration (Detector<->Receiver)

4
slsDetectorSoftware/src/Module.cpp
View File

@ -451,11 +451,11 @@ void Module::setStartingFrameNumber(uint64_t value) {
void Module::sendSoftwareTrigger() { sendToDetectorStop(F_SOFTWARE_TRIGGER); } void Module::sendSoftwareTrigger() { sendToDetectorStop(F_SOFTWARE_TRIGGER); }
bool Module::getScan() const { bool Module::getScan() {
return static_cast<bool>(sendToDetector<int>(F_GET_SCAN)); return static_cast<bool>(sendToDetector<int>(F_GET_SCAN));
} }
int Module::getNumberOfScanSteps() const { int Module::getNumberOfScanSteps() {
return sendToDetector<int>(F_GET_NUM_SCAN_STEPS); return sendToDetector<int>(F_GET_NUM_SCAN_STEPS);
} }

4
slsDetectorSoftware/src/Module.h
View File

@ -167,8 +167,8 @@ class Module : public virtual slsDetectorDefs {
uint64_t getStartingFrameNumber(); uint64_t getStartingFrameNumber();
void setStartingFrameNumber(uint64_t value); void setStartingFrameNumber(uint64_t value);
void sendSoftwareTrigger(); void sendSoftwareTrigger();
bool getScan() const; bool getScan();
int getNumberOfScanSteps() const; int getNumberOfScanSteps();
void disableScan(); void disableScan();
void enableScan(const defs::dacIndex dac, const int start_offset, void enableScan(const defs::dacIndex dac, const int start_offset,
const int end_offset, const int step_size); const int end_offset, const int step_size);