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

gotthard server fix: problem for new board due to component version change

Browse Source 
git-svn-id: file:///afs/psi.ch/project/sls_det_software/svn/slsDetectorSoftware@675 951219d9-93cf-4727-9268-0efd64621fa3
This commit is contained in:
l_maliakal_d
2013-10-02 14:20:44 +00:00
parent fbf853ea20
commit eba9bcf9ac
8 changed files with 650 additions and 345 deletions
Download Patch File Download Diff File Expand all files Collapse all files

133
slsDetectorSoftware/gotthardDetectorServer/firmware_funcs.c
View File

@ -1813,35 +1813,114 @@ int allocateRAM() {
}
int prepareADC(){
printf("Preparing ADC\n");
u_int32_t valw,codata,csmask;
int i,cdx,ddx;
cdx=0; ddx=1;
csmask=0x7c; // 1111100
codata=0;
codata=(0x14<<8)+(0x0); //command and value;
valw=0xff; bus_w(ADC_WRITE_REG,(valw)); // start point
valw=((0xffffffff&(~csmask)));bus_w(ADC_WRITE_REG,valw); //chip sel bar down
for (i=0;i<24;i++) {
valw=valw&(~(0x1<<cdx));bus_w(ADC_WRITE_REG,valw);usleep(0); //cldwn
#ifdef VERBOSE
printf("DOWN 0x%x \n",valw);
#endif
valw=(valw&(~(0x1<<ddx)))+(((codata>>(23-i))&0x1)<<ddx); bus_w(ADC_WRITE_REG,valw); usleep(0); //write data (i)
#ifdef VERBOSE
printf("LOW 0x%x \n",valw);
#endif
valw=valw+(0x1<<cdx);bus_w(ADC_WRITE_REG,valw); usleep(0); //clkup
#ifdef VERBOSE
printf("up 0x%x \n",valw);
#endif
}
printf("Preparing ADC\n");
u_int32_t valw,codata,csmask;
int i,j,cdx,ddx,value;
cdx=0; ddx=1;
csmask=0x7c; // 1111100
valw=valw&(~(0x1<<cdx));usleep(0);
valw=0xff; bus_w(ADC_WRITE_REG,(valw)); // stop point =start point */
for(j=0;j<3;j++){
//command and value;
codata = 0;
if(j==0)
codata=(0x08<<8)+(0x3);//Power modes(global) //reset
else if(j==1)
codata=(0x08<<8)+(0x0);//Power modes(global) //chip run
else
codata = (0x14<<8)+(0x0);//Output mode //offset binary
return;
// start point
valw=0xff;
bus_w(ADC_WRITE_REG,(valw));
//chip sel bar down
valw=((0xffffffff&(~csmask)));
bus_w(ADC_WRITE_REG,valw);
for (i=0;i<24;i++) {
//cldwn
valw=valw&(~(0x1<<cdx));
bus_w(ADC_WRITE_REG,valw);
usleep(0);
//write data (i)
valw=(valw&(~(0x1<<ddx)))+(((codata>>(23-i))&0x1)<<ddx);
bus_w(ADC_WRITE_REG,valw);
usleep(0);
//clkup
valw=valw+(0x1<<cdx);
bus_w(ADC_WRITE_REG,valw);
usleep(0);
}
// stop point =start point
valw=valw&(~(0x1<<cdx));
usleep(0);
valw=0xff;
bus_w(ADC_WRITE_REG,(valw));
//usleep in between
usleep(50000);
}
return OK;
/*
codata=0;
codata=(0x14<<8)+(0x0); //command and value;
valw=0xff; bus_w(ADC_WRITE_REG,(valw)); // start point
valw=((0xffffffff&(~csmask)));bus_w(ADC_WRITE_REG,valw); //chip sel bar down
for (i=0;i<24;i++) {
valw=valw&(~(0x1<<cdx));bus_w(ADC_WRITE_REG,valw);usleep(0); //cldwn
valw=(valw&(~(0x1<<ddx)))+(((codata>>(23-i))&0x1)<<ddx); bus_w(ADC_WRITE_REG,valw); usleep(0); //write data (i)
valw=valw+(0x1<<cdx);bus_w(ADC_WRITE_REG,valw); usleep(0); //clkup
}
valw=valw&(~(0x1<<cdx));usleep(0);
valw=0xff; bus_w(ADC_WRITE_REG,(valw)); // stop point =start point
usleep(5000);
codata=0;
codata=(0x08<<8)+(0x3); //command and value;Power modes(global) reset
valw=0xff; bus_w(ADC_WRITE_REG,(valw)); // start point
valw=((0xffffffff&(~csmask)));bus_w(ADC_WRITE_REG,valw); //chip sel bar down
for (i=0;i<24;i++) {
valw=valw&(~(0x1<<cdx));bus_w(ADC_WRITE_REG,valw);usleep(0); //cldwn
valw=(valw&(~(0x1<<ddx)))+(((codata>>(23-i))&0x1)<<ddx); bus_w(ADC_WRITE_REG,valw); usleep(0); //write data (i)
valw=valw+(0x1<<cdx);bus_w(ADC_WRITE_REG,valw); usleep(0); //clkup
}
valw=valw&(~(0x1<<cdx));usleep(0);
valw=0xff; bus_w(ADC_WRITE_REG,(valw)); // stop point =start point
usleep(50000);
codata=0;
codata=(0x08<<8)+(0x0); //command and value;Power modes(global) reset
valw=0xff; bus_w(ADC_WRITE_REG,(valw)); // start point
valw=((0xffffffff&(~csmask)));bus_w(ADC_WRITE_REG,valw); //chip sel bar down
for (i=0;i<24;i++) {
valw=valw&(~(0x1<<cdx));bus_w(ADC_WRITE_REG,valw);usleep(0); //cldwn
valw=(valw&(~(0x1<<ddx)))+(((codata>>(23-i))&0x1)<<ddx); bus_w(ADC_WRITE_REG,valw); usleep(0); //write data (i)
valw=valw+(0x1<<cdx);bus_w(ADC_WRITE_REG,valw); usleep(0); //clkup
}
valw=valw&(~(0x1<<cdx));usleep(0);
valw=0xff; bus_w(ADC_WRITE_REG,(valw)); // stop point =start point
*/
}

12
slsDetectorSoftware/slsDetector/slsDetectorUsers.cpp
View File

