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

modified all the receive module, chip to be non struct and with an extra parameter for type

Browse Source 
git-svn-id: file:///afs/psi.ch/project/sls_det_software/svn/slsDetectorSoftware@612 951219d9-93cf-4727-9268-0efd64621fa3
This commit is contained in:
l_maliakal_d 2013-06-19 09:30:45 +00:00
parent 3d4748e918
commit cb326e1f63
3 changed files with 108 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

155
slsDetectorSoftware/commonFiles/communication_funcs.c
View File

@ -11,7 +11,6 @@
#include <sys/time.h> #include <sys/time.h>
//int socketDescriptor, file_des; //int socketDescriptor, file_des;
const int send_rec_max_size=SEND_REC_MAX_SIZE; const int send_rec_max_size=SEND_REC_MAX_SIZE;
extern int errno; extern int errno;
@ -264,45 +263,42 @@ void exitServer(int socketDescriptor) {
void swapData(void* val,int length,intType itype){ void swapData(void* val,int length,intType itype){
int i;
int16_t* c= (int16_t*)val;
int32_t* a= (int32_t*)val;
int64_t* b= (int64_t*)val;
for(i=0; length > 0; i++){
switch(itype){ switch(itype){
case INT16: swap16(val,length); break; case INT16:
case INT32: swap32(val,length); break; c[i] = ((c[i] & 0x00FF) << 8) | ((c[i] & 0xFF00) >> 8);
case INT64: swap64(val,length); break; length -= sizeof(int16_t);
default: break; break;
} case INT32:
} a[i]=((a[i] << 8) & 0xFF00FF00) | ((a[i] >> 8) & 0xFF00FF );
a[i]=(a[i] << 16) | ((a[i] >> 16) & 0xFFFF);
void swap16(int16_t* val,int length){
printf("not implemented\n");
}
void swap32(int32_t* val,int length){
int i;
for(i=0; length > 0; i++){
val[i] = ((val[i] << 8) & 0xFF00FF00) | ((val[i] >> 8) & 0xFF00FF );
val[i] = (val[i] << 16) | ((val[i] >> 16) & 0xFFFF);
length -= sizeof(int32_t); length -= sizeof(int32_t);
} break;
} case INT64:
b[i] = ((b[i] << 8) & 0xFF00FF00FF00FF00ULL ) | ((b[i] >> 8) & 0x00FF00FF00FF00FFULL );
void swap64(int64_t* val,int length){ b[i] = ((b[i] << 16) & 0xFFFF0000FFFF0000ULL ) | ((b[i] >> 16) & 0x0000FFFF0000FFFFULL );
int i; b[i] = (b[i] << 32) | ((b[i] >> 32) & 0xFFFFFFFFULL);
for(i=0; length > 0; i++){
val[i] = ((val[i] << 8) & 0xFF00FF00FF00FF00ULL ) | ((val[i] >> 8) & 0x00FF00FF00FF00FFULL );
val[i] = ((val[i] << 16) & 0xFFFF0000FFFF0000ULL ) | ((val[i] >> 16) & 0x0000FFFF0000FFFFULL );
val[i] = (val[i] << 32) | ((val[i] >> 32) & 0xFFFFFFFFULL);
length -= sizeof(int64_t); length -= sizeof(int64_t);
break;
default:
length = 0;
break;
}
} }
} }
int sendData(int file_des, void* buf,int length, intType itype){ int sendData(int file_des, void* buf,int length, intType itype){
int ret = sendDataOnly(file_des, buf, length);
#ifdef EIGERD #ifdef EIGERD
swapData(buf, length, itype); swapData(buf, length, itype);
#endif #endif
return ret; return sendDataOnly(file_des, buf, length);
} }
int receiveData(int file_des, void* buf,int length, intType itype){ int receiveData(int file_des, void* buf,int length, intType itype){
int ret = receiveDataOnly(file_des, buf, length); int ret = receiveDataOnly(file_des, buf, length);
#ifdef EIGERD #ifdef EIGERD
@ -379,14 +375,24 @@ int receiveData(int file_des, void* buf,int length, intType itype){
int sendChannel(int file_des, sls_detector_channel *myChan) { int sendChannel(int file_des, sls_detector_channel *myChan) {
return sendDataOnly(file_des,myChan, sizeof(sls_detector_channel)); int ts=0;
//sendDataOnly(file_des,myChan, sizeof(sls_detector_channel));
ts+=sendData(file_des,&(myChan->chan),sizeof(myChan->chan),INT32);
ts+=sendData(file_des,&(myChan->chip),sizeof(myChan->chip),INT32);
ts+=sendData(file_des,&(myChan->module),sizeof(myChan->module),INT32);
ts+=sendData(file_des,&(myChan->reg),sizeof(myChan->reg),INT64);
return ts;
} }
int sendChip(int file_des, sls_detector_chip *myChip) { int sendChip(int file_des, sls_detector_chip *myChip) {
int ts=0; int ts=0;
int nChans=myChip->nchan; //ts+=sendDataOnly(file_des,myChip,sizeof(sls_detector_chip));
ts+=sendDataOnly(file_des,myChip,sizeof(sls_detector_chip)); ts+=sendData(file_des,&(myChip->chip),sizeof(myChip->chip),INT32);
ts+=sendDataOnly(file_des,myChip->chanregs,nChans*sizeof(int)); ts+=sendData(file_des,&(myChip->module),sizeof(myChip->module),INT32);
ts+=sendData(file_des,&(myChip->nchan),sizeof(myChip->nchan),INT32);
ts+=sendData(file_des,&(myChip->reg),sizeof(myChip->reg),INT32);
ts+=sendData(file_des,(myChip->chanregs),sizeof(myChip->chanregs),INT32);
ts+=sendData(file_des,myChip->chanregs,myChip->nchan*sizeof(int),INT32);
return ts; return ts;
} }
@ -399,25 +405,39 @@ int sendModule(int file_des, sls_detector_module *myMod) {
int nChans=myMod->nchan; int nChans=myMod->nchan;
int nAdcs=myMod->nadc; int nAdcs=myMod->nadc;
int nDacs=myMod->ndac; int nDacs=myMod->ndac;
ts+= sendDataOnly(file_des,myMod,sizeof(sls_detector_module)); //ts+= sendDataOnly(file_des,myMod,sizeof(sls_detector_module));
ts+=sendData(file_des,&(myMod->module),sizeof(myMod->module),INT32);
ts+=sendData(file_des,&(myMod->serialnumber),sizeof(myMod->serialnumber),INT32);
ts+=sendData(file_des,&(myMod->nchan),sizeof(myMod->nchan),INT32);
ts+=sendData(file_des,&(myMod->nchip),sizeof(myMod->nchip),INT32);
ts+=sendData(file_des,&(myMod->ndac),sizeof(myMod->ndac),INT32);
ts+=sendData(file_des,&(myMod->nadc),sizeof(myMod->nadc),INT32);
ts+=sendData(file_des,&(myMod->reg),sizeof(myMod->reg),INT32);
ts+=sendData(file_des,myMod->dacs,sizeof(myMod->ndac),INT32);
ts+=sendData(file_des,myMod->adcs,sizeof(myMod->nadc),INT32);
ts+=sendData(file_des,myMod->chipregs,sizeof(myMod->nchip),INT32);
ts+=sendData(file_des,myMod->chanregs,sizeof(myMod->nchan),INT32);
ts+=sendData(file_des,&(myMod->gain), sizeof(myMod->gain),OTHER);
ts+=sendData(file_des,&(myMod->offset), sizeof(myMod->offset),OTHER);
#ifdef VERBOSE #ifdef VERBOSE
printf("module %d of size %d sent\n",myMod->module, ts); printf("module %d of size %d sent\n",myMod->module, ts);
#endif #endif
ts+= sendDataOnly(file_des,myMod->dacs,sizeof(dacs_t)*nDacs); ts+= sendData(file_des,myMod->dacs,sizeof(dacs_t)*nDacs,INT32);
#ifdef VERBOSE #ifdef VERBOSE
printf("dacs %d of size %d sent\n",myMod->module, ts); printf("dacs %d of size %d sent\n",myMod->module, ts);
for (idac=0; idac< nDacs; idac++) for (idac=0; idac< nDacs; idac++)
printf("dac %d is %d\n",idac,(int)myMod->dacs[idac]); printf("dac %d is %d\n",idac,(int)myMod->dacs[idac]);
#endif #endif
ts+= sendDataOnly(file_des,myMod->adcs,sizeof(dacs_t)*nAdcs); ts+= sendData(file_des,myMod->adcs,sizeof(dacs_t)*nAdcs,INT32);
#ifdef VERBOSE #ifdef VERBOSE
printf("adcs %d of size %d sent\n",myMod->module, ts); printf("adcs %d of size %d sent\n",myMod->module, ts);
#endif #endif
ts+=sendDataOnly(file_des,myMod->chipregs,sizeof(int)*nChips); ts+=sendData(file_des,myMod->chipregs,sizeof(int)*nChips,INT32);
#ifdef VERBOSE #ifdef VERBOSE
printf("chips %d of size %d sent\n",myMod->module, ts); printf("chips %d of size %d sent\n",myMod->module, ts);
#endif #endif
ts+=sendDataOnly(file_des,myMod->chanregs,sizeof(int)*nChans); ts+=sendData(file_des,myMod->chanregs,sizeof(int)*nChans,INT32);
#ifdef VERBOSE #ifdef VERBOSE
printf("chans %d of size %d sent - %d\n",myMod->module, ts, myMod->nchan); printf("chans %d of size %d sent - %d\n",myMod->module, ts, myMod->nchan);
#endif #endif
@ -428,7 +448,13 @@ int sendModule(int file_des, sls_detector_module *myMod) {
} }
int receiveChannel(int file_des, sls_detector_channel *myChan) { int receiveChannel(int file_des, sls_detector_channel *myChan) {
return receiveDataOnly(file_des,myChan,sizeof(sls_detector_channel)); int ts=0;
//receiveDataOnly(file_des,myChan,sizeof(sls_detector_channel));
ts+=receiveData(file_des,&(myChan->chan),sizeof(myChan->chan),INT32);
ts+=receiveData(file_des,&(myChan->chip),sizeof(myChan->chip),INT32);
ts+=receiveData(file_des,&(myChan->module),sizeof(myChan->module),INT32);
ts+=receiveData(file_des,&(myChan->reg),sizeof(myChan->reg),INT32);
return ts;
} }
int receiveChip(int file_des, sls_detector_chip* myChip) { int receiveChip(int file_des, sls_detector_chip* myChip) {
@ -437,8 +463,12 @@ int receiveChip(int file_des, sls_detector_chip* myChip) {
int ts=0; int ts=0;
int nChans, nchanold=myChip->nchan, chdiff; int nChans, nchanold=myChip->nchan, chdiff;
ts+= receiveDataOnly(file_des,myChip,sizeof(sls_detector_chip)); //ts+= receiveDataOnly(file_des,myChip,sizeof(sls_detector_chip));
ts+=receiveData(file_des,&(myChip->chip),sizeof(myChip->chip),INT32);
ts+=receiveData(file_des,&(myChip->module),sizeof(myChip->module),INT32);
ts+=receiveData(file_des,&(myChip->nchan),sizeof(myChip->nchan),INT32);
ts+=receiveData(file_des,&(myChip->reg),sizeof(myChip->reg),INT32);
ts+=receiveData(file_des,(myChip->chanregs),sizeof(myChip->chanregs),INT32);
myChip->chanregs=ptr; myChip->chanregs=ptr;
nChans=myChip->nchan; nChans=myChip->nchan;
@ -454,12 +484,12 @@ int receiveChip(int file_des, sls_detector_chip* myChip) {
#endif #endif
if (chdiff<=0) if (chdiff<=0)
ts+=receiveDataOnly(file_des,myChip->chanregs, sizeof(int)*nChans); ts+=receiveData(file_des,myChip->chanregs, sizeof(int)*nChans,INT32);
else { else {
ptr=malloc(chdiff*sizeof(int)); ptr=malloc(chdiff*sizeof(int));
myChip->nchan=nchanold; myChip->nchan=nchanold;
ts+=receiveDataOnly(file_des,myChip->chanregs, sizeof(int)*nchanold); ts+=receiveData(file_des,myChip->chanregs, sizeof(int)*nchanold,INT32);
ts+=receiveDataOnly(file_des,ptr, sizeof(int)*chdiff); ts+=receiveData(file_des,ptr, sizeof(int)*chdiff,INT32);
free(ptr); free(ptr);
return FAIL; return FAIL;
} }
@ -484,7 +514,20 @@ int receiveModule(int file_des, sls_detector_module* myMod) {
#ifdef VERBOSE #ifdef VERBOSE
int id=0; int id=0;
#endif #endif
ts+= receiveDataOnly(file_des,myMod,sizeof(sls_detector_module)); // ts+= receiveDataOnly(file_des,myMod,sizeof(sls_detector_module));
ts+=receiveData(file_des,&(myMod->module),sizeof(myMod->module),INT32);
ts+=receiveData(file_des,&(myMod->serialnumber),sizeof(myMod->serialnumber),INT32);
ts+=receiveData(file_des,&(myMod->nchan),sizeof(myMod->nchan),INT32);
ts+=receiveData(file_des,&(myMod->nchip),sizeof(myMod->nchip),INT32);
ts+=receiveData(file_des,&(myMod->ndac),sizeof(myMod->ndac),INT32);
ts+=receiveData(file_des,&(myMod->nadc),sizeof(myMod->nadc),INT32);
ts+=receiveData(file_des,&(myMod->reg),sizeof(myMod->reg),INT32);
ts+=receiveData(file_des,myMod->dacs,sizeof(myMod->ndac),INT32);
ts+=receiveData(file_des,myMod->adcs,sizeof(myMod->nadc),INT32);
ts+=receiveData(file_des,myMod->chipregs,sizeof(myMod->nchip),INT32);
ts+=receiveData(file_des,myMod->chanregs,sizeof(myMod->nchan),INT32);
ts+=receiveData(file_des,&(myMod->gain), sizeof(myMod->gain),OTHER);
ts+=receiveData(file_des,&(myMod->offset), sizeof(myMod->offset),OTHER);
myMod->dacs=dacptr; myMod->dacs=dacptr;
myMod->adcs=adcptr; myMod->adcs=adcptr;
@ -532,7 +575,7 @@ int receiveModule(int file_des, sls_detector_module* myMod) {
printf("received %d adcs\n",nAdcs); printf("received %d adcs\n",nAdcs);
#endif #endif
if (ndacdiff<=0) { if (ndacdiff<=0) {
ts+=receiveDataOnly(file_des,myMod->dacs, sizeof(dacs_t)*nDacs); ts+=receiveData(file_des,myMod->dacs, sizeof(dacs_t)*nDacs,INT32);
#ifdef VERBOSE #ifdef VERBOSE
printf("dacs received\n"); printf("dacs received\n");
for (id=0; id<nDacs; id++) for (id=0; id<nDacs; id++)
@ -543,50 +586,50 @@ int receiveModule(int file_des, sls_detector_module* myMod) {
} else { } else {
dacptr=malloc(ndacdiff*sizeof(dacs_t)); dacptr=malloc(ndacdiff*sizeof(dacs_t));
myMod->ndac=ndold; myMod->ndac=ndold;
ts+=receiveDataOnly(file_des,myMod->dacs, sizeof(dacs_t)*ndold); ts+=receiveData(file_des,myMod->dacs, sizeof(dacs_t)*ndold,INT32);
ts+=receiveDataOnly(file_des,dacptr, sizeof(dacs_t)*ndacdiff); ts+=receiveData(file_des,dacptr, sizeof(dacs_t)*ndacdiff,INT32);
free(dacptr); free(dacptr);
return FAIL; return FAIL;
} }
if (nadcdiff<=0) { if (nadcdiff<=0) {
ts+=receiveDataOnly(file_des,myMod->adcs, sizeof(dacs_t)*nAdcs); ts+=receiveData(file_des,myMod->adcs, sizeof(dacs_t)*nAdcs,INT32);
#ifdef VERBOSE #ifdef VERBOSE
printf("adcs received\n"); printf("adcs received\n");
#endif #endif
} else { } else {
adcptr=malloc(nadcdiff*sizeof(dacs_t)); adcptr=malloc(nadcdiff*sizeof(dacs_t));
myMod->nadc=naold; myMod->nadc=naold;
ts+=receiveDataOnly(file_des,myMod->adcs, sizeof(dacs_t)*naold); ts+=receiveData(file_des,myMod->adcs, sizeof(dacs_t)*naold,INT32);
ts+=receiveDataOnly(file_des,adcptr, sizeof(dacs_t)*nadcdiff); ts+=receiveData(file_des,adcptr, sizeof(dacs_t)*nadcdiff,INT32);
free(adcptr); free(adcptr);
return FAIL; return FAIL;
} }
if (nchipdiff<=0) { if (nchipdiff<=0) {
ts+=receiveDataOnly(file_des,myMod->chipregs, sizeof(int)*nChips); ts+=receiveData(file_des,myMod->chipregs, sizeof(int)*nChips,INT32);
#ifdef VERBOSE #ifdef VERBOSE
printf("chips received\n"); printf("chips received\n");
#endif #endif
} else { } else {
chipptr=malloc(nchipdiff*sizeof(int)); chipptr=malloc(nchipdiff*sizeof(int));
myMod->nchip=nchipold; myMod->nchip=nchipold;
ts+=receiveDataOnly(file_des,myMod->chipregs, sizeof(int)*nchipold); ts+=receiveData(file_des,myMod->chipregs, sizeof(int)*nchipold,INT32);
ts+=receiveDataOnly(file_des,chipptr, sizeof(int)*nchipdiff); ts+=receiveData(file_des,chipptr, sizeof(int)*nchipdiff,INT32);
free(chipptr); free(chipptr);
return FAIL; return FAIL;
} }
if (nchandiff<=0) { if (nchandiff<=0) {
ts+=receiveDataOnly(file_des,myMod->chanregs, sizeof(int)*nChans); ts+=receiveData(file_des,myMod->chanregs, sizeof(int)*nChans,INT32);
#ifdef VERBOSE #ifdef VERBOSE
printf("chans received\n"); printf("chans received\n");
#endif #endif
} else { } else {
chanptr=malloc(nchandiff*sizeof(int)); chanptr=malloc(nchandiff*sizeof(int));
myMod->nchan=nchanold; myMod->nchan=nchanold;
ts+=receiveDataOnly(file_des,myMod->chanregs, sizeof(int)*nchanold); ts+=receiveData(file_des,myMod->chanregs, sizeof(int)*nchanold,INT32);
ts+=receiveDataOnly(file_des,chanptr, sizeof(int)*nchandiff); ts+=receiveData(file_des,chanptr, sizeof(int)*nchandiff,INT32);
free(chanptr); free(chanptr);
return FAIL; return FAIL;
} }

4
slsDetectorSoftware/commonFiles/communication_funcs.h
View File

@ -37,10 +37,6 @@ void closeConnection(int file_Des);
void exitServer(int socketDescriptor); void exitServer(int socketDescriptor);
void swapData(void* val,int length,intType itype); void swapData(void* val,int length,intType itype);
void swap16(int16_t* val,int length);
void swap32(int32_t* val,int length);
void swap64(int64_t* val,int length);
int sendData(int file_des, void* buf,int length, intType itype); int sendData(int file_des, void* buf,int length, intType itype);
int receiveData(int file_des, void* buf,int length, intType itype); int receiveData(int file_des, void* buf,int length, intType itype);
int sendDataOnly(int file_des, void* buf,int length); int sendDataOnly(int file_des, void* buf,int length);

3
slsDetectorSoftware/commonFiles/sls_detector_defs.h
View File

@ -370,8 +370,7 @@ enum dacIndex {
E_rxb_lb, /**< eiger */ E_rxb_lb, /**< eiger */
E_Vcp, /**< eiger */ E_Vcp, /**< eiger */
E_Vcn, /**< eiger */ E_Vcn, /**< eiger */
E_Vis, /**< eiger */ E_Vis /**< eiger */
E_iodelay /**< eiger */
}; };
/** /**