#include "sls_detector_defs.h" #include "sls_receiver_defs.h" #include "server_funcs.h" #include "server_defs.h" #include "firmware_funcs.h" #include "mcb_funcs.h" #include "registers_m.h" #include "gitInfoJungfrau.h" extern int nModX; extern int nModY; extern size_t dataBytes; extern int nSamples; extern int dynamicRange; extern int storeInRAM; extern int lockStatus; extern char lastClientIP[INET_ADDRSTRLEN]; extern char thisClientIP[INET_ADDRSTRLEN]; extern int differentClients; extern unsigned int *ram_values; //defined in the detector specific file #ifdef MYTHEND const enum detectorType myDetectorType=MYTHEN; #elif PROPIXD const enum detectorType myDetectorType=PROPIX; #elif GOTTHARDD const enum detectorType myDetectorType=GOTTHARD; #elif EIGERD const enum detectorType myDetectorType=EIGER; #elif PICASSOD const enum detectorType myDetectorType=PICASSO; #elif MOENCHD const enum detectorType myDetectorType=MOENCH; #elif JUNGFRAUD const enum detectorType myDetectorType=JUNGFRAU; #else const enum detectorType myDetectorType=GENERIC; #endif // Global variables int (*flist[256])(int); char *dataretval=NULL; int nframes, iframes, dataret; char mess[MAX_STR_LENGTH]; int digitalTestBit = 0; int adcvpp=0x4; int init_detector(int b) { int i; if (mapCSP0()==FAIL) { printf("Could not map memory\n"); exit(1); } //------control server ------- if (b) { //printf("Bus test... "); for (i=0; i<1000000; i++) { bus_w(SET_DELAY_LSB_REG, i*100); bus_r(FPGA_VERSION_REG); if (i*100!=bus_r(SET_DELAY_LSB_REG)) cprintf(RED,"Bus Test ERROR: wrote 0x%x, read 0x%x\n",i*100,bus_r(SET_DELAY_LSB_REG)); } //printf("Finished\n"); //confirm the detector type if (((bus_r(PCB_REV_REG) & DETECTOR_TYPE_MASK)>>DETECTOR_TYPE_OFFSET) != JUNGFRAU_MODULE_ID){ cprintf(BG_RED,"This is not a Jungfrau Server (enum:%d)\n",myDetectorType); exit(-1); } cprintf(BLUE,"\n\n********************************************************\n" "*********************Jungfrau Server********************\n" "********************************************************\n"); //print version cprintf(BLUE,"\n" "Firmware Version:\t 0x%x\n" "Software Version:\t %llx\n" //"F/w-S/w API Version:\t\t %lld\n" //"Required Firmware Version:\t %d\n" "Fixed Pattern:\t\t 0x%x\n" "Board Revision:\t\t 0x%x\n" "\n********************************************************\n", bus_r(FPGA_VERSION_REG),(long long unsigned int)(((int64_t)SVNREV <<32) | (int64_t)SVNDATE) //,sw_fw_apiversion, REQUIRED_FIRMWARE_VERSION ,bus_r(FIX_PATT_REG),(bus_r(PCB_REV_REG)&BOARD_REVISION_MASK) ); printf("Resetting PLL\n"); resetPLL(); bus_w16(CONTROL_REG, SYNC_RESET); bus_w16(CONTROL_REG, 0); bus_w16(CONTROL_REG, GB10_RESET_BIT); bus_w16(CONTROL_REG, 0); #ifdef MCB_FUNCS initDetector(); #endif printf("Initializing Detector\n"); /*some registers set, which is in common with jungfrau, please check */ prepareADC(); /*some registers set, which is in common with jungfrau, please check */ initDac(0); initDac(8); //initializes the two dacs //set dacs printf("Setting Default Dac values\n"); enum dacNames{VB_COMP,VDD_PROT,VIN_COM,VREF_PRECH,VB_PIXBUF,VB_DS,VREF_DS,VREF_COMP}; int retval = -1; int dacvalues[14][2]={ {VB_DS, 1000}, {VB_COMP, 1220}, {VB_PIXBUF, 750}, {VREF_DS, 480}, {VREF_COMP, 400}, {VREF_PRECH,1550}, {VIN_COM, 1053}, {VDD_PROT, 3000}, }; for(i=0;i<8;++i){ retval=setDac(dacvalues[i][0], dacvalues[i][1]); if(retval!=dacvalues[i][1]) printf("Error: Setting dac %d failed, wrote %d, read %d\n",dacvalues[i][0],dacvalues[i][1],retval); } printf("\nPowering on the chip\n"); bus_w(POWER_ON_REG,0x1); printf("\nResetting ADC\n"); writeADC(ADCREG1,0x3); writeADC(ADCREG1,0x0); writeADC(ADCREG2,0x40); writeADC(ADCREG3,0xf); writeADC(ADCREG4,0x3f); printf("\nConfiguring Vrefs\n"); writeADC(ADCREG_VREFS,0x2); printf("\nSetting ADC Inversion\n");// (by trial and error) bus_w(ADC_INVERSION_REG,0x453b2a9c); adcPipeline(HALFSPEED_ADC_PIPELINE); dbitPipeline(HALFSPEED_DBIT_PIPELINE); adcPhase(HALFSPEED_ADC_PHASE); //set adc_clock_phase in unit of 1/(52) clock period (by trial and error) printf("\nReset mem machine fifos\n"); bus_w(MEM_MACHINE_FIFOS_REG,0x4000); bus_w(MEM_MACHINE_FIFOS_REG,0x0); printf("\nReset run control\n"); bus_w(MEM_MACHINE_FIFOS_REG,0x0400); bus_w(MEM_MACHINE_FIFOS_REG,0x0); initSpeedConfGain(HALFSPEED_CONF); setSettings(DYNAMICGAIN,-1); //Initialization of acquistion parameters setFrames(1*1000*1000); setTrains(-1); setExposureTime(10*1000); setPeriod(2*1000*1000); setDelay(0); setGates(0); setTiming(GET_EXTERNAL_COMMUNICATION_MODE); setMaster(GET_MASTER); setSynchronization(GET_SYNCHRONIZATION_MODE); } //------ end of control server ------ //common for both control and stop server 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) { #ifdef VERBOSE printf("ERROR reading from socket %d, %d %d\n", n, fnum, file_des); #endif return FAIL; } #ifdef VERBOSE else printf("size of data received %d\n",n); #endif #ifdef VERBOSE printf( "calling function fnum = %d %x %x %x\n",fnum,(unsigned int)(flist[fnum]), (unsigned int)(flist[F_READ_REGISTER]),(unsigned int)(&read_register)); #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_CONFIGURE_MAC]=&configure_mac; flist[F_LOAD_IMAGE]=&load_image; flist[F_SET_MASTER]=&set_master; flist[F_SET_SYNCHRONIZATION_MODE]=&set_synchronization; flist[F_READ_COUNTER_BLOCK]=&read_counter_block; flist[F_RESET_COUNTER_BLOCK]=&reset_counter_block; flist[F_START_RECEIVER]=&start_receiver; flist[F_STOP_RECEIVER]=&stop_receiver; flist[F_CALIBRATE_PEDESTAL]=&calibrate_pedestal; flist[F_SET_CTB_PATTERN]=&set_ctb_pattern; flist[F_WRITE_ADC_REG]=&write_adc_register; flist[F_PROGRAM_FPGA]=&program_fpga; return OK; } int M_nofunc(int file_des){ int ret=FAIL; sprintf(mess,"Unrecognized Function\n"); printf(mess); sendDataOnly(file_des,&ret,sizeof(ret)); 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; } } } /* 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; break; } #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); #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=-1; int ret=OK; int n=0; 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 DETECTOR_SERIAL_NUMBER: retval=getDetectorNumber(); break; case DETECTOR_FIRMWARE_VERSION: retval=getFirmwareSVNVersion(); retval=(retval <<32) | getFirmwareVersion(); break; case DETECTOR_SOFTWARE_VERSION: retval= SVNREV; retval= (retval <<32) | SVNDATE; break; default: printf("Required unknown id %d \n", arg); ret=FAIL; retval=FAIL; break; } #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; int ival; 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 if (ret==OK) { if (differentClients==1 && lockStatus==1) { ret=FAIL; sprintf(mess,"Detector locked by %s\n",lastClientIP); } else{ if (ind<16) { if (mV) { if (val>2500) val=-1; printf("%d mV is ",val); if (val>0) val=4095*val/2500; printf("%d DACu\n", val); } else if (val>4095) val=-1; retval=setDac(ind,val); /* if(idac==HIGH_VOLTAGE) */ /* retval=initHighVoltageByModule(val,imod); */ /* else */ /* retval=initDACbyIndexDACU(idac,val,imod); */ } else if (ind==ADC_VPP) { printf("Setting ADC VPP to %d\n",val); if (val>4 || val<0) printf("Cannot set ADC VPP to %d\n",val); else { writeADC(0x18,val); adcvpp=val; } retval=adcvpp;; } else if (ind==HV_NEW ) retval=initHighVoltageByModule(val,imod); else printf("**********No dac with index %d\n",ind); } } if(ret==OK){ if (ind<16) { if (mV) { printf("%d DACu is ",retval); retval1=2500*retval/16535; printf("%d mV \n",retval1); } else retval1=retval; } else retval1=retval; } #endif #ifdef VERBOSE printf("DAC set to %d V\n", retval); #endif if(ret==FAIL) printf("Setting dac %d of module %d: wrote %d but read %d\n", ind, imod, val, retval); else{ 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)); n += sendDataOnly(file_des,&retval1,sizeof(retval1)); } else { n += sendDataOnly(file_des,mess,sizeof(mess)); } /*return ok/fail*/ return ret; } int get_adc(int file_des) { //default: mod 0 int 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]; #ifdef VERBOSE printf("Getting ADC %d of module %d\n", ind, imod); #endif if (imod>=getNModBoard() || imod<0) ret=FAIL; #ifdef MCB_FUNCS switch (ind) { case TEMPERATURE_FPGA: idac=TEMP_FPGA; break; case TEMPERATURE_ADC: idac=TEMP_ADC; break; default: printf("Unknown DAC index %d\n",ind); sprintf(mess,"Unknown DAC index %d\n",ind); ret=FAIL; break; } if (ret==OK) retval=getTemperatureByModule(idac,imod); #endif #ifdef VERBOSE printf("ADC is %d 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); if(retval != myModule.reg) ret = FAIL; #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(myDac); if(myAdc != NULL) free(myAdc); if(myChip != NULL) free(myChip); if(myChan != NULL) free(myChan); //setDynamicRange(dr); always 16 commented out return ret; } int get_module(int file_des) { int ret=OK; int arg; int imod; int n; sls_detector_module myModule; int *myDac=malloc(NDAC*sizeof(int)); int *myChip=NULL; int *myChan=NULL; int *myAdc=NULL; //not allocating mychip,mychan for jungfrau to sace memory if (myDac) myModule.dacs=myDac; else { sprintf(mess,"could not allocate dacs\n"); ret=FAIL; } myModule.adcs=NULL; myModule.chipregs=NULL; myModule.chanregs=NULL; 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",(int)(getFrames()+2)); } else { dataret=FINISHED; sprintf(mess,"acquisition successfully finished\n"); if (differentClients) dataret=FORCE_UPDATE; } #endif sendDataOnly(file_des,&dataret,sizeof(dataret)); sendDataOnly(file_des,mess,sizeof(mess)); if(dataret == FAIL) cprintf(RED,"%s\n",mess); else printf("%s",mess); 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) { #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(); 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: sprintf(mess,"can't set timer for this detector\n"); ret=FAIL; break; case CYCLES_NUMBER: retval=setTrains(tns); break; default: ret=FAIL; sprintf(mess,"timer index unknown %d\n",ind); break; } } } if (ret!=OK) { printf(mess); if (differentClients) ret=FORCE_UPDATE; } if (ret!=OK) { printf(mess); printf("set timer failed\n"); } 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",(int)(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: printf("getting frames \n"); 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; case FRAMES_FROM_START: case FRAMES_FROM_START_PG: retval=getFramesFromStart(); break; default: ret=FAIL; sprintf(mess,"timer index unknown %d\n",ind); break; } } 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; printf("Set dynamic range?\n"); 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 { 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 ret=OK; int nroi=-1; int n=0; strcpy(mess,"Could not set/get roi\n"); n = receiveDataOnly(file_des,&nroi,sizeof(nroi)); if (n < 0) { sprintf(mess,"Error reading from socket\n"); ret=FAIL; } ret = FAIL; strcpy(mess,"Not applicable/implemented for this detector\n"); printf("Error:Set ROI-%s",mess); if(ret==OK && differentClients){ printf("Force update\n"); ret=FORCE_UPDATE; } /* send answer */ n = sendDataOnly(file_des,&ret,sizeof(ret)); n = sendDataOnly(file_des,mess,sizeof(mess)); /*return ok/fail*/ return ret; } int get_roi(int file_des) { return FAIL; } int set_speed(int file_des) { enum speedVariable arg; int val,n; int ret=OK; int retval=-1; n=receiveDataOnly(file_des,&arg,sizeof(arg)); if (n < 0) { sprintf(mess,"Error reading from socket\n"); ret=FAIL; } n=receiveDataOnly(file_des,&val,sizeof(val)); if (n < 0) { sprintf(mess,"Error reading from socket\n"); ret=FAIL; } if (ret==OK) { if (val!=-1) { if (differentClients==1 && lockStatus==1 && val>=0) { ret=FAIL; sprintf(mess,"Detector locked by %s\n",lastClientIP); } else { switch (arg) { case CLOCK_DIVIDER: switch(val){ case 0: ret=FAIL; sprintf(mess,"Full speed not implemented yet. Available options: 1 for half speed and 2 for quarter speed"); break; case 1: case 2: break; default: ret=FAIL; sprintf(mess,"Unknown clock options %d. Available options: 1 for half speed and 2 for quarter speed",arg); break; } setClockDivider(val); break; case ADC_PHASE: adcPhase(val); break; default: ret=FAIL; sprintf(mess,"Unknown speed parameter %d",arg); } } } } if (ret==OK) { switch (arg) { case CLOCK_DIVIDER: retval=getClockDivider(); break; case ADC_PHASE: retval=getPhase(); break; default: ret=FAIL; sprintf(mess,"Unknown speed parameter %d",arg); } } 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 arg; int ret=FAIL; receiveDataOnly(file_des,&arg,sizeof(arg)); sprintf(mess,"can't set readout flags for this detector\n"); sendDataOnly(file_des,&ret,sizeof(ret)); sendDataOnly(file_des,mess,sizeof(mess)); return ret; } int execute_trimming(int file_des) { int arg[3]; int ret=FAIL; enum trimMode mode; sprintf(mess,"can't set execute trimming for this detector\n"); receiveDataOnly(file_des,&mode,sizeof(mode)); receiveDataOnly(file_des,arg,sizeof(arg)); sendDataOnly(file_des,&ret,sizeof(ret)); 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) { 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); if (sd==-10) { sprintf(mess,"Port %d already set\n", p_number); printf("Port %d already set\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)); 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 n;//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)); n = sendDataOnly(file_des,&dynamicRange,sizeof(dynamicRange)); n = sendDataOnly(file_des,&dataBytes,sizeof(dataBytes)); t=setSettings(GET_SETTINGS,-1); 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 configure_mac(int file_des) { int ret=OK; char arg[5][50]; int n; int imod=0;//should be in future sent from client as -1, arg[2] int ipad; long long int imacadd; long long int idetectormacadd; int udpport; int detipad; int retval=-100; sprintf(mess,"Can't configure MAC\n"); n = receiveDataOnly(file_des,arg,sizeof(arg)); if (n < 0) { sprintf(mess,"Error reading from socket\n"); ret=FAIL; } sscanf(arg[0], "%x", &ipad); sscanf(arg[1], "%llx", &imacadd); sscanf(arg[2], "%x", &udpport); sscanf(arg[3], "%llx", &idetectormacadd); sscanf(arg[4], "%x", &detipad); //#ifdef VERBOSE int i; printf("\ndigital_test_bit in server %d\t",digitalTestBit); printf("\nipadd %x\t",ipad); printf("destination ip is %d.%d.%d.%d = 0x%x \n",(ipad>>24)&0xff,(ipad>>16)&0xff,(ipad>>8)&0xff,(ipad)&0xff,ipad); printf("macad:%llx\n",imacadd); for (i=0;i<6;i++) printf("mac adress %d is 0x%x \n",6-i,(unsigned int)(((imacadd>>(8*i))&0xFF))); printf("udp port:0x%x\n",udpport); printf("detector macad:%llx\n",idetectormacadd); for (i=0;i<6;i++) printf("detector mac adress %d is 0x%x \n",6-i,(unsigned int)(((idetectormacadd>>(8*i))&0xFF))); printf("detipad %x\n",detipad); printf("\n"); //#endif if (imod>=getNModBoard()) ret=FAIL; if (imod<0) imod=ALLMOD; //#ifdef VERBOSE printf("Configuring MAC of module %d at port %x\n", imod, udpport); //#endif #ifdef MCB_FUNCS if (ret==OK){ if(runBusy()){ ret=stopStateMachine(); if(ret==FAIL) strcpy(mess,"could not stop detector acquisition to configure mac"); } if(ret==OK) configureMAC(ipad,imacadd,idetectormacadd,detipad,digitalTestBit,udpport); retval=getAdcConfigured(); } #endif if (ret==FAIL) printf("configuring MAC of mod %d failed\n", imod); else printf("Configuremac successful of mod %d and adc %d\n",imod,retval); if (differentClients) ret=FORCE_UPDATE; /* send answer */ /* send OK/failed */ 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 ok/fail*/ return ret; } int load_image(int file_des) { int retval; int ret=OK; int n; enum imageType index; short int ImageVals[NCHAN*NCHIP]; sprintf(mess,"Loading image failed\n"); n = receiveDataOnly(file_des,&index,sizeof(index)); if (n < 0) { sprintf(mess,"Error reading from socket\n"); ret=FAIL; } n = receiveDataOnly(file_des,ImageVals,dataBytes); if (n < 0) { sprintf(mess,"Error reading from socket\n"); ret=FAIL; } switch (index) { case DARK_IMAGE : #ifdef VERBOSE printf("Loading Dark image\n"); #endif break; case GAIN_IMAGE : #ifdef VERBOSE printf("Loading Gain image\n"); #endif break; default: printf("Unknown index %d\n",index); sprintf(mess,"Unknown index %d\n",index); ret=FAIL; break; } if (ret==OK) { if (differentClients==1 && lockStatus==1) { ret=FAIL; sprintf(mess,"Detector locked by %s\n",lastClientIP); } else{ retval=loadImage(index,ImageVals); if (retval==-1) ret = FAIL; } } if(ret==OK){ 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_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; } int read_counter_block(int file_des) { int ret=OK; int n; int startACQ; //char *retval=NULL; short int CounterVals[NCHAN*NCHIP]; sprintf(mess,"Read counter block failed\n"); n = receiveDataOnly(file_des,&startACQ,sizeof(startACQ)); if (n < 0) { sprintf(mess,"Error reading from socket\n"); ret=FAIL; } if (ret==OK) { if (differentClients==1 && lockStatus==1) { ret=FAIL; sprintf(mess,"Detector locked by %s\n",lastClientIP); } else{ ret=readCounterBlock(startACQ,CounterVals); #ifdef VERBOSE int i; for(i=0;i<6;i++) printf("%d:%d\t",i,CounterVals[i]); #endif } } if(ret!=FAIL){ 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,CounterVals,dataBytes);//1280*2 } else { n += sendDataOnly(file_des,mess,sizeof(mess)); } /*return ok/fail*/ return ret; } int reset_counter_block(int file_des) { int ret=OK; int n; int startACQ; sprintf(mess,"Reset counter block failed\n"); n = receiveDataOnly(file_des,&startACQ,sizeof(startACQ)); if (n < 0) { sprintf(mess,"Error reading from socket\n"); ret=FAIL; } if (ret==OK) { if (differentClients==1 && lockStatus==1) { ret=FAIL; sprintf(mess,"Detector locked by %s\n",lastClientIP); } else ret=resetCounterBlock(startACQ); } if(ret==OK){ if (differentClients) ret=FORCE_UPDATE; } /* send answer */ /* send OK/failed */ n = sendDataOnly(file_des,&ret,sizeof(ret)); if (ret==FAIL) n += sendDataOnly(file_des,mess,sizeof(mess)); /*return ok/fail*/ return ret; } int start_receiver(int file_des) { int ret=FAIL; int n; strcpy(mess,"Not implemented for this detector\n"); /* send answer */ n = sendDataOnly(file_des,&ret,sizeof(ret)); n = sendDataOnly(file_des,mess,sizeof(mess)); /*return ok/fail*/ return ret; } int stop_receiver(int file_des) { int ret = FAIL; int n; strcpy(mess,"Not implemented for this detector\n"); /* send answer */ n = sendDataOnly(file_des,&ret,sizeof(ret)); n = sendDataOnly(file_des,mess,sizeof(mess)); /*return ok/fail*/ return ret; } int calibrate_pedestal(int file_des){ int ret=OK; int retval=-1; int n; int frames; sprintf(mess,"Could not calibrate pedestal\n"); n = receiveDataOnly(file_des,&frames,sizeof(frames)); if (n < 0) { sprintf(mess,"Error reading from socket\n"); ret=FAIL; } if (ret==OK) { if (differentClients==1 && lockStatus==1) { ret=FAIL; sprintf(mess,"Detector locked by %s\n",lastClientIP); } else ret=calibratePedestal(frames); } if(ret==OK){ if (differentClients) ret=FORCE_UPDATE; } /* send answer */ /* send OK/failed */ 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 ok/fail*/ return ret; } int set_ctb_pattern(int file_des){ int ret=OK;//FAIL; int retval=-1; int n; int mode; uint64_t word, retval64, t; int addr; int level, start, stop, nl; uint64_t pat[1024]; sprintf(mess,"Could not set pattern\n"); n = receiveDataOnly(file_des,&mode,sizeof(mode)); printf("pattern mode is %d\n",mode); switch (mode) { case 0: //sets word n = receiveDataOnly(file_des,&addr,sizeof(addr)); n = receiveDataOnly(file_des,&word,sizeof(word)); ret=OK; switch (addr) { case -1: retval64=writePatternIOControl(word); break; case -2: retval64=writePatternClkControl(word); break; default: retval64=writePatternWord(addr,word); }; //write word; //@param addr address of the word, -1 is I/O control register, -2 is clk control register //@param word 64bit word to be written, -1 gets n = sendDataOnly(file_des,&ret,sizeof(ret)); if (ret==FAIL) n += sendDataOnly(file_des,mess,sizeof(mess)); else n += sendDataOnly(file_des,&retval64,sizeof(retval64)); break; case 1: //pattern loop n = receiveDataOnly(file_des,&level,sizeof(level)); n = receiveDataOnly(file_des,&start,sizeof(start)); n = receiveDataOnly(file_des,&stop,sizeof(stop)); n = receiveDataOnly(file_des,&nl,sizeof(nl)); printf("level %d start %x stop %x nl %d\n",level, start, stop, nl); /** Sets the pattern or loop limits in the CTB @param level -1 complete pattern, 0,1,2, loop level @param start start address if >=0 @param stop stop address if >=0 @param n number of loops (if level >=0) @returns OK/FAIL */ ret=setPatternLoop(level, &start, &stop, &nl); n = sendDataOnly(file_des,&ret,sizeof(ret)); if (ret==FAIL) n += sendDataOnly(file_des,mess,sizeof(mess)); else { n += sendDataOnly(file_des,&start,sizeof(start)); n += sendDataOnly(file_des,&stop,sizeof(stop)); n += sendDataOnly(file_des,&nl,sizeof(nl)); } break; case 2: //wait address n = receiveDataOnly(file_des,&level,sizeof(level)); n = receiveDataOnly(file_des,&addr,sizeof(addr)); /** Sets the wait address in the CTB @param level 0,1,2, wait level @param addr wait address, -1 gets @returns actual value */ printf("wait addr %d %x\n",level, addr); retval=setPatternWaitAddress(level,addr); printf("ret: wait addr %d %x\n",level, retval); ret=OK; 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)); } break; case 3: //wait time n = receiveDataOnly(file_des,&level,sizeof(level)); n = receiveDataOnly(file_des,&t,sizeof(t)); /** Sets the wait time in the CTB @param level 0,1,2, wait level @param t wait time, -1 gets @returns actual value */ ret=OK; retval64=setPatternWaitTime(level,t); n = sendDataOnly(file_des,&ret,sizeof(ret)); if (ret==FAIL) n += sendDataOnly(file_des,mess,sizeof(mess)); else n += sendDataOnly(file_des,&retval64,sizeof(retval64)); break; case 4: n = receiveDataOnly(file_des,pat,sizeof(pat)); for (addr=0; addr<1024; addr++) writePatternWord(addr,word); ret=OK; retval=0; n = sendDataOnly(file_des,&ret,sizeof(ret)); if (ret==FAIL) n += sendDataOnly(file_des,mess,sizeof(mess)); else n += sendDataOnly(file_des,&retval64,sizeof(retval64)); break; default: ret=FAIL; printf(mess); sprintf(mess,"%s - wrong mode %d\n",mess, mode); n = sendDataOnly(file_des,&ret,sizeof(ret)); n += sendDataOnly(file_des,mess,sizeof(mess)); } /*return ok/fail*/ return ret; } int write_adc_register(int file_des) { int retval; int ret=OK; int arg[2]; int addr, val; int n; sprintf(mess,"Can't write to register\n"); n = receiveDataOnly(file_des,arg,sizeof(arg)); if (n < 0) { sprintf(mess,"Error reading from socket\n"); ret=FAIL; } addr=arg[0]; val=arg[1]; #ifdef VERBOSE printf("writing to register 0x%x data 0x%x\n", addr, val); #endif if (differentClients==1 && lockStatus==1) { ret=FAIL; sprintf(mess,"Detector locked by %s\n",lastClientIP); } if(ret!=FAIL){ ret=writeADC(addr,val); if (ret==OK) retval=val; } #ifdef VERBOSE printf("Data set to 0x%x\n", retval); #endif if (retval==val) { ret=OK; if (differentClients) ret=FORCE_UPDATE; } else { ret=FAIL; sprintf(mess,"Writing to register 0x%x failed: wrote 0x%x but read 0x%x\n", addr, 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)); } /*return ok/fail*/ return ret; } int program_fpga(int file_des) { int ret=OK; int n; const size_t maxprogramsize = 2 * 1024 *1024; size_t unitprogramsize = 0; char* fpgasrc = (char*)malloc(maxprogramsize); size_t filesize = 0; size_t totalsize = 0; FILE* fp = NULL; sprintf(mess,"Program FPGA\n"); //filesize n = receiveDataOnly(file_des,&filesize,sizeof(filesize)); if (n < 0) { sprintf(mess,"Error reading from socket\n"); ret=FAIL; } totalsize = filesize; #ifdef VERY_VERBOSE printf("\n\n Total size is:%d\n",totalsize); #endif //opening file pointer to flash and telling FPGA to not touch flash if(startWritingFPGAprogram(&fp) != OK){ sprintf(mess,"Could not write to flash. Error at startup.\n"); cprintf(RED,"%s",mess); ret=FAIL; filesize = 0; } n = sendDataOnly(file_des,&ret,sizeof(ret)); if (ret==FAIL) n += sendDataOnly(file_des,mess,sizeof(mess)); //erasing flash if(ret != FAIL) eraseFlash(); //writing to flash part by part while(filesize){ unitprogramsize = maxprogramsize; //2mb if(unitprogramsize > filesize) //less than 2mb unitprogramsize = filesize; #ifdef VERY_VERBOSE printf("unit size to receive is:%d\n",unitprogramsize); printf("filesize:%d currentpointer:%d\n",filesize,currentPointer); #endif //receive n = receiveDataOnly(file_des,fpgasrc,unitprogramsize); if (n < 0) { sprintf(mess,"Error reading from socket\n"); ret=FAIL; } if(!(unitprogramsize - filesize)){ fpgasrc[unitprogramsize]='\0'; filesize-=unitprogramsize; unitprogramsize++; }else filesize-=unitprogramsize; if (ret==OK) { if (differentClients==1 && lockStatus==1) { ret=FAIL; sprintf(mess,"Detector locked by %s\n",lastClientIP); } else{ ret = writeFPGAProgram(fpgasrc,unitprogramsize,fp); } } if(ret!=FAIL){ if (differentClients) ret=FORCE_UPDATE; } /* send answer */ /* send OK/failed */ n = sendDataOnly(file_des,&ret,sizeof(ret)); if (ret==FAIL) { n += sendDataOnly(file_des,mess,sizeof(mess)); cprintf(RED,"Failure: Breaking out of program receiving\n"); break; } //print progress printf("Writing to Flash:%d%%\r",(int) (((double)(totalsize-filesize)/totalsize)*100) ); fflush(stdout); } printf("\n"); //closing file pointer to flash and informing FPGA if(stopWritingFPGAprogram(fp) == FAIL){ sprintf(mess,"Could not write to flash. Error at end.\n"); cprintf(RED,"%s",mess); ret=FAIL; } n = sendDataOnly(file_des,&ret,sizeof(ret)); if (ret==FAIL) n += sendDataOnly(file_des,mess,sizeof(mess)); //free resources free(fpgasrc); if(fp!=NULL) fclose(fp); #ifdef VERY_VERBOSE printf("Done with program receiving command\n"); #endif /*return ok/fail*/ return ret; }