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

Gappixels (#89)

Browse Source 
* WIP

* WIP virtual delays, imagetest for saturation

* WIP, vertical and horizontal

* WIP

* gap pixels work, fixed 32 bit data out (10gbe=0) for virtual servers

* quad works (also in virtual), handling gappixels and quad

* jungfrau gapppixels work

* jungfrau: done

* complete image or missing packets given in json header and gui

* eiger virtual 4 bit mode bug fix

* working version of zmq add json header, except printout

* printout bug

* fix for json para

* to map WIP

* map done

* map print , mapwith result left

* json result works, testing added

* updated server binaries

* compiling on rhels7, variable size char array iniitalization

* zmqsocket parsing didnt need Document

* const to map, json para is strings not map

* json add header: mapping cleaner without insert make_pair
This commit is contained in:
Dhanya Thattil
2020-03-30 14:54:35 +02:00
committed by GitHub
parent 6a6af528ef
commit d58eb1dc6e
52 changed files with 1879 additions and 1398 deletions
Download Patch File Download Diff File Expand all files Collapse all files

49
slsDetectorServers/eigerDetectorServer/CMakeLists.txt
View File

@ -22,7 +22,7 @@ target_include_directories(eigerDetectorServerMaster_virtual
target_compile_definitions(eigerDetectorServerMaster_virtual
PUBLIC EIGERD PCCOMPILE STOP_SERVER
PUBLIC VIRTUAL DVIRTUAL_9M
PUBLIC VIRTUAL #VIRTUAL_9M
PUBLIC VIRTUAL_MASTER
)
@ -38,27 +38,60 @@ install(TARGETS eigerDetectorServerMaster_virtual
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
)
add_executable(eigerDetectorServerSlave_virtual
add_executable(eigerDetectorServerSlaveTop_virtual
${src}
)
target_include_directories(eigerDetectorServerSlave_virtual
target_include_directories(eigerDetectorServerSlaveTop_virtual
PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}
)
target_compile_definitions(eigerDetectorServerSlave_virtual
target_compile_definitions(eigerDetectorServerSlaveTop_virtual
PUBLIC EIGERD PCCOMPILE STOP_SERVER
PUBLIC VIRTUAL DVIRTUAL_9M
PUBLIC VIRTUAL #VIRTUAL_9M
PUBLIC VIRTUAL_TOP
)
target_link_libraries(eigerDetectorServerSlave_virtual
target_link_libraries(eigerDetectorServerSlaveTop_virtual
PUBLIC pthread rt
)
set_target_properties(eigerDetectorServerSlave_virtual PROPERTIES
set_target_properties(eigerDetectorServerSlaveTop_virtual PROPERTIES
RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
)
install(TARGETS eigerDetectorServerSlave_virtual
install(TARGETS eigerDetectorServerSlaveTop_virtual
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
)
add_executable(eigerDetectorServerSlaveBottom_virtual
${src}
)
target_include_directories(eigerDetectorServerSlaveBottom_virtual
PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}
)
target_compile_definitions(eigerDetectorServerSlaveBottom_virtual
PUBLIC EIGERD PCCOMPILE STOP_SERVER
PUBLIC VIRTUAL #VIRTUAL_9M
)
target_link_libraries(eigerDetectorServerSlaveBottom_virtual
PUBLIC pthread rt
)
set_target_properties(eigerDetectorServerSlaveBottom_virtual PROPERTIES
RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
)
install(TARGETS eigerDetectorServerSlaveBottom_virtual
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
)

BIN
slsDetectorServers/eigerDetectorServer/bin/eigerDetectorServer_developer
View File

Binary file not shown.

221
slsDetectorServers/eigerDetectorServer/slsDetectorFunctionList.c
View File

@ -20,6 +20,7 @@
// Global variable from slsDetectorServer_funcs
extern int debugflag;
extern udpStruct udpDetails;
extern const enum detectorType myDetectorType;
// Global variable from communication_funcs.c
extern int isControlServer;
@ -88,6 +89,8 @@ pthread_t eiger_virtual_tid;
int eiger_virtual_stop = 0;
uint64_t eiger_virtual_startingframenumber = 0;
int eiger_virtual_detPos[2] = {0, 0};
int eiger_virtual_test_mode = 0;
int eiger_virtual_quad_mode = 0;
#endif
@ -179,8 +182,23 @@ void basictests() {
LOG(logINFO, ("Compatibility - success\n"));
}
#ifdef VIRTUAL
void setTestImageMode(int ival) {
if (ival >= 0) {
if (ival == 0) {
LOG(logINFO, ("Switching off Image Test Mode\n"));
eiger_virtual_test_mode = 0;
} else {
LOG(logINFO, ("Switching on Image Test Mode\n"));
eiger_virtual_test_mode = 1;
}
}
}
int getTestImageMode() {
return eiger_virtual_test_mode;
}
#endif
/* Ids */
@ -361,7 +379,11 @@ void getModuleConfiguration() {
top = 1;
#else
master = 0;
#ifdef VIRTUAL_TOP
top = 1;
#else
top = 0;
#endif
#endif
#ifdef VIRTUAL_9M
normal = 0;
@ -1291,13 +1313,15 @@ int setQuad(int value) {
if (!Feb_Control_SetQuad(value)) {
return FAIL;
}
#else
eiger_virtual_quad_mode = value;
#endif
return OK;
}
int getQuad() {
#ifdef VIRTUAL
return 0;
return eiger_virtual_quad_mode;
#else
return Beb_GetQuad();
#endif
@ -1779,95 +1803,144 @@ void* start_timer(void* arg) {
int numPacketsPerFrame = (tgEnable ? 4 : 16) * dr;
int npixelsx = 256 * 2 * bytesPerPixel;
int databytes = 256 * 256 * 2 * bytesPerPixel;
LOG(logINFO, (" dr:%f\n bytesperpixel:%d\n tgenable:%d\n datasize:%d\n packetsize:%d\n numpackes:%d\n npixelsx:%d\n databytes:%d\n",
dr, bytesPerPixel, tgEnable, datasize, packetsize, numPacketsPerFrame, npixelsx, databytes));
int row = eiger_virtual_detPos[0];
int colLeft = top ? eiger_virtual_detPos[1] : eiger_virtual_detPos[1] + 1;
int colRight = top ? eiger_virtual_detPos[1] + 1 : eiger_virtual_detPos[1];
int ntotpixels = 256 * 256 * 4;
LOG(logINFO, (" dr:%d\n bytesperpixel:%f\n tgenable:%d\n datasize:%d\n packetsize:%d\n numpackes:%d\n npixelsx:%d\n databytes:%d\n ntotpixels:%d\n",
dr, bytesPerPixel, tgEnable, datasize, packetsize, numPacketsPerFrame, npixelsx, databytes, ntotpixels));
//TODO: Generate data
char imageData[databytes * 2];
memset(imageData, 0, databytes * 2);
{
int i = 0;
for (i = 0; i < databytes * 2; i += sizeof(uint8_t)) {
*((uint8_t*)(imageData + i)) = i;
}
}
//TODO: Send data
{
int frameNr = 1;
for(frameNr=1; frameNr <= numFrames; ++frameNr ) {
//check if virtual_stop is high
if(eiger_virtual_stop == 1){
break;
//TODO: Generate data
char imageData[databytes * 2];
memset(imageData, 0, databytes * 2);
{
int i = 0;
switch (dr) {
case 4:
for (i = 0; i < ntotpixels/2; ++i) {
*((uint8_t*)(imageData + i)) = eiger_virtual_test_mode ? 0xEE : (uint8_t)(((2 * i & 0xF) << 4) | ((2 * i + 1) & 0xF));
}
break;
case 8:
for (i = 0; i < ntotpixels; ++i) {
*((uint8_t*)(imageData + i)) = eiger_virtual_test_mode ? 0xFE : (uint8_t)i;
}
break;
case 16:
for (i = 0; i < ntotpixels; ++i) {
*((uint16_t*)(imageData + i * sizeof(uint16_t))) = eiger_virtual_test_mode ? 0xFFE : (uint16_t)i;
}
break;
case 32:
for (i = 0; i < ntotpixels; ++i) {
*((uint32_t*)(imageData + i * sizeof(uint32_t))) = eiger_virtual_test_mode ? 0xFFFFFE : (uint32_t)i;
}
break;
default:
break;
}
}
//TODO: Send data
{
int frameNr = 1;
for(frameNr=1; frameNr <= numFrames; ++frameNr ) {
int srcOffset = 0;
int srcOffset2 = npixelsx;
usleep(eiger_virtual_transmission_delay_frame);
//check if virtual_stop is high
if(eiger_virtual_stop == 1){
break;
}
int srcOffset = 0;
int srcOffset2 = npixelsx;
struct timespec begin, end;
clock_gettime(CLOCK_REALTIME, &begin);
usleep(exp_us);
char packetData[packetsize];
memset(packetData, 0, packetsize);
char packetData2[packetsize];
memset(packetData2, 0, packetsize);
struct timespec begin, end;
clock_gettime(CLOCK_REALTIME, &begin);
usleep(exp_us);
char packetData[packetsize];
memset(packetData, 0, packetsize);
char packetData2[packetsize];
memset(packetData2, 0, packetsize);
// loop packet
{
int i = 0;
for(i = 0; i != numPacketsPerFrame; ++i) {
int dstOffset = sizeof(sls_detector_header);
int dstOffset2 = sizeof(sls_detector_header);
// set header
sls_detector_header* header = (sls_detector_header*)(packetData);
header->frameNumber = frameNr;
header->packetNumber = i;
header = (sls_detector_header*)(packetData2);
header->frameNumber = frameNr;
header->packetNumber = i;
// loop packet
{
int i = 0;
for(i = 0; i != numPacketsPerFrame; ++i) {
int dstOffset = sizeof(sls_detector_header);
int dstOffset2 = sizeof(sls_detector_header);
// set header
sls_detector_header* header = (sls_detector_header*)(packetData);
header->detType = 3;//(uint16_t)myDetectorType; updated when firmware updates
header->version = SLS_DETECTOR_HEADER_VERSION - 1;
header->frameNumber = frameNr;
header->packetNumber = i;
header->row = row;
header->column = colLeft;
// fill data
{
int psize = 0;
for (psize = 0; psize < datasize; psize += npixelsx) {
header = (sls_detector_header*)(packetData2);
header->detType = (uint16_t)myDetectorType;
header->version = SLS_DETECTOR_HEADER_VERSION - 1;
header->frameNumber = frameNr;
header->packetNumber = i;
header->row = row;
header->column = colRight;
if (eiger_virtual_quad_mode) {
header->row = 1; // right is next row
header->column = 0; // right same first column
}
if (dr == 32 && tgEnable == 0) {
memcpy(packetData + dstOffset, imageData + srcOffset, npixelsx/2);
memcpy(packetData2 + dstOffset2, imageData + srcOffset2, npixelsx/2);
// fill data
{
int psize = 0;
for (psize = 0; psize < datasize; psize += npixelsx) {
if (dr == 32 && tgEnable == 0) {
memcpy(packetData + dstOffset, imageData + srcOffset, npixelsx/2);
memcpy(packetData2 + dstOffset2, imageData + srcOffset2, npixelsx/2);
if (srcOffset % npixelsx == 0) {
srcOffset += npixelsx/2;
srcOffset2 += npixelsx/2;
}
// skip the other half (2 packets in 1 line for 32 bit)
else {
srcOffset += npixelsx;
srcOffset2 += npixelsx;
dstOffset += npixelsx/2;
dstOffset2 += npixelsx/2;
} else {
memcpy(packetData + dstOffset, imageData + srcOffset, npixelsx);
memcpy(packetData2 + dstOffset2, imageData + srcOffset2, npixelsx);
srcOffset += 2 * npixelsx;
srcOffset2 += 2 * npixelsx;
dstOffset += npixelsx;
dstOffset2 += npixelsx;
srcOffset2 += npixelsx;
}
dstOffset += npixelsx/2;
dstOffset2 += npixelsx/2;
} else {
memcpy(packetData + dstOffset, imageData + srcOffset, npixelsx);
memcpy(packetData2 + dstOffset2, imageData + srcOffset2, npixelsx);
srcOffset += 2 * npixelsx;
srcOffset2 += 2 * npixelsx;
dstOffset += npixelsx;
dstOffset2 += npixelsx;
}
}
sendUDPPacket(0, packetData, packetsize);
sendUDPPacket(1, packetData2, packetsize);
}
usleep(eiger_virtual_transmission_delay_left);
sendUDPPacket(0, packetData, packetsize);
usleep(eiger_virtual_transmission_delay_right);
sendUDPPacket(1, packetData2, packetsize);
}
LOG(logINFO, ("Sent frame: %d\n", frameNr));
clock_gettime(CLOCK_REALTIME, &end);
int64_t time_ns = ((end.tv_sec - begin.tv_sec) * 1E9 +
(end.tv_nsec - begin.tv_nsec));
}
LOG(logINFO, ("Sent frame: %d\n", frameNr));
clock_gettime(CLOCK_REALTIME, &end);
int64_t time_ns = ((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 > time_ns) {
usleep((periodns - time_ns)/ 1000);
}
// sleep for (period - exptime)
if (frameNr < numFrames) { // if there is a next frame
if (periodns > time_ns) {
usleep((periodns - time_ns)/ 1000);
}
}
}
}
closeUDPSocket(0);
closeUDPSocket(1);