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

changes for jungfrau new header

Browse Source
This commit is contained in:
Dhanya Maliakal
2017-05-15 15:00:04 +02:00
parent 476f3162af
commit 205a3780d5
4 changed files with 120 additions and 124 deletions
Download Patch File Download Diff File Expand all files Collapse all files

104
slsReceiverSoftware/include/GeneralData.h
View File

@ -78,6 +78,10 @@ public:
/** Streaming (for ROI - mainly short Gotthard) - Image size (in bytes) */ /** Streaming (for ROI - mainly short Gotthard) - Image size (in bytes) */
uint32_t imageSize_Streamer; uint32_t imageSize_Streamer;
/** emptybuffer (mainly for jungfrau) */
uint32_t emptyHeader;
/** Cosntructor */ /** Cosntructor */
GeneralData(): GeneralData():
myDetectorType(slsReceiverDefs::GENERIC), myDetectorType(slsReceiverDefs::GENERIC),
@ -100,7 +104,8 @@ public:
headerPacketSize(0), headerPacketSize(0),
nPixelsX_Streamer(0), nPixelsX_Streamer(0),
nPixelsY_Streamer(0), nPixelsY_Streamer(0),
imageSize_Streamer(0) imageSize_Streamer(0),
emptyHeader(0)
{}; {};
/** Destructor */ /** Destructor */
@ -167,26 +172,27 @@ public:
std::string temp = slsReceiverDefs::getDetectorType(myDetectorType); std::string temp = slsReceiverDefs::getDetectorType(myDetectorType);
printf("\n\nDetector Data Variables:\n"); printf("\n\nDetector Data Variables:\n");
printf( "myDetectorType:%s\n" printf( "myDetectorType:%s\n"
"Pixels X: %d\n" "Pixels X: %u\n"
"Pixels Y: %d\n" "Pixels Y: %u\n"
"Header Size in Packet: %d\n" "Header Size in Packet: %u\n"
"Data Size: %d\n" "Data Size: %u\n"
"Packet Size: %d\n" "Packet Size: %u\n"
"Packets per Frame: %d\n" "Packets per Frame: %u\n"
"Image Size: %d\n" "Image Size: %u\n"
"Frame Index Mask: 0x%llx\n" "Frame Index Mask: 0x%llx\n"
"Frame Index Offset: %d\n" "Frame Index Offset: %u\n"
"Packet Index Mask: 0x%x\n" "Packet Index Mask: 0x%x\n"
"Packet Index Offset: %d\n" "Packet Index Offset: %u\n"
"Max Frames Per File: %d\n" "Max Frames Per File: %u\n"
"Fifo Buffer Size: %d\n" "Fifo Buffer Size: %u\n"
"Fifo Buffer Header Size: %d\n" "Fifo Buffer Header Size: %u\n"
"Default Fifo Depth: %d\n" "Default Fifo Depth: %u\n"
"Threads Per Receiver: %d\n" "Threads Per Receiver: %u\n"
"Header Packet Size: %d\n" "Header Packet Size: %u\n"
"Streamer Pixels X: %d\n" "Streamer Pixels X: %u\n"
"Streamer Pixels Y: %d\n" "Streamer Pixels Y: %u\n"
"Streamer Image Size: %d\n" "Streamer Image Size: %u\n"
"Empty Header: %u\n"
,temp.c_str(),//.c_str() modifies, using temp string for thread safety ,temp.c_str(),//.c_str() modifies, using temp string for thread safety
nPixelsX, nPixelsX,
nPixelsY, nPixelsY,
@ -207,7 +213,8 @@ public:
headerPacketSize, headerPacketSize,
nPixelsX_Streamer, nPixelsX_Streamer,
nPixelsY_Streamer, nPixelsY_Streamer,
imageSize_Streamer); imageSize_Streamer,
emptyHeader);
}; };
}; };
@ -436,22 +443,8 @@ class JCTBData : public GeneralData {
class JungfrauData : public GeneralData { class JungfrauData : public GeneralData {
private:
/** Structure of an jungfrau packet header */
typedef struct {
unsigned char emptyHeader[6];
unsigned char reserved[4];
unsigned char packetNumber[1];
unsigned char frameNumber[3];
unsigned char bunchid[8];
} jfrau_packet_header_t;
public: public:
/** Size of packet header */
const static uint32_t packetHeaderSize = 22;
/** Constructor */ /** Constructor */
JungfrauData(){ JungfrauData(){
myDetectorType = slsReceiverDefs::JUNGFRAU; myDetectorType = slsReceiverDefs::JUNGFRAU;
@ -469,50 +462,9 @@ private:
nPixelsX_Streamer = nPixelsX; nPixelsX_Streamer = nPixelsX;
nPixelsY_Streamer = nPixelsY; nPixelsY_Streamer = nPixelsY;
imageSize_Streamer = imageSize; imageSize_Streamer = imageSize;
emptyHeader = 6;
}; };
/**
* Get Header Infomation (frame number, packet number)
* @param index thread index for debugging purposes
* @param packetData pointer to data
* @param frameNumber frame number
* @param packetNumber packet number
*/
virtual void GetHeaderInfo(int index, char* packetData, uint64_t& frameNumber, uint32_t& packetNumber) const
{
jfrau_packet_header_t* header = (jfrau_packet_header_t*)(packetData);
frameNumber = (uint64_t)(*( (uint32_t*) header->frameNumber));
packetNumber = packetsPerFrame -1 - (uint32_t)(*( (uint8_t*) header->packetNumber));
}
/**
* Get Header Infomation (frame number, packet number)
* @param index thread index for debugging purposes
* @param packetData pointer to data
* @param dynamicRange dynamic range to assign subframenumber if 32 bit mode
* @param frameNumber frame number
* @param packetNumber packet number
* @param subFrameNumber sub frame number if applicable
* @param bunchId bunch id
*/
void GetHeaderInfo(int index, char* packetData, uint32_t dynamicRange,
uint64_t& frameNumber, uint32_t& packetNumber, uint32_t& subFrameNumber, uint64_t& bunchId) const
{
subFrameNumber = -1;
jfrau_packet_header_t* header = (jfrau_packet_header_t*)(packetData);
frameNumber = (uint64_t)(*( (uint32_t*) header->frameNumber));
packetNumber = packetsPerFrame - 1 -(uint32_t)(*( (uint8_t*) header->packetNumber));//old firmware (not needed in new firmware)
bunchId = (*((uint64_t*) header->bunchid));
}
/**
* Print all variables
*/
void Print() const {
GeneralData::Print();
printf("Packet Header Size: %d\n",packetHeaderSize);
}
}; };

6
slsReceiverSoftware/include/Listener.h
View File

@ -21,6 +21,7 @@ class Listener : private virtual slsReceiverDefs, public ThreadObject {
/** /**
* Constructor * Constructor
* Calls Base Class CreateThread(), sets ErrorMask if error and increments NumberofListerners * Calls Base Class CreateThread(), sets ErrorMask if error and increments NumberofListerners
* @param dtype detector type
* @param f address of Fifo pointer * @param f address of Fifo pointer
* @param s pointer to receiver status * @param s pointer to receiver status
* @param portno pointer to udp port number * @param portno pointer to udp port number
@ -29,7 +30,7 @@ class Listener : private virtual slsReceiverDefs, public ThreadObject {
* @param nf pointer to number of images to catch * @param nf pointer to number of images to catch
* @param dr pointer to dynamic range * @param dr pointer to dynamic range
*/ */
Listener(Fifo*& f, runStatus* s, uint32_t* portno, char* e, int* act, uint64_t* nf, uint32_t* dr); Listener(detectorType dtype, Fifo*& f, runStatus* s, uint32_t* portno, char* e, int* act, uint64_t* nf, uint32_t* dr);
/** /**
* Destructor * Destructor
@ -213,6 +214,9 @@ class Listener : private virtual slsReceiverDefs, public ThreadObject {
// individual members // individual members
/** Detector Type */
detectorType myDetectorType;
/** Aquisition Started flag */ /** Aquisition Started flag */
bool acquisitionStartedFlag; bool acquisitionStartedFlag;

132
slsReceiverSoftware/src/Listener.cpp
View File

@ -27,10 +27,11 @@ uint64_t Listener::RunningMask(0x0);
pthread_mutex_t Listener::Mutex = PTHREAD_MUTEX_INITIALIZER; pthread_mutex_t Listener::Mutex = PTHREAD_MUTEX_INITIALIZER;
Listener::Listener(Fifo*& f, runStatus* s, uint32_t* portno, char* e, int* act, uint64_t* nf, uint32_t* dr) : Listener::Listener(detectorType dtype, Fifo*& f, runStatus* s, uint32_t* portno, char* e, int* act, uint64_t* nf, uint32_t* dr) :
ThreadObject(NumberofListeners), ThreadObject(NumberofListeners),
generalData(0), generalData(0),
fifo(f), fifo(f),
myDetectorType(dtype),
acquisitionStartedFlag(false), acquisitionStartedFlag(false),
measurementStartedFlag(false), measurementStartedFlag(false),
status(s), status(s),
@ -150,8 +151,8 @@ void Listener::ResetParametersforNewMeasurement(){
memset(carryOverPacket,0,generalData->packetSize); memset(carryOverPacket,0,generalData->packetSize);
if (listeningPacket) if (listeningPacket)
delete [] listeningPacket; delete [] listeningPacket;
listeningPacket = new char[generalData->packetSize]; listeningPacket = new char[generalData->packetSize + generalData->emptyHeader];
memset(listeningPacket,0,generalData->packetSize); memset(listeningPacket,0,generalData->packetSize + generalData->emptyHeader);
} }
@ -265,7 +266,20 @@ void Listener::ThreadExecution() {
if (rc <= 0) { if (rc <= 0) {
if (carryOverFlag) { if (carryOverFlag) {
uint64_t fnum=0;uint32_t pnum=0; uint64_t fnum=0;uint32_t pnum=0;
generalData->GetHeaderInfo(index, carryOverPacket, fnum, pnum);
// -------------------------- new header -------------------------------------------------
if (myDetectorType == JUNGFRAU) {
sls_detector_header* header = (sls_detector_header*) (carryOverPacket);
fnum = header->frameNumber;
pnum = header->packetNumber;
}
// -------------------old header -------------------------------------------------
else {
generalData->GetHeaderInfo(index, carryOverPacket, fnum, pnum);
}
//---------------------------------------------------------------------------------------
if (fnum < currentFrameIndex) if (fnum < currentFrameIndex)
cprintf(BG_RED,"Error:(Weird Early self shut down), Frame number less than current frame number\n"); cprintf(BG_RED,"Error:(Weird Early self shut down), Frame number less than current frame number\n");
}else }else
@ -302,19 +316,30 @@ uint32_t Listener::ListenToAnImage(char* buf) {
uint32_t pnum = 0, snum = 0; uint32_t pnum = 0, snum = 0;
int dsize = generalData->dataSize; int dsize = generalData->dataSize;
bool isHeaderEmpty = true; bool isHeaderEmpty = true;
sls_detector_header* header = 0;
//only for jungfrau as we look only at pnum
uint32_t expectpnum = 0;
//reset to -1 //reset to -1
memset(buf + generalData->fifoBufferHeaderSize, 0xFF, dsize); memset(buf + generalData->fifoBufferHeaderSize, 0xFF, dsize);
//look for carry over //look for carry over
if (carryOverFlag) {if(!index) cprintf(RED,"carry flag\n"); if (carryOverFlag) {
if(!index) cprintf(RED,"carry flag\n");
//check if its the current image packet //check if its the current image packet
generalData->GetHeaderInfo(index, carryOverPacket, *dynamicRange, fnum, pnum, snum, bid); // -------------------------- new header ----------------------------------------------------------------------
if (myDetectorType == JUNGFRAU) {
header = (sls_detector_header*) (carryOverPacket);
fnum = header->frameNumber;
pnum = header->packetNumber;
}
// -------------------old header -----------------------------------------------------------------------------
else {
generalData->GetHeaderInfo(index, carryOverPacket, *dynamicRange, fnum, pnum, snum, bid);
}
//------------------------------------------------------------------------------------------------------------
if (fnum != currentFrameIndex) { if (fnum != currentFrameIndex) {
if (fnum < currentFrameIndex) if (fnum < currentFrameIndex)
return 0; return 0;
@ -324,24 +349,30 @@ uint32_t Listener::ListenToAnImage(char* buf) {
memcpy(buf + generalData->fifoBufferHeaderSize + (pnum * dsize), carryOverPacket + generalData->headerSizeinPacket, dsize); memcpy(buf + generalData->fifoBufferHeaderSize + (pnum * dsize), carryOverPacket + generalData->headerSizeinPacket, dsize);
//writer header //writer header
if(isHeaderEmpty) { if(isHeaderEmpty) {
sls_detector_header* header = (sls_detector_header*) (buf + FIFO_HEADER_NUMBYTES); // -------------------------- new header ----------------------------------------------------------------------
memset(header, 0, sizeof(sls_detector_header)); if (myDetectorType == JUNGFRAU) {
header->frameNumber = fnum; memcpy(buf + FIFO_HEADER_NUMBYTES, header, sizeof(sls_detector_header));
if (generalData->myDetectorType == EIGER && *dynamicRange == 32) }
header->expLength = snum; // -------------------old header ------------------------------------------------------------------------------
header->packetNumber = generalData->packetsPerFrame; /*in the end..*/ else {
if (generalData->myDetectorType == JUNGFRAU) header = (sls_detector_header*) (buf + FIFO_HEADER_NUMBYTES);
header->bunchId = bid; memset(header, 0, sizeof(sls_detector_header));
/*header->xCoord = index; given by det packet, also for ycoord, zcoord */ header->frameNumber = fnum;
header->detType = (uint8_t) generalData->myDetectorType; /*given by det packet */ if (generalData->myDetectorType == EIGER && *dynamicRange == 32)
header->version = (uint8_t) SLS_DETECTOR_HEADER_VERSION; header->expLength = snum;
header->packetNumber = generalData->packetsPerFrame; /*in the end..*/
/*header->xCoord = index; given by det packet, also for ycoord, zcoord */
header->detType = (uint8_t) generalData->myDetectorType; /*given by det packet */
header->version = (uint8_t) SLS_DETECTOR_HEADER_VERSION;
}
//------------------------------------------------------------------------------------------------------------
isHeaderEmpty = false; isHeaderEmpty = false;
} }
expectpnum = pnum+1; //for jungfrau
} }
//until last packet isHeaderEmpty to account for gotthard short frame, else never entering this loop) //until last packet isHeaderEmpty to account for gotthard short frame, else never entering this loop)
while ( isHeaderEmpty || (pnum < (generalData->packetsPerFrame-1))) { while ( isHeaderEmpty || (pnum < (generalData->packetsPerFrame-1))) {
@ -359,28 +390,32 @@ uint32_t Listener::ListenToAnImage(char* buf) {
//update parameters //update parameters
numPacketsCaught++; //record immediately to get more time before socket shutdown numPacketsCaught++; //record immediately to get more time before socket shutdown
numTotalPacketsCaught++; numTotalPacketsCaught++;
generalData->GetHeaderInfo(index, listeningPacket, *dynamicRange, fnum, pnum, snum, bid);
// -------------------------- new header ----------------------------------------------------------------------
if (myDetectorType == JUNGFRAU) {
listeningPacket += generalData->emptyHeader;
header = (sls_detector_header*) (listeningPacket);
fnum = header->frameNumber;
pnum = header->packetNumber;
}
// -------------------old header -----------------------------------------------------------------------------
else {
generalData->GetHeaderInfo(index, listeningPacket, *dynamicRange, fnum, pnum, snum, bid);
}
//------------------------------------------------------------------------------------------------------------
lastCaughtFrameIndex = fnum; lastCaughtFrameIndex = fnum;
#ifdef VERBOSE #ifdef VERBOSE
//if (!index) //if (!index)
cprintf(GREEN,"Listening %d: fnum:%lu, pnum:%d\n", index,fnum, pnum); cprintf(GREEN,"Listening %d: fnum:%lu, pnum:%d\n", index,fnum, pnum);
#endif #endif
if (!measurementStartedFlag) if (!measurementStartedFlag)
RecordFirstIndices(fnum); RecordFirstIndices(fnum);
//future packet (jungfrau) look at packet numbers
if (generalData->myDetectorType == JUNGFRAU) {
if (pnum < expectpnum) {
cprintf(RED,"setting carry over flag to true\n");
carryOverFlag = true;
memcpy(carryOverPacket,listeningPacket, generalData->packetSize);
return generalData->imageSize;
}
}
//future packet by looking at image number (all other detectors) //future packet by looking at image number (all other detectors)
else if (fnum != currentFrameIndex) { if (fnum != currentFrameIndex) {
cprintf(RED,"setting carry over flag to true\n"); cprintf(RED,"setting carry over flag to true\n");
carryOverFlag = true; carryOverFlag = true;
memcpy(carryOverPacket,listeningPacket, generalData->packetSize); memcpy(carryOverPacket,listeningPacket, generalData->packetSize);
@ -390,20 +425,25 @@ uint32_t Listener::ListenToAnImage(char* buf) {
//copy packet //copy packet
memcpy(buf + generalData->fifoBufferHeaderSize + (pnum * dsize), listeningPacket + generalData->headerSizeinPacket, dsize); memcpy(buf + generalData->fifoBufferHeaderSize + (pnum * dsize), listeningPacket + generalData->headerSizeinPacket, dsize);
if(isHeaderEmpty) { if(isHeaderEmpty) {
sls_detector_header* header = (sls_detector_header*) (buf + FIFO_HEADER_NUMBYTES); // -------------------------- new header ----------------------------------------------------------------------
memset(header, 0, sizeof(sls_detector_header)); if (myDetectorType == JUNGFRAU) {
header->frameNumber = fnum; memcpy(buf + FIFO_HEADER_NUMBYTES, header, sizeof(sls_detector_header));
if (generalData->myDetectorType == EIGER && *dynamicRange == 32) }
header->expLength = snum; // -------------------old header ------------------------------------------------------------------------------
header->packetNumber = generalData->packetsPerFrame; /*in the end..*/ else {
if (generalData->myDetectorType == JUNGFRAU) header = (sls_detector_header*) (buf + FIFO_HEADER_NUMBYTES);
header->bunchId = bid; memset(header, 0, sizeof(sls_detector_header));
/*header->xCoord = index; given by det packet, also for ycoord, zcoord */ header->frameNumber = fnum;
header->detType = (uint8_t) generalData->myDetectorType; /*given by det packet */ if (generalData->myDetectorType == EIGER && *dynamicRange == 32)
header->version = (uint8_t) SLS_DETECTOR_HEADER_VERSION; header->expLength = snum;
header->packetNumber = generalData->packetsPerFrame; /*in the end..*/
/*header->xCoord = index; given by det packet, also for ycoord, zcoord */
header->detType = (uint8_t) generalData->myDetectorType; /*given by det packet */
header->version = (uint8_t) SLS_DETECTOR_HEADER_VERSION;
}
//------------------------------------------------------------------------------------------------------------
isHeaderEmpty = false; isHeaderEmpty = false;
} }
expectpnum = pnum+1; //for jungfrau
} }
return generalData->imageSize; return generalData->imageSize;

2
slsReceiverSoftware/src/UDPStandardImplementation.cpp
View File

@ -370,7 +370,7 @@ int UDPStandardImplementation::setDetectorType(const detectorType d) {
//create threads //create threads
for ( int i=0; i < numThreads; ++i ) { for ( int i=0; i < numThreads; ++i ) {
listener.push_back(new Listener(fifo[i], &status, &udpPortNum[i], eth, &activated, &numberOfFrames, &dynamicRange)); listener.push_back(new Listener(myDetectorType, fifo[i], &status, &udpPortNum[i], eth, &activated, &numberOfFrames, &dynamicRange));
dataProcessor.push_back(new DataProcessor(fifo[i], &fileFormatType, &fileWriteEnable, &dataStreamEnable, dataProcessor.push_back(new DataProcessor(fifo[i], &fileFormatType, &fileWriteEnable, &dataStreamEnable,
rawDataReadyCallBack,pRawDataReady)); rawDataReadyCallBack,pRawDataReady));
if (Listener::GetErrorMask() || DataProcessor::GetErrorMask()) { if (Listener::GetErrorMask() || DataProcessor::GetErrorMask()) {