#include "sls_detector_defs.h" #include "server_funcs.h" #ifndef PICASSOD #include "server_defs.h" #else #include "picasso_defs.h" #endif #include "firmware_funcs.h" #include "mcb_funcs.h" #include "trimming_funcs.h" // Global variables int (*flist[256])(int); #ifdef MCB_FUNCS extern const enum detectorType myDetectorType; #endif #ifndef MCB_FUNCS const enum detectorType myDetectorType=MYTHEN; #endif extern int nModX; extern int nModY; extern int dataBytes; extern int dynamicRange; extern int storeInRAM; extern int lockStatus; extern char lastClientIP[INET_ADDRSTRLEN]; extern char thisClientIP[INET_ADDRSTRLEN]; extern int differentClients; /* global variables for optimized readout */ extern int *ram_values; char *dataretval=NULL; int nframes, iframes, dataret; char mess[1000]; int init_detector( int b) { #ifndef PICASSOD printf("This is a MYTHEN detector with %d chips per module\n", NCHIP); #else printf("This is a PICASSO detector with %d chips per module\n", NCHIP); #endif mapCSP0(); #ifndef VIRTUAL system("bus -a 0xb0000000 -w 0xd0008"); #ifdef VERBOSE printf("setting wait states \n"); system("bus -a 0xb0000000"); #endif #endif testFpga(); if (b) { #ifdef MCB_FUNCS initDetector(); setSettings(GET_SETTINGS); testRAM(); #endif setTiming(GET_EXTERNAL_COMMUNICATION_MODE); setMaster(GET_MASTER); setSynchronization(GET_SYNCHRONIZATION_MODE); } strcpy(mess,"dummy message"); strcpy(lastClientIP,"none"); strcpy(thisClientIP,"none1"); lockStatus=0; return OK; } int decode_function(int file_des) { int fnum,n; int retval=FAIL; #ifdef VERBOSE printf( "receive data\n"); #endif n = receiveDataOnly(file_des,&fnum,sizeof(fnum)); if (n <= 0) { printf("ERROR reading from socket %d, %d %d\n", n, fnum, file_des); return FAIL; } #ifdef VERBOSE else printf("size of data received %d\n",n); #endif #ifdef VERBOSE printf( "calling function fnum = %d %x\n",fnum,flist[fnum]); #endif if (fnum<0 || fnum>255) fnum=255; retval=(*flist[fnum])(file_des); if (retval==FAIL) printf( "Error executing the function = %d \n",fnum); return retval; } int function_table() { int i; for (i=0;i<256;i++){ flist[i]=&M_nofunc; } flist[F_EXIT_SERVER]=&exit_server; flist[F_EXEC_COMMAND]=&exec_command; flist[F_GET_DETECTOR_TYPE]=&get_detector_type; flist[F_SET_NUMBER_OF_MODULES]=&set_number_of_modules; flist[F_GET_MAX_NUMBER_OF_MODULES]=&get_max_number_of_modules; flist[F_SET_EXTERNAL_SIGNAL_FLAG]=&set_external_signal_flag; flist[F_SET_EXTERNAL_COMMUNICATION_MODE]=&set_external_communication_mode; flist[F_GET_ID]=&get_id; flist[F_DIGITAL_TEST]=&digital_test; flist[F_WRITE_REGISTER]=&write_register; flist[F_READ_REGISTER]=&read_register; flist[F_SET_DAC]=&set_dac; flist[F_GET_ADC]=&get_adc; flist[F_SET_CHANNEL]=&set_channel; flist[F_SET_CHIP]=&set_chip; flist[F_SET_MODULE]=&set_module; flist[F_GET_CHANNEL]=&get_channel; flist[F_GET_CHIP]=&get_chip; flist[F_GET_MODULE]=&get_module; flist[F_GET_THRESHOLD_ENERGY]=&get_threshold_energy; flist[F_SET_THRESHOLD_ENERGY]=&set_threshold_energy; flist[F_SET_SETTINGS]=&set_settings; flist[F_START_ACQUISITION]=&start_acquisition; flist[F_STOP_ACQUISITION]=&stop_acquisition; flist[F_START_READOUT]=&start_readout; flist[F_GET_RUN_STATUS]=&get_run_status; flist[F_READ_FRAME]=&read_frame; flist[F_READ_ALL]=&read_all; flist[F_START_AND_READ_ALL]=&start_and_read_all; flist[F_SET_TIMER]=&set_timer; flist[F_GET_TIME_LEFT]=&get_time_left; flist[F_SET_DYNAMIC_RANGE]=&set_dynamic_range; flist[F_SET_ROI]=&set_roi; flist[F_SET_SPEED]=&set_speed; flist[F_SET_READOUT_FLAGS]=&set_readout_flags; flist[F_EXECUTE_TRIMMING]=&execute_trimming; flist[F_LOCK_SERVER]=&lock_server; flist[F_SET_PORT]=&set_port; flist[F_GET_LAST_CLIENT_IP]=&get_last_client_ip; flist[F_UPDATE_CLIENT]=&update_client; flist[F_SET_MASTER]=&set_master; flist[F_SET_SYNCHRONIZATION_MODE]=&set_synchronization; #ifdef VERBOSE /* for (i=0;i<256;i++){ printf("function %d located at %x\n",i,flist[i]); }*/ #endif return OK; } int M_nofunc(int file_des){ int retval=FAIL; sprintf(mess,"Unrecognized Function\n"); printf(mess); sendDataOnly(file_des,&retval,sizeof(retval)); sendDataOnly(file_des,mess,sizeof(mess)); return GOODBYE; } int exit_server(int file_des) { int retval=FAIL; sendDataOnly(file_des,&retval,sizeof(retval)); printf("closing server."); sprintf(mess,"closing server"); sendDataOnly(file_des,mess,sizeof(mess)); return GOODBYE; } int exec_command(int file_des) { char cmd[MAX_STR_LENGTH]; char answer[MAX_STR_LENGTH]; int retval=OK; int sysret=0; int n=0; /* receive arguments */ n = receiveDataOnly(file_des,cmd,MAX_STR_LENGTH); if (n < 0) { sprintf(mess,"Error reading from socket\n"); retval=FAIL; } /* execute action if the arguments correctly arrived*/ if (retval==OK) { #ifdef VERBOSE printf("executing command %s\n", cmd); #endif if (lockStatus==0 || differentClients==0) sysret=system(cmd); //should be replaced by popen if (sysret==0) { sprintf(answer,"Succeeded\n"); if (lockStatus==1 && differentClients==1) sprintf(answer,"Detector locked by %s\n", lastClientIP); } else { sprintf(answer,"Failed\n"); retval=FAIL; } } else { sprintf(answer,"Could not receive the command\n"); } /* send answer */ n = sendDataOnly(file_des,&retval,sizeof(retval)); n = sendDataOnly(file_des,answer,MAX_STR_LENGTH); if (n < 0) { sprintf(mess,"Error writing to socket"); retval=FAIL; } /*return ok/fail*/ return retval; } int get_detector_type(int file_des) { int n=0; enum detectorType ret; int retval=OK; sprintf(mess,"Can't return detector type\n"); /* receive arguments */ /* execute action */ ret=myDetectorType; #ifdef VERBOSE printf("Returning detector type %d\n",ret); #endif /* send answer */ /* send OK/failed */ if (differentClients==1) retval=FORCE_UPDATE; n += sendDataOnly(file_des,&retval,sizeof(retval)); if (retval!=FAIL) { /* send return argument */ n += sendDataOnly(file_des,&ret,sizeof(ret)); } else { n += sendDataOnly(file_des,mess,sizeof(mess)); } /*return ok/fail*/ return retval; } int set_number_of_modules(int file_des) { int n; int arg[2], ret=0; int retval=OK; int dim, nm; sprintf(mess,"Can't set number of modules\n"); /* receive arguments */ n = receiveDataOnly(file_des,&arg,sizeof(arg)); if (n < 0) { sprintf(mess,"Error reading from socket %d", n); retval=GOODBYE; } if (retval==OK) { dim=arg[0]; nm=arg[1]; /* execute action */ #ifdef VERBOSE printf("Setting the number of modules in dimension %d to %d\n",dim,nm ); #endif //if (nm!=GET_FLAG) { if (dim!=X && nm!=GET_FLAG) { retval=FAIL; sprintf(mess,"Can't change module number in dimension %d\n",dim); } else { if (lockStatus==1 && differentClients==1 && nm!=GET_FLAG) { sprintf(mess,"Detector locked by %s\n", lastClientIP); retval=FAIL; } else { ret=setNMod(nm); if (nModX==nm || nm==GET_FLAG) { retval=OK; if (differentClients==1) retval=FORCE_UPDATE; } else retval=FAIL; } } } /*} else { if (dim==Y) { ret=nModY; } else if (dim==X) { ret=setNMod(-1); } } */ /* send answer */ /* send OK/failed */ n = sendDataOnly(file_des,&retval,sizeof(retval)); if (retval!=FAIL) { /* send return argument */ n += sendDataOnly(file_des,&ret,sizeof(ret)); } else { n += sendDataOnly(file_des,mess,sizeof(mess)); } /*return ok/fail*/ return retval; } int get_max_number_of_modules(int file_des) { int n; int ret; int retval=OK; enum dimension arg; sprintf(mess,"Can't get max number of modules\n"); /* receive arguments */ n = receiveDataOnly(file_des,&arg,sizeof(arg)); if (n < 0) { sprintf(mess,"Error reading from socket\n"); retval=FAIL; } /* execute action */ #ifdef VERBOSE printf("Getting the max number of modules in dimension %d \n",arg); #endif switch (arg) { case X: ret=getNModBoard(); break; case Y: ret=NMAXMODY; break; default: ret=FAIL; retval=FAIL; } #ifdef VERBOSE printf("Max number of module in dimension %d is %d\n",arg,ret ); #endif if (differentClients==1 && retval==OK) { retval=FORCE_UPDATE; } /* send answer */ /* send OK/failed */ n = sendDataOnly(file_des,&retval,sizeof(retval)); if (retval!=FAIL) { /* send return argument */ n += sendDataOnly(file_des,&ret,sizeof(ret)); } else { n += sendDataOnly(file_des,mess,sizeof(mess)); } /*return ok/fail*/ return retval; } //index 0 is in gate //index 1 is in trigger //index 2 is out gate //index 3 is out trigger int set_external_signal_flag(int file_des) { int n; int arg[2]; int ret=OK; int signalindex; enum externalSignalFlag flag, retval; sprintf(mess,"Can't set external signal flag\n"); /* receive arguments */ n = receiveDataOnly(file_des,&arg,sizeof(arg)); if (n < 0) { sprintf(mess,"Error reading from socket\n"); ret=FAIL; } retval=SIGNAL_OFF; if (ret==OK) { signalindex=arg[0]; flag=arg[1]; /* execute action */ switch (flag) { case GET_EXTERNAL_SIGNAL_FLAG: retval=getExtSignal(signalindex); break; default: if (differentClients==0 || lockStatus==0) { retval=setExtSignal(signalindex,flag); } else { if (lockStatus!=0) { ret=FAIL; sprintf(mess,"Detector locked by %s\n", lastClientIP); } } } #ifdef VERBOSE printf("Setting external signal %d to flag %d\n",signalindex,flag ); printf("Set to flag %d\n",retval); #endif } else { ret=FAIL; } if (ret==OK && differentClients!=0) ret=FORCE_UPDATE; /* send answer */ /* send OK/failed */ n = sendDataOnly(file_des,&ret,sizeof(ret)); if (ret!=FAIL) { /* send return argument */ n += sendDataOnly(file_des,&retval,sizeof(retval)); } else { n += sendDataOnly(file_des,mess,sizeof(mess)); } /*return ok/fail*/ return ret; } int set_external_communication_mode(int file_des) { int n; enum externalCommunicationMode arg, ret=GET_EXTERNAL_COMMUNICATION_MODE; int retval=OK; sprintf(mess,"Can't set external communication mode\n"); /* receive arguments */ n = receiveDataOnly(file_des,&arg,sizeof(arg)); if (n < 0) { sprintf(mess,"Error reading from socket\n"); retval=FAIL; } /* enum externalCommunicationMode{ GET_EXTERNAL_COMMUNICATION_MODE, AUTO, TRIGGER_EXPOSURE_SERIES, TRIGGER_EXPOSURE_BURST, TRIGGER_READOUT, TRIGGER_COINCIDENCE_WITH_INTERNAL_ENABLE, GATE_FIX_NUMBER, GATE_FIX_DURATION, GATE_WITH_START_TRIGGER, GATE_COINCIDENCE_WITH_INTERNAL_ENABLE }; */ if (retval==OK) { /* execute action */ ret=setTiming(arg); /* switch(arg) { */ /* default: */ /* sprintf(mess,"The meaning of single signals should be set\n"); */ /* retval=FAIL; */ /* } */ #ifdef VERBOSE printf("Setting external communication mode to %d\n", arg); #endif } else ret=FAIL; /* send answer */ /* send OK/failed */ n = sendDataOnly(file_des,&retval,sizeof(retval)); if (retval!=FAIL) { /* send return argument */ n += sendDataOnly(file_des,&ret,sizeof(ret)); } else { n += sendDataOnly(file_des,mess,sizeof(mess)); } /*return ok/fail*/ return retval; } int get_id(int file_des) { // sends back 64 bits! int64_t retval, rev, dat; int ret=OK; int imod=-1; int n=0; int rev1; enum idMode arg; sprintf(mess,"Can't return id\n"); /* receive arguments */ n = receiveDataOnly(file_des,&arg,sizeof(arg)); if (n < 0) { sprintf(mess,"Error reading from socket\n"); ret=FAIL; } #ifdef VERBOSE printf("Getting id %d\n", arg); #endif switch (arg) { case MODULE_SERIAL_NUMBER: n = receiveDataOnly(file_des,&imod,sizeof(imod)); if (n < 0) { sprintf(mess,"Error reading from socket\n"); retval=FAIL; } else { #ifdef VERBOSE printf("of module %d\n", imod); #endif if (imod>=0 && imod<=getNModBoard()) { #ifdef MCB_FUNCS retval=getModuleNumber(imod); #endif ; } else { sprintf(mess,"Module number %d out of range\n",imod); ret=FAIL; } } break; case MODULE_FIRMWARE_VERSION: retval=0x1; break; case DETECTOR_SERIAL_NUMBER: retval=getMcsNumber(); break; case DETECTOR_FIRMWARE_VERSION: retval=getMcsVersion(); break; case DETECTOR_SOFTWARE_VERSION: sscanf(THIS_REVISION,"$Rev : %x",&rev1); rev=((int64_t)rev1); dat=THIS_SOFTWARE_VERSION; retval=(dat<<32) | rev; break; default: printf("Required unknown id %d \n", arg); ret=FAIL; retval=FAIL; } #ifdef VERBOSE printf("Id is %llx\n", retval); #endif if (differentClients==1) ret=FORCE_UPDATE; /* send answer */ /* send OK/failed */ n = sendDataOnly(file_des,&ret,sizeof(ret)); if (ret!=FAIL) { /* send return argument */ n += sendDataOnly(file_des,&retval,sizeof(retval)); } else { n += sendDataOnly(file_des,mess,sizeof(mess)); } /*return ok/fail*/ return ret; } int digital_test(int file_des) { int retval; int ret=OK; int imod=-1; int n=0; int ibit=0; int ow; enum digitalTestMode arg; sprintf(mess,"Can't send digital test\n"); n = receiveDataOnly(file_des,&arg,sizeof(arg)); if (n < 0) { sprintf(mess,"Error reading from socket\n"); ret=FAIL; } #ifdef VERBOSE printf("Digital test mode %d\n",arg ); #endif switch (arg) { case CHIP_TEST: n = receiveDataOnly(file_des,&imod,sizeof(imod)); if (n < 0) { sprintf(mess,"Error reading from socket\n"); retval=FAIL; } #ifdef VERBOSE printf("of module %d\n", imod); #endif retval=0; #ifdef MCB_FUNCS if (differentClients==1 && lockStatus==1) { ret=FAIL; sprintf(mess,"Detector locked by %s\n",lastClientIP); break; } if (imod >= nModX) { ret=FAIL; sprintf(mess,"Module %d disabled\n",imod); break; } if (testShiftIn(imod)) retval|=(1<<(ibit)); ibit++; if (testShiftOut(imod)) retval|=(1<<(ibit)); ibit++; if (testShiftStSel(imod)) retval|=(1<<(ibit)); ibit++; //if ( testDataInOut(0x123456, imod)) retval|=(1<<(ibit++)); //if ( testExtPulse(imod)) retval|=(1<<(ibit++)); // for (ow=0; ow<6; ow++) // ow=1; //#ifndef PICASSOD for (ow=0; ow<5; ow++) { //#endif if (testDataInOutMux(imod, ow, 0x789abc)) retval|=(1<=getNModBoard()) ret=FAIL; if (imod<0) imod=ALLMOD; #ifdef MCB_FUNCS switch (ind) { case TRIMBIT_SIZE: idac=VTRIM; break; case THRESHOLD: idac=VTHRESH; break; case SHAPER1: idac=RGSH1; break; case SHAPER2: idac=RGSH2; break; case CALIBRATION_PULSE: idac=VCAL; break; case PREAMP: idac=RGPR; break; /*************************************************************** add possible potentiometers like in chiptest board!!!!!!!!!!!!!!! ****************************************************************/ default: printf("Unknown DAC index %d\n",ind); sprintf(mess,"Unknown DAC index %d\n",ind); ret=FAIL; } if (ret==OK) { if (differentClients==1 && lockStatus==1 && val!=-1) { ret=FAIL; sprintf(mess,"Detector locked by %s\n",lastClientIP); } else retval=initDACbyIndexDACU(idac,val,imod); } #endif #ifdef VERBOSE printf("DAC set to %f V\n", retval); #endif if (retval==val || val==-1) { ret=OK; if (differentClients) ret=FORCE_UPDATE; } else { ret=FAIL; printf("Setting dac %d of module %d: wrote %f but read %f\n", ind, imod, val, retval); } /* send answer */ /* send OK/failed */ n = sendDataOnly(file_des,&ret,sizeof(ret)); if (ret!=FAIL) { /* send return argument */ n += sendDataOnly(file_des,&retval,sizeof(retval)); } else { n += sendDataOnly(file_des,mess,sizeof(mess)); } /* Maybe this is done inside the initialization funcs */ //detectorDacs[imod][ind]=val; /*return ok/fail*/ return ret; } int get_adc(int file_des) { dacs_t retval; int ret=OK; int arg[2]; enum dacIndex ind; int imod; int n; int idac=0; sprintf(mess,"Can't read ADC\n"); n = receiveDataOnly(file_des,arg,sizeof(arg)); if (n < 0) { sprintf(mess,"Error reading from socket\n"); ret=FAIL; } ind=arg[0]; imod=arg[1]; if (imod>=getNModBoard() || imod<0) ret=FAIL; #ifdef MCB_FUNCS switch (ind) { case TRIMBIT_SIZE: idac=VTRIM; break; case THRESHOLD: idac=VTHRESH; break; case SHAPER1: idac=RGSH1; break; case SHAPER2: idac=RGSH2; break; case CALIBRATION_PULSE: idac=VCAL; break; case PREAMP: idac=RGPR; break; default: printf("Unknown DAC index %d\n",ind); ret=FAIL; sprintf(mess,"Unknown DAC index %d\n",ind); } if (ret==OK) { retval=getDACbyIndexDACU(idac,imod); } #endif #ifdef VERBOSE printf("Getting ADC %d of module %d\n", ind, imod); #endif #ifdef VERBOSE printf("ADC is %f V\n", retval); #endif if (ret==FAIL) { printf("Getting adc %d of module %d failed\n", ind, imod); } if (differentClients) ret=FORCE_UPDATE; /* send answer */ /* send OK/failed */ n = sendDataOnly(file_des,&ret,sizeof(ret)); if (ret!=FAIL) { /* send return argument */ n += sendDataOnly(file_des,&retval,sizeof(retval)); } else { n += sendDataOnly(file_des,mess,sizeof(mess)); } /*return ok/fail*/ return ret; } int set_channel(int file_des) { int ret=OK; sls_detector_channel myChan; int retval; int n; sprintf(mess,"Can't set channel\n"); #ifdef VERBOSE printf("Setting channel\n"); #endif ret=receiveChannel(file_des, &myChan); if (ret>=0) ret=OK; else ret=FAIL; #ifdef VERBOSE printf("channel number is %d, chip number is %d, module number is %d, register is %lld\n", myChan.chan,myChan.chip, myChan.module, myChan.reg); #endif if (ret==OK) { if (myChan.module>=getNModBoard()) ret=FAIL; if (myChan.chip>=NCHIP) ret=FAIL; if (myChan.chan>=NCHAN) ret=FAIL; if (myChan.module<0) myChan.module=ALLMOD; } if (ret==OK) { if (differentClients==1 && lockStatus==1) { ret=FAIL; sprintf(mess,"Detector locked by %s\n",lastClientIP); } else { #ifdef MCB_FUNCS retval=initChannelbyNumber(myChan); #endif } } /* Maybe this is done inside the initialization funcs */ //copyChannel(detectorChans[myChan.module][myChan.chip]+(myChan.chan), &myChan); if (differentClients==1 && ret==OK) ret=FORCE_UPDATE; /* send answer */ /* send OK/failed */ n = sendDataOnly(file_des,&ret,sizeof(ret)); if (ret!=FAIL) { /* send return argument */ n += sendDataOnly(file_des,&retval,sizeof(retval)); } else { n += sendDataOnly(file_des,mess,sizeof(mess)); } /*return ok/fail*/ return ret; } int get_channel(int file_des) { int ret=OK; sls_detector_channel retval; int arg[3]; int ichan, ichip, imod; int n; sprintf(mess,"Can't get channel\n"); n = receiveDataOnly(file_des,arg,sizeof(arg)); if (n < 0) { sprintf(mess,"Error reading from socket\n"); ret=FAIL; } ichan=arg[0]; ichip=arg[1]; imod=arg[2]; if (ret==OK) { ret=FAIL; if (imod>=0 && imod=0 && ichip=0 && ichan=0) ret=OK; else ret=FAIL; #ifdef VERBOSE printf("chip number is %d, module number is %d, register is %d, nchan %d\n",myChip.chip, myChip.module, myChip.reg, myChip.nchan); #endif if (ret==OK) { if (myChip.module>=getNModBoard()) ret=FAIL; if (myChip.module<0) myChip.module=ALLMOD; if (myChip.chip>=NCHIP) ret=FAIL; } if (differentClients==1 && lockStatus==1) { ret=FAIL; sprintf(mess,"Detector locked by %s\n",lastClientIP); } else { #ifdef MCB_FUNCS retval=initChipbyNumber(myChip); #endif } /* Maybe this is done inside the initialization funcs */ //copyChip(detectorChips[myChip.module]+(myChip.chip), &myChip); if (differentClients && ret==OK) ret=FORCE_UPDATE; /* send answer */ /* send OK/failed */ n = sendDataOnly(file_des,&ret,sizeof(ret)); if (ret!=FAIL) { /* send return argument */ n += sendDataOnly(file_des,&retval,sizeof(retval)); } else { n += sendDataOnly(file_des,mess,sizeof(mess)); } return ret; } int get_chip(int file_des) { int ret=OK; sls_detector_chip retval; int arg[2]; int ichip, imod; int n; n = receiveDataOnly(file_des,arg,sizeof(arg)); if (n < 0) { sprintf(mess,"Error reading from socket\n"); ret=FAIL; } ichip=arg[0]; imod=arg[1]; if (ret==OK) { ret=FAIL; if (imod>=0 && imod=0 && ichip=0) ret=OK; else ret=FAIL; #ifdef VERBOSE printf("module number is %d,register is %d, nchan %d, nchip %d, ndac %d, nadc %d, gain %f, offset %f\n",myModule.module, myModule.reg, myModule.nchan, myModule.nchip, myModule.ndac, myModule.nadc, myModule.gain,myModule.offset); #endif if (ret==OK) { if (myModule.module>=getNModBoard()) { ret=FAIL; printf("Module number is too large %d\n",myModule.module); } if (myModule.module<0) myModule.module=ALLMOD; } if (ret==OK) { if (differentClients==1 && lockStatus==1) { ret=FAIL; sprintf(mess,"Detector locked by %s\n",lastClientIP); } else { #ifdef MCB_FUNCS retval=initModulebyNumber(myModule); #endif } } if (differentClients==1 && ret==OK) ret=FORCE_UPDATE; /* Maybe this is done inside the initialization funcs */ //copyChip(detectorChips[myChip.module]+(myChip.chip), &myChip); /* send answer */ /* send OK/failed */ n = sendDataOnly(file_des,&ret,sizeof(ret)); if (ret!=FAIL) { /* send return argument */ n += sendDataOnly(file_des,&retval,sizeof(retval)); } else { n += sendDataOnly(file_des,mess,sizeof(mess)); } free(myChip); free(myChan); free(myDac); free(myAdc); setDynamicRange(dr); return ret; } int get_module(int file_des) { int ret=OK; int arg; int imod; int n; sls_detector_module myModule; int *myChip=malloc(NCHIP*sizeof(int)); int *myChan=malloc(NCHIP*NCHAN*sizeof(int)); dacs_t *myDac=malloc(NDAC*sizeof(dacs_t)); dacs_t *myAdc=malloc(NADC*sizeof(dacs_t)); if (myDac) myModule.dacs=myDac; else { sprintf(mess,"could not allocate dacs\n"); ret=FAIL; } if (myAdc) myModule.adcs=myAdc; else { sprintf(mess,"could not allocate adcs\n"); ret=FAIL; } if (myChip) myModule.chipregs=myChip; else { sprintf(mess,"could not allocate chips\n"); ret=FAIL; } if (myChan) myModule.chanregs=myChan; else { sprintf(mess,"could not allocate chans\n"); ret=FAIL; } myModule.ndac=NDAC; myModule.nchip=NCHIP; myModule.nchan=NCHAN*NCHIP; myModule.nadc=NADC; n = receiveDataOnly(file_des,&arg,sizeof(arg)); if (n < 0) { sprintf(mess,"Error reading from socket\n"); ret=FAIL; } imod=arg; if (ret==OK) { ret=FAIL; if (imod>=0 && imod-2) { dataret=FAIL; sprintf(mess,"no data and run stopped: %d frames left\n",getFrames()+2); printf("%s\n",mess); } else { dataret=FINISHED; sprintf(mess,"acquisition successfully finished\n"); printf("%s\n",mess); } #ifdef VERYVERBOSE printf("%d %d %x %s\n",sizeof(mess),strlen(mess), mess,mess); #endif sendDataOnly(file_des,&dataret,sizeof(dataret)); sendDataOnly(file_des,mess,sizeof(mess));//sizeof(mess));//sizeof(mess)); #ifdef VERYVERBOSE printf("message sent\n",mess); #endif printf("dataret %d\n",dataret); return dataret; } } else { nframes=0; while(fifo_read_event()) { nframes++; } dataretval=(char*)ram_values; dataret=OK; #ifdef VERBOSE printf("sending data of %d frames\n",nframes); #endif for (iframes=0; iframes-2) { dataret=FAIL; sprintf(mess,"no data and run stopped: %d frames left\n",getFrames()+2); printf("%s\n",mess); } else { dataret=FINISHED; sprintf(mess,"acquisition successfully finished\n"); printf("%s\n",mess); if (differentClients) dataret=FORCE_UPDATE; } #ifdef VERBOSE printf("Frames left %d\n",getFrames()); #endif sendDataOnly(file_des,&dataret,sizeof(dataret)); sendDataOnly(file_des,mess,sizeof(mess)); printf("dataret %d\n",dataret); return dataret; } printf("dataret %d\n",dataret); return dataret; } int read_all(int file_des) { while(read_frame(file_des)==OK) { #ifdef VERBOSE printf("frame read\n"); #endif ; } #ifdef VERBOSE printf("Frames finished\n"); #endif return OK; } int start_and_read_all(int file_des) { //int dataret=OK; #ifdef VERBOSE printf("Starting and reading all frames\n"); #endif if (differentClients==1 && lockStatus==1) { dataret=FAIL; sprintf(mess,"Detector locked by %s\n",lastClientIP); sendDataOnly(file_des,&dataret,sizeof(dataret)); sendDataOnly(file_des,mess,sizeof(mess)); return dataret; } startStateMachine(); /* ret=startStateMachine(); if (ret!=OK) { sprintf(mess,"could not start state machine\n"); sendDataOnly(file_des,&ret,sizeof(ret)); sendDataOnly(file_des,mess,sizeof(mess)); #ifdef VERBOSE printf("could not start state machine\n"); #endif } else {*/ read_all(file_des); #ifdef VERBOSE printf("Frames finished\n"); #endif //} return OK; } int set_timer(int file_des) { enum timerIndex ind; int64_t tns; int n; int64_t retval; int ret=OK; sprintf(mess,"can't set timer\n"); n = receiveDataOnly(file_des,&ind,sizeof(ind)); if (n < 0) { sprintf(mess,"Error reading from socket\n"); ret=FAIL; } n = receiveDataOnly(file_des,&tns,sizeof(tns)); if (n < 0) { sprintf(mess,"Error reading from socket\n"); ret=FAIL; } if (ret!=OK) { printf(mess); } #ifdef VERBOSE printf("setting timer %d to %lld ns\n",ind,tns); #endif if (ret==OK) { if (differentClients==1 && lockStatus==1 && tns!=-1) { ret=FAIL; sprintf(mess,"Detector locked by %s\n",lastClientIP); } else { switch(ind) { case FRAME_NUMBER: retval=setFrames(tns); break; case ACQUISITION_TIME: retval=setExposureTime(tns); break; case FRAME_PERIOD: retval=setPeriod(tns); break; case DELAY_AFTER_TRIGGER: retval=setDelay(tns); break; case GATES_NUMBER: retval=setGates(tns); break; case PROBES_NUMBER: retval=setProbes(tns); break; case CYCLES_NUMBER: retval=setTrains(tns); break; default: ret=FAIL; sprintf(mess,"timer index unknown %d\n",ind); } } } if (ret!=OK) { printf(mess); if (differentClients) ret=FORCE_UPDATE; } if (ret!=OK) { printf(mess); printf("set timer failed\n"); sprintf(mess, "set timer %d failed\n", ind); } else if (ind==FRAME_NUMBER) { ret=allocateRAM(); if (ret!=OK) sprintf(mess, "could not allocate RAM for %lld frames\n", tns); } n = sendDataOnly(file_des,&ret,sizeof(ret)); if (ret==FAIL) { n = sendDataOnly(file_des,mess,sizeof(mess)); } else { #ifdef VERBOSE printf("returning ok %d\n",sizeof(retval)); #endif n = sendDataOnly(file_des,&retval,sizeof(retval)); } return ret; } int get_time_left(int file_des) { enum timerIndex ind; int n; int64_t retval; int ret=OK; sprintf(mess,"can't get timer\n"); n = receiveDataOnly(file_des,&ind,sizeof(ind)); if (n < 0) { sprintf(mess,"Error reading from socket\n"); ret=FAIL; } #ifdef VERBOSE printf("getting time left on timer %d \n",ind); #endif if (ret==OK) { switch(ind) { case FRAME_NUMBER: retval=getFrames(); break; case ACQUISITION_TIME: retval=getExposureTime(); break; case FRAME_PERIOD: retval=getPeriod(); break; case DELAY_AFTER_TRIGGER: retval=getDelay(); break; case GATES_NUMBER: retval=getGates(); break; case PROBES_NUMBER: retval=getProbes(); break; case CYCLES_NUMBER: retval=getTrains(); break; case PROGRESS: retval=getProgress(); break; case ACTUAL_TIME: retval=getActualTime(); break; case MEASUREMENT_TIME: retval=getMeasurementTime(); break; default: ret=FAIL; sprintf(mess,"timer index unknown %d\n",ind); } } if (ret!=OK) { printf("get time left failed\n"); } else if (differentClients) ret=FORCE_UPDATE; #ifdef VERBOSE printf("time left on timer %d is %lld\n",ind, retval); #endif n = sendDataOnly(file_des,&ret,sizeof(ret)); if (ret==FAIL) { n += sendDataOnly(file_des,mess,sizeof(mess)); } else { n = sendDataOnly(file_des,&retval,sizeof(retval)); } #ifdef VERBOSE printf("data sent\n"); #endif return ret; } int set_dynamic_range(int file_des) { int dr; int n; int retval; int ret=OK; sprintf(mess,"can't set dynamic range\n"); n = receiveDataOnly(file_des,&dr,sizeof(dr)); if (n < 0) { sprintf(mess,"Error reading from socket\n"); ret=FAIL; } if (differentClients==1 && lockStatus==1 && dr>=0) { ret=FAIL; sprintf(mess,"Detector locked by %s\n",lastClientIP); } else { retval=setDynamicRange(dr); } if (dr>=0 && retval!=dr) ret=FAIL; if (ret!=OK) { sprintf(mess,"set dynamic range failed\n"); } else { ret=allocateRAM(); if (ret!=OK) sprintf(mess,"Could not allocate RAM for the dynamic range selected\n"); else if (differentClients) ret=FORCE_UPDATE; } n = sendDataOnly(file_des,&ret,sizeof(ret)); if (ret==FAIL) { n = sendDataOnly(file_des,mess,sizeof(mess)); } else { n = sendDataOnly(file_des,&retval,sizeof(retval)); } return ret; } int set_roi(int file_des) { int arg=-1; int n; ROI roiLimits[MAX_ROIS]; int ret=OK; ROI retval; int nm=setNMod(-1), nmax=getNModBoard(), nroi; sprintf(mess,"can't set ROI\n"); n = receiveDataOnly(file_des,&arg,sizeof(arg)); if(arg>0){ n+=receiveDataOnly(file_des,roiLimits,arg*sizeof(ROI)); } if (arg>1) { ret=FAIL; sprintf(mess,"can't set more than 1 ROI per detector\n"); } else ret=OK; if (arg>0) { nm=(roiLimits[0].xmax-1)/1280+1; if (roiLimits[0].xmin>0) { roiLimits[0].xmin=0; ret=FAIL; sprintf(mess,"ROI starts at 0\n"); } if (nm>nmax) { retval.xmax=setNMod(-1)*1280; ret=FAIL; sprintf(mess,"ROI max larger than detector size\n"); } } else if (arg==0) { setNMod(nmax); } n = sendDataOnly(file_des,&ret,sizeof(ret)); if (ret==FAIL) { n = sendDataOnly(file_des,mess,sizeof(mess)); } else { retval.xmin=0; retval.xmax=setNMod(-1)*1280; retval.ymin=0; retval.ymax=0; if (setNMod(-1)=0) { if (differentClients==1 && lockStatus==1 && val>=0) { ret=FAIL; sprintf(mess,"Detector locked by %s\n",lastClientIP); } else { switch (arg) { case CLOCK_DIVIDER: retval=setClockDivider(val); break; case WAIT_STATES: retval=setWaitStates(val); break; case SET_SIGNAL_LENGTH: retval=setSetLength(val); break; case TOT_CLOCK_DIVIDER: retval=setTotClockDivider(val); break; case TOT_DUTY_CYCLE: retval=setTotDutyCycle(val); break; default: ret=FAIL; } } } else { switch (arg) { case CLOCK_DIVIDER: retval=getClockDivider(); break; case WAIT_STATES: retval=getWaitStates(); break; case SET_SIGNAL_LENGTH: retval=getSetLength(); break; case TOT_CLOCK_DIVIDER: retval=getTotClockDivider(); break; case TOT_DUTY_CYCLE: retval=getTotDutyCycle(); break; default: ret=FAIL; } } } n = sendDataOnly(file_des,&ret,sizeof(ret)); if (ret==FAIL) { n = sendDataOnly(file_des,mess,sizeof(mess)); } else { n = sendDataOnly(file_des,&retval,sizeof(retval)); } return ret; } int set_readout_flags(int file_des) { enum readOutFlags retval; enum readOutFlags arg; int n; int ret=OK; int regret=OK; sprintf(mess,"can't set readout flags\n"); n = receiveDataOnly(file_des,&arg,sizeof(arg)); if (n < 0) { sprintf(mess,"Error reading from socket\n"); ret=FAIL; } #ifdef VERBOSE printf("setting readout flags to %d\n",arg); #endif if (differentClients==1 && lockStatus==1 && arg!=GET_READOUT_FLAGS) { ret=FAIL; sprintf(mess,"Detector locked by %s\n",lastClientIP); } else { //ret=setStoreInRAM(0); // initChipWithProbes(0,0,0, ALLMOD); switch(arg) { case GET_READOUT_FLAGS: break; case STORE_IN_RAM: if (setStoreInRAM(1)==OK) ret=OK; else ret=FAIL; break; case TOT_MODE: if(setToT(1)) ret=OK; else ret=FAIL; break; case CONTINOUS_RO: if (setContinousReadOut(1)) ret=OK; else ret=FAIL; break; // case PUMP_PROBE_MODE: //set number of probes //initChipWithProbes(0,0,2, ALLMOD); //break; default: ret=setStoreInRAM(0); regret=setConfigurationRegister(0); ret=OK; } } retval=NORMAL_READOUT; if (storeInRAM) retval=STORE_IN_RAM; //else if (getProbes()) // retval=PUMP_PROBE_MODE; //else if (setToT(-1)) retval|=TOT_MODE; if (setContinousReadOut(-1)) retval|=CONTINOUS_RO; if (ret!=OK) { printf("set readout flags failed\n"); sprintf(mess,"Could not allocate RAM\n"); } else if (differentClients) ret=FORCE_UPDATE; n = sendDataOnly(file_des,&ret,sizeof(ret)); if (ret==FAIL) { n = sendDataOnly(file_des,mess,sizeof(mess)); } else { n = sendDataOnly(file_des,&retval,sizeof(retval)); } return ret; } int execute_trimming(int file_des) { int arg[3]; int n; int ret=OK; int imod, par1,par2; enum trimMode mode; printf("called function execute trimming\n"); sprintf(mess,"can't set execute trimming\n"); n = receiveDataOnly(file_des,&mode,sizeof(mode)); printf("mode received\n"); if (n < 0) { sprintf(mess,"Error reading from socket\n"); printf("Error reading from socket (mode)\n"); ret=FAIL; } n = receiveDataOnly(file_des,arg,sizeof(arg)); printf("arg received\n"); if (n < 0) { sprintf(mess,"Error reading from socket\n"); printf("Error reading from socket (args)\n"); ret=FAIL; } imod=arg[0]; if (imod>=getNModBoard()) ret=FAIL; if (imod<0) imod=ALLMOD; par1=arg[1]; par2=arg[2]; #ifdef VERBOSE printf("trimming module %d mode %d, parameters %d %d \n",imod,mode, par1, par2); #endif if (differentClients==1 && lockStatus==1 ) { ret=FAIL; sprintf(mess,"Detector locked by %s\n",lastClientIP); } else { if (ret==OK) { switch(mode) { case NOISE_TRIMMING: // par1 is countlim; par2 is nsigma ret=trim_with_noise(par1, par2, imod); break; case BEAM_TRIMMING: // par1 is countlim; par2 is nsigma ret=trim_with_beam(par1,par2,imod); break; case IMPROVE_TRIMMING: // par1 is maxit; if par2!=0 vthresh will be optimized ret=trim_improve(par1, par2,imod); break; case FIXEDSETTINGS_TRIMMING: // par1 is countlim; if par2<0 then trimwithlevel else trim with median ret=trim_fixed_settings(par1,par2,imod); break; // case OFFLINE_TRIMMING: //break; default: printf("Unknown trimming mode\n"); sprintf(mess,"Unknown trimming mode\n"); ret=FAIL; } } } if (ret<0) { sprintf(mess,"can't set execute trimming\n"); ret=FAIL; } else if (ret>0) { sprintf(mess,"Could not trim %d channels\n", ret); ret=FAIL; } else if (differentClients) ret=FORCE_UPDATE; n = sendDataOnly(file_des,&ret,sizeof(ret)); if (ret==FAIL) { n = sendDataOnly(file_des,mess,sizeof(mess)); } return ret; } int lock_server(int file_des) { int n; int ret=OK; int lock; n = receiveDataOnly(file_des,&lock,sizeof(lock)); if (n < 0) { sprintf(mess,"Error reading from socket\n"); printf("Error reading from socket (lock)\n"); ret=FAIL; } if (lock>=0) { if (lockStatus==0 || strcmp(lastClientIP,thisClientIP)==0 || strcmp(lastClientIP,"none")==0) { lockStatus=lock; } else { ret=FAIL; sprintf(mess,"Server already locked by %s\n", lastClientIP); } } if (differentClients && ret==OK) ret=FORCE_UPDATE; n = sendDataOnly(file_des,&ret,sizeof(ret)); if (ret==FAIL) { n = sendDataOnly(file_des,mess,sizeof(mess)); } else n = sendDataOnly(file_des,&lockStatus,sizeof(lockStatus)); return ret; } int set_port(int file_des) { int n; int ret=OK; int sd=-1; enum portType p_type; /** data? control? stop? Unused! */ int p_number; /** new port number */ n = receiveDataOnly(file_des,&p_type,sizeof(p_type)); if (n < 0) { sprintf(mess,"Error reading from socket\n"); printf("Error reading from socket (ptype)\n"); ret=FAIL; } n = receiveDataOnly(file_des,&p_number,sizeof(p_number)); if (n < 0) { sprintf(mess,"Error reading from socket\n"); printf("Error reading from socket (pnum)\n"); ret=FAIL; } if (differentClients==1 && lockStatus==1 ) { ret=FAIL; sprintf(mess,"Detector locked by %s\n",lastClientIP); } else { if (p_number<1024) { sprintf(mess,"Too low port number %d\n", p_number); printf("\n"); ret=FAIL; } printf("set port %d to %d\n",p_type, p_number); sd=bindSocket(p_number); } if (sd>=0 || sd==-10) { ret=OK; if (differentClients ) ret=FORCE_UPDATE; } else { ret=FAIL; sprintf(mess,"Could not bind port %d\n", p_number); printf("Could not bind port %d\n", p_number); } n = sendDataOnly(file_des,&ret,sizeof(ret)); if (ret==FAIL) { n = sendDataOnly(file_des,mess,sizeof(mess)); } else { n = sendDataOnly(file_des,&p_number,sizeof(p_number)); if (sd>=0) { closeConnection(file_des); exitServer(sockfd); sockfd=sd; } } return ret; } int get_last_client_ip(int file_des) { int ret=OK; int n; if (differentClients ) ret=FORCE_UPDATE; n = sendDataOnly(file_des,&ret,sizeof(ret)); n = sendDataOnly(file_des,lastClientIP,sizeof(lastClientIP)); return ret; } int send_update(int file_des) { int ret=OK; enum detectorSettings t; int thr, n; // int it; int64_t retval, tns=-1; n = sendDataOnly(file_des,lastClientIP,sizeof(lastClientIP)); n = sendDataOnly(file_des,&nModX,sizeof(nModX)); // n = sendDataOnly(file_des,&nModY,sizeof(nModY)); //sends back max modules instead of nmodulesY! thr = getNModBoard(); sendDataOnly(file_des,&thr,sizeof(thr)); n = sendDataOnly(file_des,&dynamicRange,sizeof(dynamicRange)); n = sendDataOnly(file_des,&dataBytes,sizeof(dataBytes)); t=setSettings(GET_SETTINGS); n = sendDataOnly(file_des,&t,sizeof(t)); thr=getThresholdEnergy(); n = sendDataOnly(file_des,&thr,sizeof(thr)); retval=setFrames(tns); n = sendDataOnly(file_des,&retval,sizeof(int64_t)); retval=setExposureTime(tns); n = sendDataOnly(file_des,&retval,sizeof(int64_t)); retval=setPeriod(tns); n = sendDataOnly(file_des,&retval,sizeof(int64_t)); retval=setDelay(tns); n = sendDataOnly(file_des,&retval,sizeof(int64_t)); retval=setGates(tns); n = sendDataOnly(file_des,&retval,sizeof(int64_t)); retval=setProbes(tns); n = sendDataOnly(file_des,&retval,sizeof(int64_t)); retval=setTrains(tns); n = sendDataOnly(file_des,&retval,sizeof(int64_t)); if (lockStatus==0) { strcpy(lastClientIP,thisClientIP); } return ret; } int update_client(int file_des) { int ret=OK; sendDataOnly(file_des,&ret,sizeof(ret)); return send_update(file_des); } int set_master(int file_des) { enum masterFlags retval=GET_MASTER; enum masterFlags arg; int n; int ret=OK; // int regret=OK; sprintf(mess,"can't set master flags\n"); n = receiveDataOnly(file_des,&arg,sizeof(arg)); if (n < 0) { sprintf(mess,"Error reading from socket\n"); ret=FAIL; } #ifdef VERBOSE printf("setting master flags to %d\n",arg); #endif if (differentClients==1 && lockStatus==1 && arg!=GET_READOUT_FLAGS) { ret=FAIL; sprintf(mess,"Detector locked by %s\n",lastClientIP); } else { retval=setMaster(arg); } if (retval==GET_MASTER) { ret=FAIL; } n = sendDataOnly(file_des,&ret,sizeof(ret)); if (ret==FAIL) { n = sendDataOnly(file_des,mess,sizeof(mess)); } else { n = sendDataOnly(file_des,&retval,sizeof(retval)); } return ret; } int set_synchronization(int file_des) { enum synchronizationMode retval=GET_MASTER; enum synchronizationMode arg; int n; int ret=OK; //int regret=OK; sprintf(mess,"can't set synchronization mode\n"); n = receiveDataOnly(file_des,&arg,sizeof(arg)); if (n < 0) { sprintf(mess,"Error reading from socket\n"); ret=FAIL; } #ifdef VERBOSE printf("setting master flags to %d\n",arg); #endif if (differentClients==1 && lockStatus==1 && arg!=GET_READOUT_FLAGS) { ret=FAIL; sprintf(mess,"Detector locked by %s\n",lastClientIP); } else { //ret=setStoreInRAM(0); // initChipWithProbes(0,0,0, ALLMOD); retval=setSynchronization(arg); } if (retval==GET_SYNCHRONIZATION_MODE) { ret=FAIL; } n = sendDataOnly(file_des,&ret,sizeof(ret)); if (ret==FAIL) { n = sendDataOnly(file_des,mess,sizeof(mess)); } else { n = sendDataOnly(file_des,&retval,sizeof(retval)); } return ret; }