@ -153,28 +153,28 @@ int slsDetectorUsers::setBeamEnergy(int e_eV){
}
double slsDetectorUsers::setExposureTime(double t, bool inseconds){
int64_t tms = t * (1E+9);
int64_t tms = (int64_t)(t * (1E+9));
if (t < 0) tms = -1;
if(!inseconds)
return myDetector->setExposureTime(t);
return myDetector->setExposureTime((int64_t)t);
else
return ((1E-9) * (double)myDetector->setExposureTime(tms));
}
double slsDetectorUsers::setExposurePeriod(double t, bool inseconds){
int64_t tms = t * (1E+9);
int64_t tms = (int64_t)(t * (1E+9));
if (t < 0) tms = -1;
if(!inseconds)
return myDetector->setExposurePeriod(t);
return myDetector->setExposurePeriod((int64_t)t);
else
return ((1E-9) * (double)myDetector->setExposurePeriod(tms));
}
double slsDetectorUsers::setDelayAfterTrigger(double t, bool inseconds){
int64_t tms = t * (1E+9);
int64_t tms = (int64_t)(t * (1E+9));
if (t < 0) tms = -1;
if(!inseconds)
return myDetector->setDelayAfterTrigger(t);
return myDetector->setDelayAfterTrigger((int64_t)t);
else
return ((1E-9) * (double)myDetector->setDelayAfterTrigger(tms));
}

2
slsDetectorSoftware/slsReceiver/Makefile
View File

@ -7,7 +7,7 @@ LDFLAG= -L/usr/lib64/ -lpthread -lm -lstdc++
LIBS?= -L$(LIBDIR) -lSlsDetector
INCLUDES ?= -I ../MySocketTCP -I ../commonFiles -I -I ../slsDetectorAnalysis -I .
SRC_CLNT = slsReceiver.cpp
SRC_CLNT = slsReceiver.cpp
#../MySocketTCP/MySocketTCP.cpp slsReceiver_funcs.cpp UHRIXCallback.cpp slsReceiverFunctionList.cpp slsReceiverUsers.cpp
DESTDIR ?= bin

19
slsDetectorSoftware/slsReceiver/receiver_defs.h
View File

@ -15,18 +15,24 @@
//all max frames defined in sls_detector_defs.h. 20000 gotthard, 100000 for short gotthard, 1000 for moench
#define GOTTHARD_FIFO_SIZE 25000
#define GOTTHARD_ALIGNED_FRAME_SIZE 4096
#define GOTTHARD_PACKETS_PER_FRAME 2
#define GOTTHARD_BUFFER_SIZE (1286*GOTTHARD_PACKETS_PER_FRAME)
#define GOTTHARD_DATA_BYTES (1280*GOTTHARD_PACKETS_PER_FRAME)
#define GOTTHARD_ONE_PACKET_SIZE 1286
#define GOTTHARD_BUFFER_SIZE (GOTTHARD_ONE_PACKET_SIZE*GOTTHARD_PACKETS_PER_FRAME) //1286*2
#define GOTTHARD_DATA_BYTES (1280*GOTTHARD_PACKETS_PER_FRAME) //1280*2
#define GOTTHARD_SHORT_PACKETS_PER_FRAME 1
#define GOTTHARD_SHORT_BUFFER_SIZE 518
#define GOTTHARD_SHORT_DATABYTES 512
#define GOTTHARD_SHORT_FRAME_INDEX_MASK 0xFFFFFFFF
#define GOTTHARD_SHORT_FRAME_INDEX_OFFSET 0
#define GOTTHARD_SHORT_PACKET_INDEX_MASK 0
#define GOTTHARD_FRAME_INDEX_MASK 0xFFFFFFFF
#define GOTTHARD_FRAME_INDEX_OFFSET 0
#define GOTTHARD_FRAME_INDEX_MASK 0xFFFFFFFE
#define GOTTHARD_FRAME_INDEX_OFFSET 1
#define GOTTHARD_PACKET_INDEX_MASK 0x1
@ -34,8 +40,9 @@
#define MOENCH_FIFO_SIZE 2500
#define MOENCH_ALIGNED_FRAME_SIZE 65536
#define MOENCH_PACKETS_PER_FRAME 40
#define MOENCH_BUFFER_SIZE (1286*MOENCH_PACKETS_PER_FRAME)
#define MOENCH_DATA_BYTES (1280*MOENCH_PACKETS_PER_FRAME)
#define MOENCH_ONE_PACKET_SIZE 1286
#define MOENCH_BUFFER_SIZE (MOENCH_ONE_PACKET_SIZE*MOENCH_PACKETS_PER_FRAME) //1286*40
#define MOENCH_DATA_BYTES (1280*MOENCH_PACKETS_PER_FRAME) //1280*40
#define MOENCH_BYTES_PER_ADC (40*2)
#define MOENCH_PIXELS_IN_ONE_ROW 160

549
slsDetectorSoftware/slsReceiver/slsReceiverFunctionList.cpp
View File

@ -23,48 +23,49 @@ using namespace std;
FILE* slsReceiverFunctionList::sfilefd(NULL);
int slsReceiverFunctionList::receiver_threads_running(0);
slsReceiverFunctionList::slsReceiverFunctionList(detectorType det,bool moenchwithGotthardTest):
myDetectorType(det),
maxFramesPerFile(MAX_FRAMES_PER_FILE),
enableFileWrite(1),
fileIndex(0),
frameIndexNeeded(0),
framesCaught(0),
acqStarted(false),
measurementStarted(false),
startFrameIndex(0),
frameIndex(0),
totalFramesCaught(0),
startAcquisitionIndex(0),
acquisitionIndex(0),
framesInFile(0),
prevframenum(0),
listening_thread_running(0),
writing_thread_running(0),
status(IDLE),
latestData(NULL),
udpSocket(NULL),
server_port(DEFAULT_UDP_PORTNO),
fifo(NULL),
fifofree(NULL),
fifosize(GOTTHARD_FIFO_SIZE),
shortFrame(-1),
bufferSize(GOTTHARD_BUFFER_SIZE),
packetsPerFrame(GOTTHARD_PACKETS_PER_FRAME),
guiDataReady(0),
guiData(NULL),
guiFileName(NULL),
currframenum(0),
nFrameToGui(0),
startAcquisitionCallBack(NULL),
pStartAcquisition(NULL),
acquisitionFinishedCallBack(NULL),
pAcquisitionFinished(NULL),
rawDataReadyCallBack(NULL),
pRawDataReady(NULL),
withGotthard(moenchwithGotthardTest),
frameIndexMask(GOTTHARD_FRAME_INDEX_MASK),
frameIndexOffset(GOTTHARD_FRAME_INDEX_OFFSET)
slsReceiverFunctionList::slsReceiverFunctionList(detectorType det):
myDetectorType(det),
maxFramesPerFile(MAX_FRAMES_PER_FILE),
enableFileWrite(1),
fileIndex(0),
frameIndexNeeded(0),
framesCaught(0),
acqStarted(false),
measurementStarted(false),
startFrameIndex(0),
frameIndex(0),
totalFramesCaught(0),
startAcquisitionIndex(0),
acquisitionIndex(0),
packetsInFile(0),
prevframenum(0),
listening_thread_running(0),
writing_thread_running(0),
status(IDLE),
latestData(NULL),
udpSocket(NULL),
server_port(DEFAULT_UDP_PORTNO),
fifo(NULL),
fifofree(NULL),
fifosize(GOTTHARD_FIFO_SIZE),
shortFrame(-1),
bufferSize(GOTTHARD_BUFFER_SIZE),
packetsPerFrame(GOTTHARD_PACKETS_PER_FRAME),
guiDataReady(0),
guiData(NULL),
guiFileName(NULL),
currframenum(0),
nFrameToGui(0),
frameIndexMask(GOTTHARD_FRAME_INDEX_MASK),
frameIndexOffset(GOTTHARD_FRAME_INDEX_OFFSET),
dataCompression(false),
startAcquisitionCallBack(NULL),
pStartAcquisition(NULL),
acquisitionFinishedCallBack(NULL),
pAcquisitionFinished(NULL),
rawDataReadyCallBack(NULL),
pRawDataReady(NULL)
{
@ -76,11 +77,8 @@ slsReceiverFunctionList::slsReceiverFunctionList(detectorType det,bool moenchwit
maxFramesPerFile = MOENCH_MAX_FRAMES_PER_FILE;
bufferSize = MOENCH_BUFFER_SIZE;
packetsPerFrame = MOENCH_PACKETS_PER_FRAME;
if(!withGotthard){
frameIndexMask = MOENCH_FRAME_INDEX_MASK;
frameIndexOffset = MOENCH_FRAME_INDEX_OFFSET;
}
}
oneBufferSize = bufferSize/packetsPerFrame;
strcpy(savefilename,"");
strcpy(filePath,"");
@ -106,12 +104,105 @@ slsReceiverFunctionList::slsReceiverFunctionList(detectorType det,bool moenchwit
buffer+=aligned_frame_size;
}
if(withGotthard)
cout << "Testing MOENCH Receiver with GOTTHARD Detector" << endl;
vector <vector<int16_t> > map;
vector <vector<int16_t> > mask;
int initial_offset = 4;
int later_offset = 2;
int mask_y_offset = 120;
int mask_adc = 0x7fff;
int num_packets_in_col = 4;
int num_packets_in_row = 10;
int num_pixels_per_packet_in_row = 40;
int num_pixels_per_packet_in_col = 16;
int offset,ipacket;
int x;
int y;
int i, j;
/** not for roi */
//filter
switch(myDetectorType){
case MOENCH:
x = MOENCH_PIXELS_IN_ONE_ROW;
y = MOENCH_PIXELS_IN_ONE_ROW;
mask.resize(x);
for(i=0;i<x; i++)
mask[i].resize(y);
map.resize(x);
for(i=0;i<x; i++)
map[i].resize(y);
//set up mask for moench
for(int i=0;i<x; i++)
for(j=0;i<y; i++)
if (j<mask_y_offset)
mask[i][j] = mask_adc;
else
mask[i][j] = 0;
//set up mapping for moench
for (int ipx = 0; ipx < num_packets_in_col; ipx++ )
for (int ipy = 0; ipy < num_packets_in_row; ipy++ )
for (int ix = 0; ix < num_pixels_per_packet_in_col; ix++ ){
offset = initial_offset;
for (int iy = 0; iy < num_pixels_per_packet_in_row; iy++ ){
ipacket = (ipx + 1) + (ipy * num_packets_in_row);
if (ipacket == MOENCH_PACKETS_PER_FRAME)
ipacket = 0;
map[ ipx * num_pixels_per_packet_in_col + ix][ ipy * num_pixels_per_packet_in_row + iy] =
ipacket * MOENCH_ONE_PACKET_SIZE + offset;
offset += later_offset;
}
}
filter = new singlePhotonFilter(x,y, MOENCH_FRAME_INDEX_MASK, MOENCH_PACKET_INDEX_MASK, MOENCH_FRAME_INDEX_OFFSET, 0, MOENCH_PACKETS_PER_FRAME, 0,map, mask,MOENCH_BUFFER_SIZE);
break;
default:
x = 1;
y = (GOTTHARD_DATA_BYTES/GOTTHARD_PACKETS_PER_FRAME);
offset = initial_offset;
mask.resize(x);
for(int i=0;i<x; i++)
mask[i].resize(y);
map.resize(x);
for(int i=0;i<x; i++)
map[i].resize(y);
//set up mask for moench
for (int i=0; i < x; i++)
for (int j=0; j < y; j++){
mask[i][j] = 0;
}
//set up mapping for gotthard
for (int i=0; i < x; i++)
for (int j=0; j < y; j++){
//since there are 2 packets
if (y == y/2)
offset += initial_offset;
map[i][j] = offset;
offset += 2;
}
filter = new singlePhotonFilter(x,y,GOTTHARD_FRAME_INDEX_MASK, GOTTHARD_PACKET_INDEX_MASK, GOTTHARD_FRAME_INDEX_OFFSET, 0, GOTTHARD_PACKETS_PER_FRAME, 1,map, mask,GOTTHARD_BUFFER_SIZE);
break;
}
pthread_mutex_init(&status_mutex,NULL);
pthread_mutex_init(&dataReadyMutex,NULL);
dataCompression = false;
}
@ -144,10 +235,8 @@ void slsReceiverFunctionList::setEthernetInterface(char* c){
uint32_t slsReceiverFunctionList::getFrameIndex(){
if(!framesCaught)
frameIndex=0;
else if(frameIndexOffset)
frameIndex = currframenum - startFrameIndex; //moench
else
frameIndex = (currframenum - startFrameIndex)/packetsPerFrame;//moench with gotthard, gotthard
frameIndex = currframenum - startFrameIndex;
return frameIndex;
}
@ -156,10 +245,8 @@ uint32_t slsReceiverFunctionList::getFrameIndex(){
uint32_t slsReceiverFunctionList::getAcquisitionIndex(){
if(!totalFramesCaught)
acquisitionIndex=0;
else if(frameIndexOffset)
acquisitionIndex = currframenum - startAcquisitionIndex; //moench
else
acquisitionIndex = (currframenum - startAcquisitionIndex)/packetsPerFrame; //moench with gotthard, gotthard
acquisitionIndex = currframenum - startAcquisitionIndex;
return acquisitionIndex;
}
@ -377,6 +464,13 @@ int slsReceiverFunctionList::startListening(){
measurementStarted = false;
startFrameIndex = 0;
int offset=0;
int ret=1;
int i=0;
uint32_t *framenum;
char *tempchar = new char[oneBufferSize];
// A do/while(FALSE) loop is used to make error cleanup easier. The
// close() of each of the socket descriptors is only done once at the
// very end of the program.
@ -405,10 +499,10 @@ int slsReceiverFunctionList::startListening(){
delete udpSocket;
udpSocket = NULL;
}
udpSocket = new genericSocket(server_port,genericSocket::UDP,bufferSize/packetsPerFrame,packetsPerFrame);
udpSocket = new genericSocket(server_port,genericSocket::UDP,oneBufferSize,1);//packetsPerFrame);
}else{
cout<<"eth:"<<eth<<endl;
udpSocket = new genericSocket(server_port,genericSocket::UDP,bufferSize/packetsPerFrame,packetsPerFrame,eth);
udpSocket = new genericSocket(server_port,genericSocket::UDP,oneBufferSize,1,eth);//packetsPerFrame,eth);
}
if (udpSocket->getErrorStatus()){
#ifdef VERBOSE
@ -420,30 +514,43 @@ int slsReceiverFunctionList::startListening(){
break;
}
filter->setupAcquisitionParameters();
while (receiver_threads_running) {
pthread_mutex_lock(&status_mutex);
listening_thread_running = 1;
pthread_mutex_unlock(&(status_mutex));
if(!listening_thread_running){
pthread_mutex_lock(&status_mutex);
listening_thread_running = 1;
pthread_mutex_unlock(&(status_mutex));
}
if (!fifofree->isEmpty()) {
fifofree->pop(buffer);
if (ret!=0)
fifofree->pop(buffer);
if(ret == -2){
memcpy(buffer,tempchar,oneBufferSize);
offset = oneBufferSize;
}
//receiver 2 half frames / 1 short frame / 40 moench frames
rc = udpSocket->ReceiveDataOnly(buffer,bufferSize);
if( rc < 0)
rc = udpSocket->ReceiveDataOnly(buffer+offset,oneBufferSize);
if( rc <= 0){
#ifdef VERYVERBOSE
cerr << "recvfrom() failed" << endl;
#endif
continue;
}
if ((myDetectorType == GOTTHARD) && (shortFrame == -1))
(*((uint32_t*)(buffer+offset)))++;
ret = filter->verifyFrame(buffer+offset);
//start for each scan
if(!measurementStarted){
if(!frameIndexOffset)
startFrameIndex = ((uint32_t)(*((uint32_t*)buffer)));
else
startFrameIndex = ((((uint32_t)(*((uint32_t*)buffer))) & (frameIndexMask)) >> frameIndexOffset);
cout<<"startFrameIndex:"<<startFrameIndex<<endl;
startFrameIndex = ((((uint32_t)(*((uint32_t*)buffer))) & (frameIndexMask)) >> frameIndexOffset);
cout<<"startFrameIndex:"<<hex<<startFrameIndex<<endl;
prevframenum=startFrameIndex;
measurementStarted = true;
}
@ -453,24 +560,47 @@ int slsReceiverFunctionList::startListening(){
startAcquisitionIndex=startFrameIndex;
currframenum = startAcquisitionIndex;
acqStarted = true;
cout<<"startAcquisitionIndex:"<<startAcquisitionIndex<<endl;
cout<<"startAcquisitionIndex:"<<hex<<startAcquisitionIndex<<endl;
}
/*
if(ret < 0){
offset = 0;
continue;
}
*/
//last packet, but not the full frame, must push previous frame
if(ret == -1){
//set reminaing headers invalid
for( i = offset+ oneBufferSize; i < bufferSize; i += oneBufferSize)
(*((uint32_t*)(buffer+i))) = 0xFFFFFFFF;
offset = 0;
}
//first packet of new frame, must push previous frame
else if(ret == -2){
//copy the new frame to a temp
memcpy(tempchar, buffer+offset, oneBufferSize);
//set all the new frame header and remaining headers invalid
for(i = offset; i < bufferSize; i += oneBufferSize);
(*((uint32_t*)(buffer+i))) = 0xFFFFFFFF;
}
//wait for new packets of same frame
else if (ret == 0){
offset += oneBufferSize;
continue;
}
//wait for next frame
else{
offset = 0;
}
//so that it doesnt write the last frame twice
if(receiver_threads_running){
//s.assign(buffer);
if(fifo->isFull())
;//cout<<"**********************FIFO FULLLLLLLL************************"<<endl;
else{
//cout<<"read index:"<<dec<<(int)(*(int*)buffer)<<endl;& (frameIndexMask)) >> frameIndexOffset;
fifo->push(buffer);
}
if((receiver_threads_running) && (!fifo->isFull())){
fifo->push(buffer);
}
}
}
} while (receiver_threads_running);
@ -482,6 +612,7 @@ int slsReceiverFunctionList::startListening(){
//Close down any open socket descriptors
udpSocket->Disconnect();
delete tempchar;
#ifdef VERBOSE
cout << "receiver_threads_running:" << receiver_threads_running << endl;
@ -512,9 +643,10 @@ int slsReceiverFunctionList::startWriting(){
char *wbuf;
int sleepnumber=0;
int frameFactor=0;
int packetloss=0;
int i;
/*int i1,i2;*/
framesInFile=0;
packetsInFile=0;
framesCaught=0;
frameIndex=0;
if(sfilefd) sfilefd=NULL;
@ -546,11 +678,16 @@ int slsReceiverFunctionList::startWriting(){
cout << "Ready!" << endl;
if (dataCompression)
filter->enableFilter(true);
//will always run till acquisition over and then runs till fifo is empty
while(receiver_threads_running || (!fifo->isEmpty())){
//start a new file
if ((framesInFile == maxFramesPerFile) || (strlen(savefilename) == 0)){
if (((int)(packetsInFile/packetsPerFrame) >= maxFramesPerFile) || (strlen(savefilename) == 0)){
//create file name
if(frameIndexNeeded==-1) sprintf(savefilename, "%s/%s_%d.raw", filePath,fileName,fileIndex);
@ -558,6 +695,14 @@ int slsReceiverFunctionList::startWriting(){
if(enableFileWrite && cbAction > DO_NOTHING){
//create tree and file
if(dataCompression){
if(enableFileWrite){
filter->writeToFile();
filter->initTree(savefilename);
}
}
/*else{*///the standard way
if(sfilefd){
fclose(sfilefd);
sfilefd = NULL;
@ -570,24 +715,22 @@ int slsReceiverFunctionList::startWriting(){
pthread_mutex_unlock(&(status_mutex));
break;
}
//setting buffer
setvbuf(sfilefd,NULL,_IOFBF,BUF_SIZE);
/*}*/
//printing packet losses and file names
//if(prevframenum != 0)
if(!framesCaught)
cout << savefilename << endl;
else{
if(!frameIndexOffset)
packetloss = (int)(((currframenum-prevframenum-(packetsPerFrame*framesInFile))/(double)(packetsPerFrame*framesInFile))*100.000);
else
packetloss = (int)(((currframenum-prevframenum-(framesInFile))/(double)(framesInFile))*100.000);
cout << savefilename
<< "\tpacket loss " << setw(4)<<fixed << setprecision(4) << packetloss
<< "\tpacket loss "
<< setw(4)<<fixed << setprecision(4)<< dec <<
(int)(((((currframenum-prevframenum)*packetsPerFrame)-(packetsInFile))/(double)((currframenum-prevframenum)*packetsPerFrame))*100.000)/*packetloss*/
<< "%\tframenum "
<< currframenum //<< "\t\t p " << prevframenum
<< "\tindex " << getFrameIndex()
<< dec << currframenum //<< "\t\t p " << prevframenum
<< "\tindex " << dec << getFrameIndex()
<< endl;
}
}
@ -600,7 +743,7 @@ int slsReceiverFunctionList::startWriting(){
//if(prevframenum != 0){
if(framesCaught){
prevframenum = currframenum;
framesInFile = 0;
packetsInFile=0;
}
}
@ -609,62 +752,90 @@ int slsReceiverFunctionList::startWriting(){
if(!fifo->isEmpty()){
if(fifo->pop(wbuf)){
framesCaught++;
totalFramesCaught++;
if(!frameIndexOffset)
currframenum = (uint32_t)(*((uint32_t*)wbuf));
else
currframenum = (((uint32_t)(*((uint32_t*)wbuf))) & (frameIndexMask)) >> frameIndexOffset;
//cout<<"currframenum:"<<currframenum<<endl;
currframenum = ((uint32_t)(*((uint32_t*)wbuf))& frameIndexMask) >>frameIndexOffset;
//cout<<"currframenum: "<<hex<<currframenum<<endl;
//cout<<"currframenum2:"<<hex<<((((uint32_t)(*((uint32_t*)((char*)(wbuf+oneBufferSize)))))& frameIndexMask) >> frameIndexOffset)<<endl;;
//write data call back
if (cbAction < DO_EVERYTHING) {
rawDataReadyCallBack(currframenum, wbuf, bufferSize, sfilefd, guiData,pRawDataReady);
}
//default writing to file
else if(enableFileWrite){
if(sfilefd)
fwrite(wbuf, 1, bufferSize, sfilefd);
for(i=0; i < packetsPerFrame; i++){
if(((uint32_t)(*((uint32_t*)((char*)(wbuf+oneBufferSize))))) == 0xFFFFFFFF){
//cout<<"found one: currframenum:"<<currframenum<<" currframe2:"<<((((uint32_t)(*((uint32_t*)((char*)(wbuf+oneBufferSize)))))& frameIndexMask) >> frameIndexOffset)<<endl;
break;
}
}
packetsInFile += i;
//count only if you get full frames
if(i == packetsPerFrame){
framesCaught++;
totalFramesCaught++;
}
//write data call back
if (cbAction < DO_EVERYTHING) {
rawDataReadyCallBack(currframenum, wbuf, i*oneBufferSize, sfilefd, guiData,pRawDataReady);
}
//default writing to file
else if(enableFileWrite){
/*if(!dataCompression){*/
if(sfilefd)
fwrite(wbuf, 1, i*oneBufferSize, sfilefd);
else{
cout << "You do not have permissions to overwrite: " << savefilename << endl;
usleep(50000);
}
/*}*/
}
//does not read every frame
if(!nFrameToGui){
if((guiData) && (i == packetsPerFrame)){
pthread_mutex_lock(&dataReadyMutex);
guiDataReady=0;
pthread_mutex_unlock(&dataReadyMutex);
memcpy(latestData,wbuf,bufferSize);
strcpy(guiFileName,savefilename);
pthread_mutex_lock(&dataReadyMutex);
guiDataReady=1;
/* i1 = ((((uint32_t)(*((uint32_t*)latestData))) & (frameIndexMask)) >> frameIndexOffset);
i2 = ((((uint32_t)(*((uint32_t*)(latestData+oneBufferSize)))) & (frameIndexMask)) >> frameIndexOffset);
if ( i1 == (i2+1))
cout<<"222WEIRDDD:"<<i1<<":"<<i2<<endl;*/
pthread_mutex_unlock(&dataReadyMutex);
}else{
pthread_mutex_lock(&dataReadyMutex);
guiDataReady=0;
pthread_mutex_unlock(&dataReadyMutex);
}
}
//reads every nth frame
else{
cout << "You do not have permissions to overwrite: " << savefilename << endl;
usleep(50000);
}
}
if (i != packetsPerFrame)//so no 1 packet frame writing over previous 2 packet frame
;
else if(frameFactor){
frameFactor--;
}else{
frameFactor = nFrameToGui-1;
//block current process if the guireader hasnt read it yet
sem_wait(&smp);
//copy data and set guidataready
pthread_mutex_lock(&dataReadyMutex);
guiDataReady=0;
pthread_mutex_unlock(&dataReadyMutex);
memcpy(latestData,wbuf,bufferSize);
strcpy(guiFileName,savefilename);
pthread_mutex_lock(&dataReadyMutex);
guiDataReady = 1;
pthread_mutex_unlock(&dataReadyMutex);
//does not read every frame
if(!nFrameToGui){
if(guiData){
memcpy(latestData,wbuf,bufferSize);
strcpy(guiFileName,savefilename);
pthread_mutex_lock(&dataReadyMutex);
guiDataReady=1;
pthread_mutex_unlock(&dataReadyMutex);
}else{
pthread_mutex_lock(&dataReadyMutex);
guiDataReady=0;
pthread_mutex_unlock(&dataReadyMutex);
}
}
}
//reads every nth frame
else{
if(frameFactor){
frameFactor--;
}else{
frameFactor = nFrameToGui-1;
//block current process if the guireader hasnt read it yet
sem_wait(&smp);
//copy data and set guidataready
memcpy(latestData,wbuf,bufferSize);
strcpy(guiFileName,savefilename);
pthread_mutex_lock(&dataReadyMutex);
guiDataReady = 1;
pthread_mutex_unlock(&dataReadyMutex);
}
}
framesInFile++;
fifofree->push(wbuf);
fifofree->push(wbuf);
}
}
else{//cout<<"************************fifo empty**********************************"<<endl;
@ -685,8 +856,8 @@ int slsReceiverFunctionList::startWriting(){
receiver_threads_running=0;
pthread_mutex_unlock(&status_mutex);
cout << "RealTime Frames Caught:" << framesCaught << endl;
cout << "Total Frames Caught:"<< totalFramesCaught << endl;
cout << "RealTime Frames Caught:" << dec <<framesCaught << endl;
cout << "Total Frames Caught:"<< dec << totalFramesCaught << endl;
if(sfilefd){
@ -712,6 +883,7 @@ int slsReceiverFunctionList::startWriting(){
void slsReceiverFunctionList::readFrame(char* c,char** raw){
int i1,i2;
//point to gui data
if (guiData == NULL)
guiData = latestData;
@ -724,13 +896,17 @@ void slsReceiverFunctionList::readFrame(char* c,char** raw){
//data ready, set guidata to receive new data
else{
*raw = guiData;
i1 = ((((uint32_t)(*((uint32_t*)guiData))) & (frameIndexMask)) >> frameIndexOffset);
i2 = ((((uint32_t)(*((uint32_t*)(guiData+oneBufferSize)))) & (frameIndexMask)) >> frameIndexOffset);
if ( i1 == (i2+1))
cout<<"WEIRDDD:"<<i1<<":"<<i2<<endl;
guiData = NULL;
pthread_mutex_lock(&dataReadyMutex);
guiDataReady = 0;
pthread_mutex_unlock(&dataReadyMutex);
if((nFrameToGui) && (receiver_threads_running)){
//release after getting data
sem_post(&smp);
//release after getting data
sem_post(&smp);
}
}
}
@ -745,13 +921,92 @@ int slsReceiverFunctionList::setShortFrame(int i){
bufferSize = GOTTHARD_SHORT_BUFFER_SIZE;
maxFramesPerFile = SHORT_MAX_FRAMES_PER_FILE;
packetsPerFrame = GOTTHARD_SHORT_PACKETS_PER_FRAME;
frameIndexMask = GOTTHARD_SHORT_FRAME_INDEX_MASK;
frameIndexOffset = GOTTHARD_SHORT_FRAME_INDEX_OFFSET;
}else{
bufferSize = GOTTHARD_BUFFER_SIZE;
maxFramesPerFile = MAX_FRAMES_PER_FILE;
packetsPerFrame = GOTTHARD_PACKETS_PER_FRAME;
frameIndexMask = GOTTHARD_FRAME_INDEX_MASK;
frameIndexOffset = GOTTHARD_FRAME_INDEX_OFFSET;
}
oneBufferSize = bufferSize/packetsPerFrame;
//if the filter is inititalized with the wrong readout
if(filter->getPacketsPerFrame() != packetsPerFrame){
vector <vector<int16_t> > map;
vector <vector<int16_t> > mask;
int initial_offset = 4;
int later_offset = 2;
int x,y,i,j,offset = 0;
switch(packetsPerFrame){
case GOTTHARD_SHORT_PACKETS_PER_FRAME://roi readout for gotthard
x = 1;
y = (GOTTHARD_DATA_BYTES/GOTTHARD_PACKETS_PER_FRAME)/2;
offset = initial_offset;
mask.resize(x);
for(int i=0;i<x; i++)
mask[i].resize(y);
map.resize(x);
for(int i=0;i<x; i++)
map[i].resize(y);
//set up mask for moench
for (int i=0; i < x; i++)
for (int j=0; j < y; j++){
mask[i][j] = 0;
}
//set up mapping for gotthard
for (int i=0; i < x; i++)
for (int j=0; j < y; j++){
map[i][j] = offset;
offset += 2;
}
delete filter;
filter = new singlePhotonFilter(x,y,frameIndexMask, GOTTHARD_PACKET_INDEX_MASK, frameIndexOffset, 0, GOTTHARD_SHORT_PACKETS_PER_FRAME, 0,map, mask,GOTTHARD_SHORT_BUFFER_SIZE);
break;
default: //normal readout for gotthard
x = 1;
y = (GOTTHARD_DATA_BYTES/GOTTHARD_PACKETS_PER_FRAME);
offset = initial_offset;
mask.resize(x);
for(int i=0;i<x; i++)
mask[i].resize(y);
map.resize(x);
for(int i=0;i<x; i++)
map[i].resize(y);
//set up mask for moench
for (int i=0; i < x; i++)
for (int j=0; j < y; j++){
mask[i][j] = 0;
}
//set up mapping for gotthard
for (int i=0; i < x; i++)
for (int j=0; j < y; j++){
//since there are 2 packets
if (y == y/2)
offset += initial_offset;
map[i][j] = offset;
offset += 2;
}
delete filter;
filter = new singlePhotonFilter(x,y,frameIndexMask, GOTTHARD_PACKET_INDEX_MASK, frameIndexOffset, 0, GOTTHARD_PACKETS_PER_FRAME, 1,map, mask,GOTTHARD_BUFFER_SIZE);
break;
}
}
return shortFrame;
}

48
slsDetectorSoftware/slsReceiver/slsReceiverFunctionList.h
View File

@ -12,6 +12,7 @@
#include "receiver_defs.h"
#include "genericSocket.h"
#include "circularFifo.h"
#include "singlePhotonFilter.h"
#include <string.h>
@ -30,7 +31,7 @@ public:
/**
* Constructor
*/
slsReceiverFunctionList(detectorType det, bool moenchwithGotthardTest);
slsReceiverFunctionList(detectorType det);
/**
* Destructor
@ -207,6 +208,12 @@ public:
* when fifo is empty later, sets status to run_finished */
void startReadout();
/** enabl data compression, by saving only hits */
void enableDataCompression(bool enable){dataCompression = enable;};
/** get data compression, by saving only hits */
bool getDataCompression(){ return dataCompression;};
private:
/** detector type */
@ -257,8 +264,8 @@ private:
/** Actual current frame index of an entire acquisition (including all scans) */
uint32_t acquisitionIndex;
/** Frames currently in current file, starts new file when it reaches max */
uint32_t framesInFile;
/** Packets currently in current file, starts new file when it reaches max */
uint32_t packetsInFile;
/** Previous Frame number from buffer */
uint32_t prevframenum;
@ -338,6 +345,26 @@ private:
/** send every nth frame to gui or only upon gui request*/
int nFrameToGui;
/** frame index mask */
int frameIndexMask;
/** frame index offset */
int frameIndexOffset;
/** datacompression - save only hits */
bool dataCompression;
/** single photon filter */
singlePhotonFilter *filter;
/** oen buffer size */
int oneBufferSize;
/** semaphore to synchronize writer and guireader threads */
sem_t smp;
/** guiDataReady mutex */
pthread_mutex_t dataReadyMutex;
/**
callback arguments are
@ -381,21 +408,6 @@ private:
* 2 we open, close, write file, callback does not do anything */
int cbAction;
/**temporary variable to test moench with gotthard module*/
bool withGotthard;
/** frame index mask */
int frameIndexMask;
/** frame index offset */
int frameIndexOffset;
/** semaphore to synchronize writer and guireader threads */
sem_t smp;
/** guiDataReady mutex */
pthread_mutex_t dataReadyMutex;
public:
/** File Descriptor */

229
slsDetectorSoftware/slsReceiver/slsReceiver_funcs.cpp
View File

@ -34,7 +34,6 @@ slsReceiverFuncs::slsReceiverFuncs(int argc, char *argv[], int &success):
lockStatus(0),
shortFrame(-1),
packetsPerFrame(GOTTHARD_PACKETS_PER_FRAME),
withGotthard(0),
socket(NULL){
int port_no = DEFAULT_PORTNO+2;
@ -147,20 +146,6 @@ slsReceiverFuncs::slsReceiverFuncs(int argc, char *argv[], int &success):
}
}
}
//test with gotthard module
else if(!strcasecmp(argv[iarg],"-test")){
if(iarg+1==argc){
cout << "no test condition given after -test in command line. Exiting." << endl;
success=FAIL;
}else{
if(!strcasecmp(argv[iarg+1],"with_gotthard"))
withGotthard = 1;
else{
cout << "could not decode test condition in command line. \nOptions are:\nwith_gotthard.\n\nExiting." << endl;
success=FAIL;
}
}
}
//tcp port
else if(!strcasecmp(argv[iarg],"-rx_tcpport")){
if(iarg+1==argc){
@ -184,18 +169,10 @@ slsReceiverFuncs::slsReceiverFuncs(int argc, char *argv[], int &success):
//display detector message
switch(myDetectorType){
case GOTTHARD:
if(withGotthard){
cout << "Option -test with_gotthard exists only for MOENCH detectors. Exiting" << endl;
exit(-1);
}else
cout << "This is a GOTTHARD Receiver" << endl;
cout << "This is a GOTTHARD Receiver" << endl;
break;
case MOENCH:
if(withGotthard)
cout << "This is a MOENCH Receiver using a GOTTHARD Detector."
"\nNote:Packet numbers are not matched for its corresponding frames." << endl;
else
cout << "This is a MOENCH Receiver" << endl;
cout << "This is a MOENCH Receiver" << endl;
break;
default:
cout << "Unknown Receiver" << endl;
@ -218,7 +195,7 @@ slsReceiverFuncs::slsReceiverFuncs(int argc, char *argv[], int &success):
strcpy(mess,"dummy message");
function_table();
slsReceiverList = new slsReceiverFunctionList(myDetectorType,withGotthard);
slsReceiverList = new slsReceiverFunctionList(myDetectorType);
#ifdef VERBOSE
cout << "Function table assigned." << endl;
@ -933,7 +910,7 @@ int slsReceiverFuncs::read_frame(){
int slsReceiverFuncs::moench_read_frame(){
ret=OK;
char fName[MAX_STR_LENGTH]="";
int arg = -1,i,j,x,y;
int arg = -1,i;
int bufferSize = MOENCH_BUFFER_SIZE;
@ -948,7 +925,6 @@ int slsReceiverFuncs::moench_read_frame(){
uint32_t startIndex=0;
int index = 0;
int count=0;
int offset=0;
@ -982,108 +958,63 @@ int slsReceiverFuncs::moench_read_frame(){
memcpy(origVal,raw,bufferSize);
raw=NULL;
//************** default order*****************************
if(withGotthard){
count = 0;
offset = 4;
j=0;
for(x=0;x<(MOENCH_BYTES_IN_ONE_ROW/MOENCH_BYTES_PER_ADC);x++){
for(y=0;y<MOENCH_PIXELS_IN_ONE_ROW;y++){
memcpy((((char*)retval) +
y * MOENCH_BYTES_IN_ONE_ROW +
x * MOENCH_BYTES_PER_ADC),
(((char*) origVal) +
offset +
j * MOENCH_BYTES_PER_ADC) ,
MOENCH_BYTES_PER_ADC);
j++;
count++;
if(count==16){
count=0;
offset+=6;
}
}
}
}
//********************************************************
//************** packet number order**********************
else{
if(!withGotthard)
index = ((index & (MOENCH_FRAME_INDEX_MASK)) >> MOENCH_FRAME_INDEX_OFFSET);
//cout<<"this frame number:"<<index<<endl;
index = ((index & (MOENCH_FRAME_INDEX_MASK)) >> MOENCH_FRAME_INDEX_OFFSET);
uint32_t numPackets = MOENCH_PACKETS_PER_FRAME; //40
uint32_t onePacketSize = MOENCH_DATA_BYTES / MOENCH_PACKETS_PER_FRAME; //1280*40 / 40 = 1280
uint32_t packetDatabytes_row = onePacketSize * (MOENCH_BYTES_IN_ONE_ROW / MOENCH_BYTES_PER_ADC); //1280 * 4 = 5120
uint32_t partsPerFrame = onePacketSize / MOENCH_BYTES_PER_ADC; // 1280 / 80 = 16
uint32_t packetOffset = 0;
int packetIndex,x,y;
int iPacket = 0;
offset = 4;
uint32_t numPackets = MOENCH_PACKETS_PER_FRAME; //40
uint32_t onePacketSize = MOENCH_DATA_BYTES / MOENCH_PACKETS_PER_FRAME; //1280*40 / 40 = 1280
uint32_t packetDatabytes_row = onePacketSize * (MOENCH_BYTES_IN_ONE_ROW / MOENCH_BYTES_PER_ADC); //1280 * 4 = 5120
uint32_t partsPerFrame = onePacketSize / MOENCH_BYTES_PER_ADC; // 1280 / 80 = 16
uint32_t packetOffset = 0;
int packetIndex,x,y;
int iPacket = 0;
offset = 4;
while (iPacket < numPackets){
while (iPacket < (int)numPackets){
#ifdef VERBOSE
printf("iPacket:%d\n",iPacket);cout << endl;
printf("iPacket:%d\n",iPacket);cout << endl;
#endif
packetIndex = (*((uint32_t*)(((char*)origVal)+packetOffset))) & MOENCH_PACKET_INDEX_MASK;
//the first packet is placed in the end
packetIndex--;
if(packetIndex ==-1)
packetIndex = 39;
packetIndex = (*((uint32_t*)(((char*)origVal)+packetOffset))) & MOENCH_PACKET_INDEX_MASK;
//the first packet is placed in the end
packetIndex--;
if(packetIndex ==-1)
packetIndex = 39;
//check validity
if ((packetIndex >= 40) && (packetIndex < 0))
cout << "cannot decode packet index:" << packetIndex << endl;
else{
//check validity
if ((packetIndex >= 40) && (packetIndex < 0))
cout << "cannot decode packet index:" << packetIndex << endl;
else{
x = packetIndex / 10;
y = packetIndex % 10;
x = packetIndex / 10;
y = packetIndex % 10;
#ifdef VERBOSE
cout<<"x:"<<x<<" y:"<<y<<endl;
cout<<"x:"<<x<<" y:"<<y<<endl;
#endif
//copy 16 times 80 bytes
for (i = 0; i < partsPerFrame; i++) {
memcpy((((char*)retval) +
y * packetDatabytes_row +
i * MOENCH_BYTES_IN_ONE_ROW +
x * MOENCH_BYTES_PER_ADC),
//copy 16 times 80 bytes
for (i = 0; i < (int)partsPerFrame; i++) {
memcpy((((char*)retval) +
y * packetDatabytes_row +
i * MOENCH_BYTES_IN_ONE_ROW +
x * MOENCH_BYTES_PER_ADC),
(((char*) origVal) +
iPacket * offset +
iPacket * onePacketSize +
i * MOENCH_BYTES_PER_ADC + 4) ,
MOENCH_BYTES_PER_ADC);
}
(((char*) origVal) +
iPacket * offset +
iPacket * onePacketSize +
i * MOENCH_BYTES_PER_ADC + 4) ,
MOENCH_BYTES_PER_ADC);
}
//increment
offset=6;
iPacket++;
packetOffset = packetOffset + offset + onePacketSize;
// cout <<" checking next frame number:"<<hex<<(((*((int*)((char*)(origVal+packetOffset)))) & (MOENCH_FRAME_INDEX_MASK)) >> MOENCH_FRAME_INDEX_OFFSET)<<endl;
//check if same frame number
/* while ((((*((int*)((char*)(origVal+packetOffset)))) & (MOENCH_FRAME_INDEX_MASK)) >> MOENCH_FRAME_INDEX_OFFSET) != index){cout<<"did not match"<<endl;
if(iPacket >= numPackets)
break;
//increment
offset+=6;
iPacket++;
packetOffset = packetOffset + offset + onePacketSize;
}*/
}
//increment
offset=6;
iPacket++;
packetOffset = packetOffset + offset + onePacketSize;
//check if same frame number
}
arg = index - startIndex;
if(withGotthard)
arg = arg/MOENCH_PACKETS_PER_FRAME;
}
//********************************************************
}
@ -1152,8 +1083,9 @@ int slsReceiverFuncs::gotthard_read_frame(){
uint32_t index=0,index2=0;
uint32_t pindex=0,pindex2=0;
uint32_t bindex=0,bindex2=0;
uint32_t startIndex=0;
int count=0;
strcpy(mess,"Could not read frame\n");
@ -1179,40 +1111,63 @@ int slsReceiverFuncs::gotthard_read_frame(){
cout<<"data not ready for gui yet"<<endl;
#endif
}else{
index=(uint32_t)(*(uint32_t*)raw);
if(shortFrame!=-1){
bindex = (uint32_t)(*((uint32_t*)raw));
pindex = (bindex & GOTTHARD_SHORT_PACKET_INDEX_MASK);
index = ((bindex & GOTTHARD_SHORT_FRAME_INDEX_MASK) >> GOTTHARD_SHORT_FRAME_INDEX_OFFSET);
#ifdef VERBOSE
cout<<"index:"<<index<<endl;
cout<<"index:"<<hex<<index<<endl;
#endif
if(shortFrame==-1)
index2= (uint32_t)(*((uint32_t*)((char*)(raw+onebuffersize))));
}else{
bindex = (uint32_t)(*((uint32_t*)raw));
pindex = (bindex & GOTTHARD_PACKET_INDEX_MASK);
index = ((bindex & GOTTHARD_FRAME_INDEX_MASK) >> GOTTHARD_FRAME_INDEX_OFFSET);
bindex2 = (uint32_t)(*((uint32_t*)((char*)(raw+onebuffersize))));
pindex2 =(bindex2 & GOTTHARD_PACKET_INDEX_MASK);
index2 =((bindex2 & GOTTHARD_FRAME_INDEX_MASK) >> GOTTHARD_FRAME_INDEX_OFFSET);
#ifdef VERBOSE
cout<<"index1:"<<hex<<index<<endl;
cout<<"index2:"<<hex<<index<<endl;
#endif
}
memcpy(origVal,raw,bufferSize);
raw=NULL;
//1 adc
if(shortFrame!=-1){
memcpy((((char*)retval)+(GOTTHARD_SHORT_DATABYTES*shortFrame)),((char*) origVal)+4, GOTTHARD_SHORT_DATABYTES);
if(bindex != 0xFFFFFFFF)
memcpy((((char*)retval)+(GOTTHARD_SHORT_DATABYTES*shortFrame)),((char*) origVal)+4, GOTTHARD_SHORT_DATABYTES);
else
index = startIndex - 1;
}
//all adc
else{
//1 odd, 1 even
if((index%2)!=index2%2){
//ideal situation (should be odd, even(index+1))
if(index%2){
memcpy(retval,((char*) origVal)+4, onedatasize);
memcpy((((char*)retval)+onedatasize), ((char*) origVal)+10+onedatasize, onedatasize);
}
//ignore if half frame is missing
if ((bindex != 0xFFFFFFFF) && (bindex2 != 0xFFFFFFFF)){
//swap to even,odd
if(index2%2){
memcpy((((char*)retval)+onedatasize),((char*) origVal)+4, onedatasize);
memcpy(retval, ((char*) origVal)+10+onedatasize, onedatasize);
index=index2;
}
}else
cout << "same type: index:" << index << "\tindex2:" << index2 << endl;
//should be same frame
if (index == index2){
//ideal situation (should be odd, even(index+1))
if(!pindex){
memcpy(retval,((char*) origVal)+4, onedatasize);
memcpy((((char*)retval)+onedatasize), ((char*) origVal)+10+onedatasize, onedatasize);
}
//swap to even,odd
else{
memcpy((((char*)retval)+onedatasize),((char*) origVal)+4, onedatasize);
memcpy(retval, ((char*) origVal)+10+onedatasize, onedatasize);
index=index2;
}
}else
cout << "different frames caught. frame1:"<< hex << index << ":"<<pindex<<" frame2:" << hex << index2 << ":"<<pindex2<<endl;
}
else
index = startIndex - 1;
}
arg = ((index - startIndex)/packetsPerFrame);
arg = (index - startIndex);
}
}

3
slsDetectorSoftware/slsReceiver/slsReceiver_funcs.h
View File

@ -200,9 +200,6 @@ public:
/** Packets per frame */
int packetsPerFrame;
/** temporary variable to debug moench receiver with gotthard module */
int withGotthard;
static int file_des;
static int socketDescriptor;