diff --git a/slsDetectorSoftware/jctbDetectorServer/Makefile.ctb b/slsDetectorSoftware/jctbDetectorServer/Makefile.ctb new file mode 100644 index 000000000..ca00d71b9 --- /dev/null +++ b/slsDetectorSoftware/jctbDetectorServer/Makefile.ctb @@ -0,0 +1,61 @@ +# $Id: Makefile,v 1.1.1.1 2006/02/04 03:35:01 freza Exp $ +# first compile +# make cris-axis-linux-gnu + + +CROSS = bfin-uclinux- +CC = $(CROSS)gcc + +CFLAGS += -Wall -DMOENCHD -DMCB_FUNCS -DDACS_INT -DDEBUG -DV1 -DCTB #-DVERBOSE #-DVERYVERBOSE #-DVIRTUAL #-DDACS_INT_CSERVER + + +PROGS= jungfrauDetectorServerTest +INSTDIR= /tftpboot +INSTMODE= 0777 + + + +BINS = testlib_sharedlibc +SRCS = server.c server_funcs.c communication_funcs.c firmware_funcs.c mcb_funcs.c sharedmemory.c +OBJS = $(SRCS:%.c=%.o) + + + +all: clean $(PROGS) + +test: clean jungfrauADCTEst + +boot: $(OBJS) + +jungfrauDetectorServerTest: $(OBJS) + echo $(OBJS) + $(CC) $(CFLAGS) -o $@ $^ $(LDLIBS_$@) $(LDFLAGS_$@) + + +jungfrauDetectorServer: $(OBJS) + echo $(OBJS) + $(CC) $(CFLAGS) -o $@ $^ $(LDLIBS_$@) $(LDFLAGS_$@) + +jungfrauADCTEst: $(OBJS) + echo $(OBJS) + $(CC) $(CFLAGS) -o $@ $^ $(LDLIBS_$@) $(LDFLAGS_$@) -DTESTADC + + + + +install: $(PROGS) + $(INSTALL) -d $(INSTDIR) + $(INSTALL) -m $(INSTMODE) $(PROGS) $(INSTDIR) + + +romfs: + $(ROMFSINST) /bin/$(PROGS) + +clean: + rm -rf $(PROGS) *.o *.gdb + + + + + + diff --git a/slsDetectorSoftware/jctbDetectorServer/ansi.h b/slsDetectorSoftware/jctbDetectorServer/ansi.h new file mode 120000 index 000000000..a122db0ad --- /dev/null +++ b/slsDetectorSoftware/jctbDetectorServer/ansi.h @@ -0,0 +1 @@ +../../slsReceiverSoftware/include/ansi.h \ No newline at end of file diff --git a/slsDetectorSoftware/jctbDetectorServer/communication_funcs.c b/slsDetectorSoftware/jctbDetectorServer/communication_funcs.c new file mode 120000 index 000000000..87a4f95d1 --- /dev/null +++ b/slsDetectorSoftware/jctbDetectorServer/communication_funcs.c @@ -0,0 +1 @@ +../commonFiles/communication_funcs.c \ No newline at end of file diff --git a/slsDetectorSoftware/jctbDetectorServer/communication_funcs.h b/slsDetectorSoftware/jctbDetectorServer/communication_funcs.h new file mode 120000 index 000000000..f220903b2 --- /dev/null +++ b/slsDetectorSoftware/jctbDetectorServer/communication_funcs.h @@ -0,0 +1 @@ +../commonFiles/communication_funcs.h \ No newline at end of file diff --git a/slsDetectorSoftware/jctbDetectorServer/firmware_funcs.c b/slsDetectorSoftware/jctbDetectorServer/firmware_funcs.c new file mode 100755 index 000000000..0b623c757 --- /dev/null +++ b/slsDetectorSoftware/jctbDetectorServer/firmware_funcs.c @@ -0,0 +1,3664 @@ +//#define TESTADC +#define TESTADC1 + + +//#define TIMEDBG +#include "server_defs.h" +#include "firmware_funcs.h" +#include "mcb_funcs.h" +#include "registers_m.h" + +//#define VERBOSE +//#define VERYVERBOSE + + +#ifdef SHAREDMEMORY +#include "sharedmemory.h" +#endif + +#include +#include +#include + +#include +#include +#include /* exit() */ +#include /* memset(), memcpy() */ +#include /* uname() */ +#include +#include /* socket(), bind(), + listen(), accept() */ +#include +#include +#include +#include +#include /* fork(), write(), close() */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +typedef struct ip_header_struct { + u_int16_t ip_len; + u_int8_t ip_tos; + u_int8_t ip_ihl:4 ,ip_ver:4; + u_int16_t ip_offset:13,ip_flag:3; + u_int16_t ip_ident; + u_int16_t ip_chksum; + u_int8_t ip_protocol; + u_int8_t ip_ttl; + u_int32_t ip_sourceip; + u_int32_t ip_destip; +} ip_header; + + +struct timeval tss,tse,tsss; //for timing + + +//for memory mapping +u_int32_t CSP0BASE; + + +FILE *debugfp, *datafp; + +int fr; +int wait_time; +int *fifocntrl; + +//int *statusreg; commented out by dhanya +const int nModY=1; +int nModBoard; +int nModX=NMAXMOD; +int dynamicRange=16;//32; +int nSamples=1; + +int dataBytes=NMAXMOD*NCHIP*NCHAN*2; + +int storeInRAM=0; +int ROI_flag=0; +int adcConfigured=-1; +u_int16_t *ram_values=NULL; +char volatile *now_ptr=NULL; +//u_int32_t volatile *values; +u_int16_t volatile *values; +int ram_size=0; + +int64_t totalTime=1; +u_int32_t progressMask=0; + +int phase_shift=0;//DEFAULT_PHASE_SHIFT; +int ipPacketSize=DEFAULT_IP_PACKETSIZE; +int udpPacketSize=DEFAULT_UDP_PACKETSIZE; + +#ifndef NEW_PLL_RECONFIG +u_int32_t clkDivider[2]={32,16}; +#else +u_int32_t clkDivider[2]={40,20}; +#endif +int32_t clkPhase[2]={0,0}; + +u_int32_t adcDisableMask=0; + +int ififostart, ififostop, ififostep, ififo; + +int masterMode=NO_MASTER, syncMode=NO_SYNCHRONIZATION, timingMode=AUTO_TIMING; + +enum externalSignalFlag signals[4]={EXT_SIG_OFF, EXT_SIG_OFF, EXT_SIG_OFF, EXT_SIG_OFF}; + +int withGotthard = 0; + +/**is not const because this value will change after initDetector, is removed from mcb_funcs.c cuz its not used anywhere + * why is this used anywhere instead of macro*/ +int nChans=NCHAN; +int nChips=NCHIP; +int nDacs=NDAC; +int nAdcs=NADC; + +extern enum detectorType myDetectorType; +/** for jungfrau reinitializing macro later in server_funcs.c in initDetector*/ +extern int N_CHAN; +extern int N_CHIP; +extern int N_DAC; +extern int N_ADC; +extern int N_CHANS; + +int mapCSP0(void) { + printf("Mapping memory\n"); +#ifndef VIRTUAL + int fd; + fd = open("/dev/mem", O_RDWR | O_SYNC, 0); + if (fd == -1) { + printf("\nCan't find /dev/mem!\n"); + return FAIL; + } + printf("/dev/mem opened\n"); + + CSP0BASE = (u_int32_t)mmap(0, MEM_SIZE, PROT_READ|PROT_WRITE, MAP_FILE|MAP_SHARED, fd, CSP0); + if (CSP0BASE == (u_int32_t)MAP_FAILED) { + printf("\nCan't map memmory area!!\n"); + return FAIL; + } + printf("CSP0 mapped\n"); + +#endif +#ifdef VIRTUAL + CSP0BASE = malloc(MEM_SIZE); + printf("memory allocated\n"); +#endif +#ifdef SHAREDMEMORY + if ( (res=inism(SMSV))<0) { + printf("error attaching shared memory! %i",res); + return FAIL; + } +#endif + printf("CSPObase is 0x%08x \n",CSP0BASE); + printf("CSPOBASE=from %08x to %08x\n",CSP0BASE,CSP0BASE+MEM_SIZE); + + u_int32_t address; + address = FIFO_DATA_REG;//_OFF; + //values=(u_int32_t*)(CSP0BASE+address*2); + values=(u_int16_t*)(CSP0BASE+address*2); + printf("statusreg=%08x\n",bus_r(STATUS_REG)); + printf("\n\n"); + return OK; +} + +u_int16_t bus_r16(u_int32_t offset){ + volatile u_int16_t *ptr1; + ptr1=(u_int16_t*)(CSP0BASE+offset*2); + return *ptr1; +} + +u_int16_t bus_w16(u_int32_t offset, u_int16_t data) { + volatile u_int16_t *ptr1; + ptr1=(u_int16_t*)(CSP0BASE+offset*2); + *ptr1=data; + return OK; +} + +/** ramType is DARK_IMAGE_REG or GAIN_IMAGE_REG */ +u_int16_t ram_w16(u_int32_t ramType, int adc, int adcCh, int Ch, u_int16_t data) { + unsigned int adr = (ramType | adc << 8 | adcCh << 5 | Ch ); + // printf("Writing to addr:%x\n",adr); + return bus_w16(adr,data); +} + +/** ramType is DARK_IMAGE_REG or GAIN_IMAGE_REG */ +u_int16_t ram_r16(u_int32_t ramType, int adc, int adcCh, int Ch){ + unsigned int adr = (ramType | adc << 8 | adcCh << 5 | Ch ); + // printf("Reading from addr:%x\n",adr); + return bus_r16(adr); +} + +u_int32_t bus_w(u_int32_t offset, u_int32_t data) { + volatile u_int32_t *ptr1; + + ptr1=(u_int32_t*)(CSP0BASE+offset*2); + *ptr1=data; + + return OK; +} + + +u_int32_t bus_r(u_int32_t offset) { + volatile u_int32_t *ptr1; + ptr1=(u_int32_t*)(CSP0BASE+offset*2); + return *ptr1; +} + + +int setPhaseShiftOnce(){ + u_int32_t addr, reg; + int i; + addr=MULTI_PURPOSE_REG; + reg=bus_r(addr); +#ifdef VERBOSE + printf("Multipurpose reg:%x\n",reg); +#endif + + //Checking if it is power on(negative number) + // if(((reg&0xFFFF0000)>>16)>0){ + //bus_w(addr,0x0); //clear the reg + + if(reg==0){ + printf("\nImplementing phase shift of %d\n",phase_shift); + for (i=1;i2*l) { + h=l+1; + odd=1; + } + printf("Counter %d: Low is %d, High is %d\n",i, l,h); + + + val= (i<<18)| (odd<<17) | l | (h<<8); + + printf("Counter %d, val: %08x\n", i, val); + setPllReconfigReg(PLL_C_COUNTER_REG, val,0); + // usleep(20); + //change sync at the same time as + if (i>0) { + val= (2<<18)| (odd<<17) | l | (h<<8); + + printf("Counter %d, val: %08x\n", i, val); + setPllReconfigReg(PLL_C_COUNTER_REG, val,0); + + } + + } else { + // if (mode==1) { + // } else { + printf("phase in %d\n",clkPhase[1]); + + if (clkPhase[1]>0) { + inv=0; + phase=clkPhase[1]; + } else { + inv=1; + phase=-1*clkPhase[1]; + } + + printf("phase out %d %08x\n",phase,phase); + if (inv) { + val=phase | (1<<16);// | (inv<<21); + printf("**************** phase word %08x\n",val); + + // printf("Phase, val: %08x\n", val); + setPllReconfigReg(PLL_PHASE_SHIFT_REG,val,0); //shifts counter 0 + } else { + + + val=phase ;// | (inv<<21); + printf("**************** phase word %08x\n",val); + + // printf("Phase, val: %08x\n", val); + setPllReconfigReg(PLL_PHASE_SHIFT_REG,val,0); //shifts counter 0 +#ifndef NEW_PLL_RECONFIG + printf("Start reconfig\n"); setPllReconfigReg(PLL_START_REG, 1,0); + + // bus_w(PLL_CNTRL_REG, 0); + printf("Status register\n"); getPllReconfigReg(PLL_STATUS_REG,0); + // sleep(1); + + printf("PLL mode\n"); setPllReconfigReg(PLL_MODE_REG,1,0); + // usleep(10000); + +#endif + printf("**************** phase word %08x\n",val); + + val=phase | (2<<16);// | (inv<<21); + // printf("Phase, val: %08x\n", val); + setPllReconfigReg(PLL_PHASE_SHIFT_REG,val,0); //shifts counter 0 + } + + + } + +#ifndef NEW_PLL_RECONFIG + printf("Start reconfig\n"); setPllReconfigReg(PLL_START_REG, 1,0); + + // bus_w(PLL_CNTRL_REG, 0); + printf("Status register\n"); getPllReconfigReg(PLL_STATUS_REG,0); + // sleep(1); +#endif + // printf("PLL mode\n"); setPllReconfigReg(PLL_MODE_REG,0,0); + usleep(10000); + if (i<2) { + printf("reset pll\n"); + bus_w(PLL_CNTRL_REG,((1<1) + return -1; + + if (ic==1 && d>40) + return -1; + + if (d>160) + return -1; + + if (tot>510) + return -1; + + if (tot<1) + return -1; + + + + clkDivider[ic]=d; + configurePll(ic); + + + + return clkDivider[ic]; +} + + +int phaseStep(int st){ + + if (st>65535 || st<-65535) + return clkPhase[0]; +#ifdef NEW_PLL_RECONFIG + printf("reset pll\n"); + bus_w(PLL_CNTRL_REG,((1<1) + return -1; + return clkDivider[ic]; + + +/* int ic=0; */ +/* u_int32_t val; */ +/* u_int32_t l,h; */ + +/* printf("get clk divider\n"); */ + + +/* setPllReconfigReg(PLL_MODE_REG,1,0); */ +/* getPllReconfigReg(PLL_MODE_REG,0); */ + +/* u_int32_t addr=0xa; //c0 */ +/* if (ic>0) */ +/* addr=0xb; //c1 */ + +/* val=getPllReconfigReg(PLL_N_COUNTER_REG,0); */ +/* printf("Getting N counter %08x\n",val); */ + +/* l=val&0xff; */ +/* h=(val>>8)&0xff; */ + +/* //getPllReconfigReg(PLL_STATUS_REG,0); */ +/* val=getPllReconfigReg(addr,0); */ +/* printf("Getting C counter %08x\n",val); */ + + + +/* return 800/(l+h); */ + +} + + +u_int32_t adcPipeline(int d) { + if (d>=0) + bus_w(DAQ_REG, d); + return bus_r(DAQ_REG)&0xff; +} + + +u_int32_t setSetLength(int d) { + return 0; +} + +u_int32_t getSetLength() { + return 0; +} + +u_int32_t setOversampling(int d) { + + if (d>=0 && d<=255) + bus_w(OVERSAMPLING_REG, d); + + return bus_r(OVERSAMPLING_REG); +} + + +u_int32_t setWaitStates(int d1) { + return 0; +} + +u_int32_t getWaitStates() { + return 0; +} + + +u_int32_t setTotClockDivider(int d) { + return 0; +} + +u_int32_t getTotClockDivider() { + return 0; +} + + +u_int32_t setTotDutyCycle(int d) { + return 0; +} + +u_int32_t getTotDutyCycle() { + return 0; +} + + +u_int32_t setExtSignal(int d, enum externalSignalFlag mode) { + + //int modes[]={EXT_SIG_OFF, EXT_GATE_IN_ACTIVEHIGH, EXT_GATE_IN_ACTIVELOW,EXT_TRIG_IN_RISING,EXT_TRIG_IN_FALLING,EXT_RO_TRIG_IN_RISING, EXT_RO_TRIG_IN_FALLING,EXT_GATE_OUT_ACTIVEHIGH, EXT_GATE_OUT_ACTIVELOW, EXT_TRIG_OUT_RISING, EXT_TRIG_OUT_FALLING, EXT_RO_TRIG_OUT_RISING, EXT_RO_TRIG_OUT_FALLING}; + // int off=d*SIGNAL_OFFSET; + + u_int32_t c; + c=bus_r(EXT_SIGNAL_REG); + + if (d>=0 && d<4) { + signals[d]=mode; +#ifdef VERBOSE + printf("settings signal variable number %d to value %04x\n", d, signals[d]); +#endif + + // if output signal, set it! + + switch (mode) { + case GATE_IN_ACTIVE_HIGH: + case GATE_IN_ACTIVE_LOW: + if (timingMode==GATE_FIX_NUMBER || timingMode==GATE_WITH_START_TRIGGER) + setFPGASignal(d,mode); + else + setFPGASignal(d,SIGNAL_OFF); + break; + case TRIGGER_IN_RISING_EDGE: + case TRIGGER_IN_FALLING_EDGE: + if (timingMode==TRIGGER_EXPOSURE || timingMode==GATE_WITH_START_TRIGGER) + setFPGASignal(d,mode); + else + setFPGASignal(d,SIGNAL_OFF); + break; + case RO_TRIGGER_IN_RISING_EDGE: + case RO_TRIGGER_IN_FALLING_EDGE: + if (timingMode==TRIGGER_READOUT) + setFPGASignal(d,mode); + else + setFPGASignal(d,SIGNAL_OFF); + break; + case MASTER_SLAVE_SYNCHRONIZATION: + setSynchronization(syncMode); + break; + default: + setFPGASignal(d,mode); + break; + } + + setTiming(GET_EXTERNAL_COMMUNICATION_MODE); + } + + +// if (mode<=RO_TRIGGER_OUT_FALLING_EDGE && mode>=0) +// bus_w(EXT_SIGNAL_REG,((modes[mode])<=0) { +#ifdef VERBOSE + printf("writing signal register number %d mode %04x\n",d, modes[mode]); +#endif + bus_w(EXT_SIGNAL_REG,((modes[mode])<>off); + + if (mode=0 && d<4) { +#ifdef VERBOSE + printf("gettings signal variable number %d value %04x\n", d, signals[d]); +#endif + return signals[d]; + } else + return -1; + + +} + + +int getFPGASignal(int d) { + + int modes[]={SIGNAL_OFF, GATE_IN_ACTIVE_HIGH, GATE_IN_ACTIVE_LOW,TRIGGER_IN_RISING_EDGE, TRIGGER_IN_FALLING_EDGE,RO_TRIGGER_IN_RISING_EDGE, RO_TRIGGER_IN_FALLING_EDGE, GATE_OUT_ACTIVE_HIGH, GATE_OUT_ACTIVE_LOW, TRIGGER_OUT_RISING_EDGE, TRIGGER_OUT_FALLING_EDGE, RO_TRIGGER_OUT_RISING_EDGE,RO_TRIGGER_OUT_FALLING_EDGE}; + + int off=d*SIGNAL_OFFSET; + int mode=((bus_r(EXT_SIGNAL_REG)&(SIGNAL_MASK<>off); + + if (mode<=RO_TRIGGER_OUT_FALLING_EDGE) { + if (modes[mode]!=SIGNAL_OFF && signals[d]!=MASTER_SLAVE_SYNCHRONIZATION) + signals[d]=modes[mode]; +#ifdef VERYVERBOSE + printf("gettings signal register number %d value %04x\n", d, modes[mode]); +#endif + return modes[mode]; + } else + return -1; + +} + + + + + +/* +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 +}; +*/ + + +int setTiming(int ti) { + + + int ret=GET_EXTERNAL_COMMUNICATION_MODE; + + int g=-1, t=-1, rot=-1; + + int i; + + switch (ti) { + case AUTO_TIMING: + timingMode=ti; + // disable all gates/triggers in except if used for master/slave synchronization + for (i=0; i<4; i++) { + if (getFPGASignal(i)>0 && getFPGASignal(i)=0 && t>=0 && rot<0) { + ret=GATE_WITH_START_TRIGGER; + } else if (g<0 && t>=0 && rot<0) { + ret=TRIGGER_EXPOSURE; + } else if (g>=0 && t<0 && rot<0) { + ret=GATE_FIX_NUMBER; + } else if (g<0 && t<0 && rot>0) { + ret=TRIGGER_READOUT; + } else if (g<0 && t<0 && rot<0) { + ret=AUTO_TIMING; + } + + // timingMode=ret; + + return ret; + +} + + + +int setConfigurationRegister(int d) { +#ifdef VERBOSE + printf("Setting configuration register to %x",d); +#endif + if (d>=0) { + bus_w(CONFIG_REG,d); + } +#ifdef VERBOSE + printf("configuration register is %x", bus_r(CONFIG_REG)); +#endif + return bus_r(CONFIG_REG); +} + +int setToT(int d) { + //int ret=0; + int reg; +#ifdef VERBOSE + printf("Setting ToT to %d\n",d); +#endif + reg=bus_r(CONFIG_REG); +#ifdef VERBOSE + printf("Before: ToT is %x\n", reg); +#endif + if (d>0) { + bus_w(CONFIG_REG,reg|TOT_ENABLE_BIT); + } else if (d==0) { + bus_w(CONFIG_REG,reg&(~TOT_ENABLE_BIT)); + } + reg=bus_r(CONFIG_REG); +#ifdef VERBOSE + printf("ToT is %x\n", reg); +#endif + if (reg&TOT_ENABLE_BIT) + return 1; + else + return 0; +} + +int setContinousReadOut(int d) { + //int ret=0; + int reg; +#ifdef VERBOSE + printf("Setting Continous readout to %d\n",d); +#endif + reg=bus_r(CONFIG_REG); +#ifdef VERBOSE + printf("Before: Continous readout is %x\n", reg); +#endif + if (d>0) { + bus_w(CONFIG_REG,reg|CONT_RO_ENABLE_BIT); + } else if (d==0) { + bus_w(CONFIG_REG,reg&(~CONT_RO_ENABLE_BIT)); + } + reg=bus_r(CONFIG_REG); +#ifdef VERBOSE + printf("Continous readout is %x\n", reg); +#endif + if (reg&CONT_RO_ENABLE_BIT) + return 1; + else + return 0; +} + + +int startReceiver(int start) { + u_int32_t addr=CONFIG_REG; +#ifdef VERBOSE + if(start) + printf("Setting up detector to send to Receiver\n"); + else + printf("Setting up detector to send to CPU\n"); +#endif + int reg=bus_r(addr); + //for start recever, write 0 and for stop, write 1 + if (!start) + bus_w(CONFIG_REG,reg&(~GB10_NOT_CPU_BIT)); + else + bus_w(CONFIG_REG,reg|GB10_NOT_CPU_BIT); + + reg=bus_r(addr); +//#ifdef VERBOSE + printf("Config Reg %x\n", reg); +//#endif + int d =reg&GB10_NOT_CPU_BIT; + if(d!=0) d=1; + if(d!=start) + return OK; + else + return FAIL; +} + + +u_int64_t getDetectorNumber() { + char output[255],mac[255]=""; + u_int64_t res=0; + FILE* sysFile = popen("ifconfig eth0 | grep HWaddr | cut -d \" \" -f 11", "r"); + fgets(output, sizeof(output), sysFile); + pclose(sysFile); + //getting rid of ":" + char * pch; + pch = strtok (output,":"); + while (pch != NULL){ + strcat(mac,pch); + pch = strtok (NULL, ":"); + } + sscanf(mac,"%llx",&res); + return res; +} + +u_int32_t getFirmwareVersion() { + return bus_r(FPGA_VERSION_REG); +} + +u_int32_t getFirmwareSVNVersion(){ + return bus_r(FPGA_SVN_REG); +} + + +// for fpga test +u_int32_t testFpga(void) { + printf("Testing FPGA:\n"); + volatile u_int32_t val,addr,val2; + int result=OK,i; + //fixed pattern + val=bus_r(FIX_PATT_REG); + if (val==FIXED_PATT_VAL) { + printf("fixed pattern ok!! %08x\n",val); + } else { + printf("fixed pattern wrong!! %08x\n",val); + result=FAIL; + } + + //dummy register + addr = DUMMY_REG; + for(i=0;i<1000000;i++) + { + val=0x5A5A5A5A-i; + bus_w(addr, val); + val=bus_r(addr); + if (val!=0x5A5A5A5A-i) { + printf("ATTEMPT:%d:\tFPGA dummy register wrong!! %x instead of %x \n",i,val,0x5A5A5A5A-i); + result=FAIL; + } + val=(i+(i<<10)+(i<<20)); + bus_w(addr, val); + val2=bus_r(addr); + if (val2!=val) { + printf("ATTEMPT:%d:\tFPGA dummy register wrong!! read %x instead of %x.\n",i,val2,val); + result=FAIL; + } + val=0x0F0F0F0F; + bus_w(addr, val); + val=bus_r(addr); + if (val!=0x0F0F0F0F) { + printf("ATTEMPT:%d:\tFPGA dummy register wrong!! %x instead of 0x0F0F0F0F \n",i,val); + result=FAIL; + } + val=0xF0F0F0F0; + bus_w(addr, val); + val=bus_r(addr); + if (val!=0xF0F0F0F0) { + printf("ATTEMPT:%d:\tFPGA dummy register wrong!! %x instead of 0xF0F0F0F0 \n\n",i,val); + result=FAIL; + } + } + if(result==OK) + { + printf("----------------------------------------------------------------------------------------------"); + printf("\nATTEMPT 1000000: FPGA DUMMY REGISTER OK!!!\n"); + printf("----------------------------------------------------------------------------------------------"); + } + printf("\n"); + return result; +} + + +// for fpga test +u_int32_t testRAM(void) { + int result=OK; + + printf("TestRAM not implemented\n"); + +/* int i=0; + allocateRAM(); + // while(i<100000) { + memcpy(ram_values, values, dataBytes); + printf ("Testing RAM:\t%d: copied fifo %x to memory %x size %d\n",i++, (unsigned int)(values), (unsigned int)(ram_values), dataBytes); + // } + * +*/ + return result; +} + + +int getNModBoard() { +if(myDetectorType == JUNGFRAU) + return 1; +else + return 32;//nModX; +} + +int setNMod(int n) { + +/* printf("Writin ADC disable register %08x\n",n); */ +/* bus_w(ADC_LATCH_DISABLE_REG,n); */ + return getNMod(); +} + +int getNMod() { +/* u_int32_t reg; */ +/* int i; */ +/* reg=bus_r(ADC_LATCH_DISABLE_REG); */ + +/* printf("Read ADC disable register %08x\n",reg); */ +/* nModX=32; */ +/* for (i=0; i<32; i++) { */ +/* if (reg & (1<> 32; + vMSB=v64&(0xffffffff); + bus_w(aMSB,vMSB); + } + return get64BitReg(aLSB, aMSB); + +} + +int64_t get64BitReg(int aLSB, int aMSB){ + int64_t v64; + u_int32_t vLSB,vMSB; + vLSB=bus_r(aLSB); + vMSB=bus_r(aMSB); + v64=vMSB; + v64=(v64<<32) | vLSB; + + printf("reg64(%x,%x) %x %x %llx\n", aLSB, aMSB, vLSB, vMSB, v64); + + return v64; +} + +int64_t setFrames(int64_t value){ + return set64BitReg(value, SET_FRAMES_LSB_REG, SET_FRAMES_MSB_REG); +} + +int64_t getFrames(){ + /*printf("gf");*/ + return get64BitReg(GET_FRAMES_LSB_REG, GET_FRAMES_MSB_REG); +} + +int64_t setExposureTime(int64_t value){ + /* time is in ns */ + if (value!=-1) + value*=(1E-3*clkDivider[0]);//(1E-9*CLK_FREQ); + return set64BitReg(value,SET_EXPTIME_LSB_REG, SET_EXPTIME_MSB_REG)/(1E-3*clkDivider[0]);//(1E-9*CLK_FREQ); +} + +int64_t getExposureTime(){ + return get64BitReg(GET_EXPTIME_LSB_REG, GET_EXPTIME_MSB_REG)/(1E-3*clkDivider[0]);//(1E-9*CLK_FREQ); +} + +int64_t setGates(int64_t value){ + return set64BitReg(value, SET_GATES_LSB_REG, SET_GATES_MSB_REG); +} + +int64_t getGates(){ + return get64BitReg(GET_GATES_LSB_REG, GET_GATES_MSB_REG); +} + +int64_t setPeriod(int64_t value){ + /* time is in ns */ + if (value!=-1) { + // value*=(1E-9*CLK_FREQ); + value*=(1E-3*clkDivider[1]); + } + if (value%2==0) { + + printf("Adding one to period: was %08llx ", value); + value+=1; + printf("now is %08llx\n ", value); + + + } else + printf("Period already even is %08llx\n ", value); + + + return set64BitReg(value,SET_PERIOD_LSB_REG, SET_PERIOD_MSB_REG)/(1E-3*clkDivider[0]);//(1E-9*CLK_FREQ); +} + +int64_t getPeriod(){ + return get64BitReg(GET_PERIOD_LSB_REG, GET_PERIOD_MSB_REG)/(1E-3*clkDivider[0]);//(1E-9*CLK_FREQ); +} + +int64_t setDelay(int64_t value){ + /* time is in ns */ + if (value!=-1) { + value*=(1E-3*clkDivider[1]);//(1E-9*CLK_FREQ); + } + return set64BitReg(value,SET_DELAY_LSB_REG, SET_DELAY_MSB_REG)/(1E-3*clkDivider[0]);//(1E-9*CLK_FREQ); +} + +int64_t getDelay(){ + return get64BitReg(GET_DELAY_LSB_REG, GET_DELAY_MSB_REG)/(1E-3*clkDivider[0]);//(1E-9*CLK_FREQ); +} + +int64_t setTrains(int64_t value){ + return set64BitReg(value, SET_CYCLES_LSB_REG, SET_CYCLES_MSB_REG); +} + +int64_t getTrains(){ + return get64BitReg(GET_CYCLES_LSB_REG, GET_CYCLES_MSB_REG); +} + + +int64_t setProbes(int64_t value){ + return 0; +} + + +int64_t setProgress() { + + //????? eventually call after setting the registers + +return 0; + +} + + +int64_t getProgress() { + + + //should be done in firmware!!!! + + return 0; + +} + +int64_t getActualTime(){ + return get64BitReg(GET_ACTUAL_TIME_LSB_REG, GET_ACTUAL_TIME_MSB_REG)/(1E-9*CLK_FREQ); +} + +int64_t getMeasurementTime(){ + int64_t v=get64BitReg(GET_MEASUREMENT_TIME_LSB_REG, GET_MEASUREMENT_TIME_MSB_REG); + // int64_t mask=0x8000000000000000; + // if (v & mask ) { + //#ifdef VERBOSE + // printf("no measurement time left\n"); + //#endif + // return -1E+9; + // } else + return v/(1E-9*CLK_FREQ); +} + +int64_t getFramesFromStart(){ + int64_t v=get64BitReg(FRAMES_FROM_START_LSB_REG, FRAMES_FROM_START_MSB_REG); + int64_t v1=get64BitReg(FRAMES_FROM_START_PG_LSB_REG, FRAMES_FROM_START_PG_MSB_REG); + + printf("Frames from start data streaming %lld\n",v); + printf("Frames from start run control %lld\n",v1); + + // int64_t mask=0x8000000000000000; + // if (v & mask ) { + //#ifdef VERBOSE + // printf("no measurement time left\n"); + //#endif + // return -1E+9; + // } else + return v; +} + + +ROI *setROI(int nroi,ROI* arg,int *retvalsize, int *ret) { + + if(myDetectorType == JUNGFRAU) + cprintf(RED,"ROI Not implemented for Jungfrau yet\n"); + return NULL; + + + ROI retval[MAX_ROIS]; + int i, ich; + adcDisableMask=0xfffffffff; /*warning: integer constant is too large for ‘long’ type,warning: large integer implicitly truncated to unsigned type*/ + + printf("Setting ROI\n"); + if (nroi>=0) { + if (nroi==0) { + adcDisableMask=0; + } else { + for (i=0; i=0 && ichMAX_ROIS) { + *retvalsize-=1; + break; + } + retval[*retvalsize-1].xmin=ich; + retval[*retvalsize-1].xmax=ich; + } else { + if ((adcDisableMask)&(1<<(ich-1))) { + *retvalsize+=1; + if (*retvalsize>MAX_ROIS) { + *retvalsize-=1; + break; + } + retval[*retvalsize-1].xmin=ich; + } + retval[*retvalsize-1].xmax=ich; + } + } + } + getDynamicRange(); + return retval;/*warning: function returns address of local variable*/ + +} + + +int loadImage(int index, short int ImageVals[]){ + + printf("loadImage Not implemented yet\n"); + + /* + u_int32_t address; + switch (index) { + case DARK_IMAGE : + address = DARK_IMAGE_REG; + break; + case GAIN_IMAGE : + address = GAIN_IMAGE_REG; + break; + } + volatile u_int16_t *ptr; + ptr=(u_int16_t*)(CSP0BASE+address*2); +#ifdef VERBOSE + int i; + for(i=0;i<6;i++) + printf("%d:%d\t",i,ImageVals[i]); +#endif + memcpy(ptr,ImageVals ,dataBytes); +#ifdef VERBOSE + printf("\nLoaded x%08x address with image of index %d\n",(unsigned int)(ptr),index); +#endif + */ + + return OK; +} + + + +int64_t getProbes(){ + return 0; +} + + +int setDACRegister(int idac, int val, int imod) { +/* u_int32_t addr, reg, mask; */ +/* int off; */ +/* #ifdef VERBOSE */ +/* if(val==-1) */ +/* printf("Getting dac register%d module %d\n",idac,imod); */ +/* else */ +/* printf("Setting dac register %d module %d to %d\n",idac,imod,val); */ +/* #endif */ + +/* switch(idac){ */ +/* case 0: */ +/* case 1: */ +/* case 2: */ +/* addr=MOD_DACS1_REG; */ +/* break; */ +/* case 3: */ +/* case 4: */ +/* case 5: */ +/* addr=MOD_DACS2_REG; */ +/* break; */ +/* case 6: */ +/* case 7: */ +/* addr=MOD_DACS3_REG; */ +/* break; */ +/* default: */ +/* printf("weird idac value %d\n",idac); */ +/* return -1; */ +/* break; */ +/* } */ +/* //saving only the msb */ +/* val=val>>2; */ + +/* off=(idac%3)*10; */ +/* mask=~((0x3ff)<=0 && val>off)&0x3ff; */ +/* //since we saved only the msb */ +/* val=val<<2; */ + +/* //val=(bus_r(addr)>>off)&0x3ff; */ + + +/* #ifdef VERBOSE */ +/* printf("Dac %d module %d register is %d\n\n",idac,imod,val); */ +/* #endif */ +/* return val; */ +} + + +int getTemperature(int tempSensor, int imod){ + int val; + imod=0;//ignoring more than 1 mod for now + int i,j,repeats=6; + u_int32_t tempVal=0; +#ifdef VERBOSE + char cTempSensor[2][100]={"ADCs/ASICs","VRs/FPGAs"}; + printf("Getting Temperature of module:%d for the %s for tempsensor:%d\n",imod,cTempSensor[tempSensor],tempSensor); +#endif + bus_w(TEMP_IN_REG,(T1_CLK_BIT)|(T1_CS_BIT)|(T2_CLK_BIT)|(T2_CS_BIT));//standby + bus_w(TEMP_IN_REG,((T1_CLK_BIT)&~(T1_CS_BIT))|(T2_CLK_BIT));//high clk low cs + + for(i=0;i<20;i++) { + //repeats is number of register writes for delay + for(j=0;j>1);//fpga + } + } + + bus_w(TEMP_IN_REG,(T1_CLK_BIT)|(T1_CS_BIT)|(T2_CLK_BIT)|(T2_CS_BIT));//standby + val=((int)tempVal)/4.0; + +#ifdef VERBOSE + printf("Temperature of module:%d for the %s is %.2fC\n",imod,cTempSensor[tempSensor],val); +#endif + return val; +} + + + +int initHighVoltage(int val, int imod){ + + + u_int32_t offw,codata; + u_int16_t valw, dacvalue; + int iru,i,ddx,csdx,cdx; + float alpha=0.55, fval=val; + + if (val>=0) { + + if (val<60) { + dacvalue=0; + val=60; + } else if (val>=200) { + dacvalue=0x1; + val=200; + } else { + dacvalue=1.+(200.-val)/alpha; + val=200.-(dacvalue-1)*alpha; + } + printf ("****************************** setting val %d, dacval %d\n",val, dacvalue); + offw=DAC_REG; + + ddx=8; csdx=10; cdx=9; + codata=((dacvalue)&0xff); + + + + + valw=0xffff; bus_w(offw,(valw)); // start point + valw=((valw&(~(0x1<>(7-i))&0x1)< 1 ) { + sum += *addr++; + count -= 2; + } + if( count > 0 ) sum += *addr; // Add left-over byte, if any + while (sum>>16) sum = (sum & 0xffff) + (sum >> 16);// Fold 32-bit sum to 16 bits + checksum = (~sum)&0xffff; + + printf("IP checksum is 0x%lx\n",checksum); + + return checksum; +} + + + +#ifdef NEW_GBE_INTERFACE +int writeGbeReg(int ivar, uint32_t val, int addr, int interface) { +/* #define GBE_CTRL_WSTROBE 0 */ +/* #define GBE_CTRL_VAR_OFFSET 16 */ +/* #define GBE_CTRL_VAR_MASK 0XF */ +/* #define GBE_CTRL_RAMADDR_OFFSET 24 */ +/* #define GBE_CTRL_RAMADDR_MASK 0X3F */ +/* #define GBE_CTRL_INTERFACE 23 */ + uint32_t ctrl=((ivar&GBE_CTRL_VAR_MASK)<>32)&0xFFFFFFFF; + vals[IPCHECKSUM_ADDR]=checksum; + vals[GBE_DELAY_ADDR]=0; + vals[GBE_RESERVED1_ADDR]=sourceport; + vals[GBE_RESERVED2_ADDR]=interface; + vals[DETECTOR_MAC_L_ADDR]=(sourcemac)&0xFFFFFFFF; + vals[DETECTOR_MAC_H_ADDR]=(sourcemac>>32)&0xFFFFFFFF; + vals[DETECTOR_IP_ADDR]=sourceip; + + for (ivar=0; ivar>32)&0xFFFFFFFF);//rx_udpmacH_AReg_c + bus_w(RX_UDPMACL_AREG,(destmac)&0xFFFFFFFF);//rx_udpmacL_AReg_c + bus_w(DETECTORMACH_AREG,(sourcemac>>32)&0xFFFFFFFF);//detectormacH_AReg_c + bus_w(DETECTORMACL_AREG,(sourcemac)&0xFFFFFFFF);//detectormacL_AReg_c + bus_w(UDPPORTS_AREG,((sourceport&0xFFFF)<<16)+(destport&0xFFFF));//udpports_AReg_c + bus_w(IPCHKSUM_AREG,(checksum&0xFFFF));//ipchksum_AReg_c + + +#endif + + bus_w(CONTROL_REG,GB10_RESET_BIT); + sleep(1); + bus_w(CONTROL_REG,0); + usleep(10000); + bus_w(CONFIG_REG,conf | GB10_NOT_CPU_BIT); + printf("System status register is %08x\n",bus_r(SYSTEM_STATUS_REG)); + +return 0; //any value doesnt matter - dhanya + +} + + + + + + + + + + + +int configureMAC(uint32_t destip,uint64_t destmac,uint64_t sourcemac,int sourceip,int ival,uint32_t destport) { +//int configureMAC(int ipad,long long int macad,long long int detectormacad, int detipad, int ival, int udpport){ + + uint32_t sourceport = 0x7e9a; // 0xE185; + int interface=0; + int ngb; +volatile u_int32_t conf= bus_r(CONFIG_REG); + + + + + +#ifdef NEW_GBE_INTERFACE + ngb=2; + printf("--------- New XGB interface\n"); +#else + ngb=1; + printf("********* Old XGB interface\n"); +#endif + + for (interface=0; interface >((i)*2))==3) { *\/ */ +/* /\* i++; *\/ */ +/* /\* if (i>15) *\/ */ +/* /\* break; *\/ */ +/* /\* } *\/ */ +/* /\* if (i<16) { *\/ */ +/* bus_w16(DUMMY_REG,i); */ +/* } */ +/* val=*values; */ + + + // bus_w16(DUMMY_REG,0); // + for (i=0; i<32; i++) { + + + // bus_w16(DUMMY_REG,i); + // bus_r16(DUMMY_REG); +/* dum=(((u_int16_t*)(now_ptr))+i); */ +/* *dum=bus_r16(FIFO_DATA_REG); */ +/* a=bus_r16(FIFO_DATA_REG); */ + //dum=(((u_int32_t*)(now_ptr))+i); + + // a=*values;//bus_r(FIFO_DATA_REG); + // if ((adcDisableMask&(3<<(i*2)))==0) { + *((u_int16_t*)now_ptr)=bus_r16(FIFO_DATA_REG);//*values;//bus_r(FIFO_DATA_REG); + + + if (i!=0 || ns!=0) { + a=0; + while (*((u_int16_t*)now_ptr)==*((u_int16_t*)(now_ptr)-1) && a++<10) { + + // printf("******************** %d: fifo %d: new %08x old %08x\n ",ns, i, *((u_int32_t*)now_ptr),*((u_int32_t*)(now_ptr)-1)); + *((u_int16_t*)now_ptr)=bus_r16(FIFO_DATA_REG);//*values; + // printf("%d-",i); + + } + } + now_ptr+=2;//4; + // } +/* while (((adcDisableMask&(3<<((i+1)*2)))>>((i+1)*2))==3) { */ +/* i++; */ +/* } */ + + // if (((adcDisableMask&(3<<((i+1)*2)))>>((i+1)*2))!=3) { + + bus_w16(DUMMY_REG,i+1); + + a = bus_r(LOOK_AT_ME_REG); + //#ifdef VERBOSE + printf("%d %08x\n",i,a); + // } + // *(((u_int16_t*)(now_ptr))+i)=bus_r16(FIFO_DATA_REG); + } + // bus_w16(DUMMY_REG,0); // +/* #ifdef TIMEDBG */ + +/* gettimeofday(&tss,NULL); */ +/* printf("read data loop = %ld usec\n",(tss.tv_usec) - (tse.tv_usec)); */ + +/* #endif */ +//#ifdef VERBOSE + // printf("*"); + //#endif + return ram_values; +} + + + +u_int16_t* fifo_read_frame() +{ +#ifdef TIMEDBG + gettimeofday(&tsss,NULL); +#endif + + // u_int16_t *dum; + int ns=0; + now_ptr=(char*)ram_values; + while(ns>(ipos))&0x1; + ichan++; + } + } + break; + case 4: + for (ibyte=0; ibyte>(ipos*4))&0xf; + ichan++; + } + } + break; + case 8: + for (ichan=0; ichan0) { + dynamicRange=16; + nSamples=dr/16; + bus_w(NSAMPLES_REG,nSamples); + } + getDynamicRange(); + allocateRAM(); + printf("Setting dataBytes to %d: dr %d; samples %d\n",dataBytes, dynamicRange, nSamples); + return getDynamicRange(); +} + + + + + + +int getDynamicRange() { + if(myDetectorType == JUNGFRAU){ + dynamicRange=16; + return dynamicRange; + } + + nSamples=bus_r(NSAMPLES_REG); + getChannels(); + dataBytes=nModX*N_CHIP*getChannels()*2; + return dynamicRange*bus_r(NSAMPLES_REG);//nSamples; +} + +int testBus() { + u_int32_t j; + u_int64_t i, n, nt; + // char cmd[100]; + u_int32_t val=0x0; + int ifail=OK; + // printf("%s\n",cmd); + // system(cmd); + i=0; + + n=1000000; + nt=n/100; + printf("testing bus %d times\n",(int)n); + while (i0) + storeInRAM=1; + else + storeInRAM=0; + return allocateRAM(); +} + +int getChannels() { + int nch=32; + int i; + for (i=0; i1) { + + clearRAM(); + ram_values=malloc(size); + // ram_values=realloc(ram_values,size)+2; + // if (ram_values) + // break; + // nSamples--; + //} + + if (ram_values) { + now_ptr=(char*)ram_values; + + //#ifdef VERBOSE + printf("ram allocated 0x%x of size %d to %x\n",(int)now_ptr,(unsigned int) size,(unsigned int)(now_ptr+size)); + //#endif + ram_size=size; + return OK; + } + + + printf("Fatal error: there must be a memory leak somewhere! You can't allocate even one frame!\n"); + return FAIL; + + + + +} + + +int writeADC(int addr, int val) { + + + u_int32_t valw,codata,csmask; + int i,cdx,ddx; + cdx=0; ddx=1; + csmask=0xfc; // 1111100 + + codata=val + (addr<< 8); + printf("***** ADC SPI WRITE TO REGISTER %04X value %04X\n",addr,val); + // start point + valw=0xff; + bus_w16(ADC_WRITE_REG,(valw)); + + //chip sel bar down + valw=((0xffffffff&(~csmask))); + bus_w16(ADC_WRITE_REG,valw); + + for (i=0;i<24;i++) { + //cldwn + valw=valw&(~(0x1<>(23-i))&0x1)<> 8); + // printf("%i: %i %i\n",a, frame[a],v); + avg[a] += ((double)frame[a])/(double)frames; + //if(frame[a] == 8191) + // printf("ch %i: %u\n",a,frame[a]); + } + // printf("********\n"); + numberFrames++; + } + + //no more data or no data + else { + if(getFrames()>-2) { + dataret=FAIL; + printf("no data and run stopped: %d frames left\n",(int)(getFrames()+2)); + + } else { + dataret=FINISHED; + printf("acquisition successfully finished\n"); + + } + printf("dataret %d\n",dataret); + } + } + + + + //double nf = (double)numberFrames; + for(i =0; i < 1280; i++){ + adc = i / 256; + adcCh = (i - adc * 256) / 32; + Ch = i - adc * 256 - adcCh * 32; + adc--; + double v2 = avg[i]; + avg[i] = avg[i]/ ((double)numberFrames/(double)frames); + unsigned short v = (unsigned short)avg[i]; + printf("setting avg for channel %i(%i,%i,%i): %i (double= %f (%f))\t", i,adc,adcCh,Ch, v,avg[i],v2); + v=i*100; + ram_w16(DARK_IMAGE_REG,adc,adcCh,Ch,v-4096); + if(ram_r16(DARK_IMAGE_REG,adc,adcCh,Ch) != v-4096){ + printf("value is wrong (%i,%i,%i): %i \n",adc,adcCh,Ch, ram_r16(DARK_IMAGE_REG,adc,adcCh,Ch)); + } + } + + /*for(adc = 1; adc < 5; adc++){ + for(adcCh = 0; adcCh < 8; adcCh++){ + for(Ch=0 ; Ch < 32; Ch++){ + int channel = (adc+1) * 32 * 8 + adcCh * 32 + Ch; + double v2 = avg[channel]; + avg[channel] = avg[channel]/ ((double)numberFrames/(double)frames); + unsigned short v = (unsigned short)avg[channel]; + printf("setting avg for channel %i: %i (double= %f (%f))\t", channel, v,avg[channel],v2); + ram_w16(DARK_IMAGE_REG,adc,adcCh,Ch,v-4096); + if(ram_r16(DARK_IMAGE_REG,adc,adcCh,Ch) != v-4096){ + printf("value is wrong (%i,%i,%i): %i \n",adc,adcCh,Ch, ram_r16(DARK_IMAGE_REG,adc,adcCh,Ch)); + } + } + } + }*/ + + + + printf("frames: %i\n",numberFrames); + printf("corrected avg by: %f\n",(double)numberFrames/(double)frames); + + printf("restoring previous condition\n"); + setFrames(framesBefore); + setPeriod(periodBefore); + + printf("---------------------------\n"); + return 0; +} +uint64_t readPatternWord(int addr) { + uint64_t word=0; + int cntrl=0; + + if (addr>=MAX_PATTERN_LENGTH) + return -1; + + + printf("read %x\n",addr); + cntrl= (addr&APATTERN_MASK) << PATTERN_CTRL_ADDR_OFFSET; + bus_w(PATTERN_CNTRL_REG, cntrl); + usleep(1000); + bus_w(PATTERN_CNTRL_REG, cntrl | (1<< PATTERN_CTRL_READ_BIT) ); + usleep(1000); + printf("reading\n"); + word=get64BitReg(PATTERN_OUT_LSB_REG,PATTERN_OUT_MSB_REG); + printf("read %llx\n", word); + usleep(1000); + bus_w(PATTERN_CNTRL_REG, cntrl); + printf("done\n"); + + return word; +} + +uint64_t writePatternWord(int addr, uint64_t word) { + + + int cntrl=0; + if (addr>=MAX_PATTERN_LENGTH) + return -1; + + printf("write %x %llx\n",addr, word); + if (word!=-1){ + + set64BitReg(word,PATTERN_IN_REG_LSB,PATTERN_IN_REG_MSB); + + + cntrl= (addr&APATTERN_MASK) << PATTERN_CTRL_ADDR_OFFSET; + bus_w(PATTERN_CNTRL_REG, cntrl); + usleep(1000); + bus_w(PATTERN_CNTRL_REG, cntrl | (1<< PATTERN_CTRL_WRITE_BIT) ); + usleep(1000); + bus_w(PATTERN_CNTRL_REG, cntrl); + return word; + } else + return readPatternWord(addr); +} +uint64_t writePatternIOControl(uint64_t word) { + if (word!=0xffffffffffffffff) { /*warning: integer constant is too large for ‘long’ type*/ + // printf("%llx %llx %lld",get64BitReg(PATTERN_IOCTRL_REG_LSB,PATTERN_IOCTRL_REG_MSB),word); + set64BitReg(word,PATTERN_IOCTRL_REG_LSB,PATTERN_IOCTRL_REG_MSB); + // printf("************ write IOCTRL (%x)\n",PATTERN_IOCTRL_REG_MSB); + } + return get64BitReg(PATTERN_IOCTRL_REG_LSB,PATTERN_IOCTRL_REG_MSB); + +} +uint64_t writePatternClkControl(uint64_t word) { + if (word!=0xffffffffffffffff) set64BitReg(word,PATTERN_IOCLKCTRL_REG_LSB,PATTERN_IOCLKCTRL_REG_MSB);/*warning: integer constant is too large for ‘long’ type*/ + return get64BitReg(PATTERN_IOCLKCTRL_REG_LSB,PATTERN_IOCLKCTRL_REG_MSB); + +} + +int setPatternLoop(int level, int *start, int *stop, int *n) { + int ret=OK; + int lval=0; + + int nreg; + int areg; + + switch (level ) { + case 0: + nreg=PATTERN_N_LOOP0_REG; + areg=PATTERN_LOOP0_AREG; + break; + case 1: + nreg=PATTERN_N_LOOP1_REG; + areg=PATTERN_LOOP1_AREG; + break; + case 2: + nreg=PATTERN_N_LOOP2_REG; + areg=PATTERN_LOOP2_AREG; + break; + case -1: + nreg=-1; + areg=PATTERN_LIMITS_AREG; + break; + default: + return FAIL; + } + + printf("level %d start %x stop %x nl %d\n",level, *start, *stop, *n); + if (nreg>=0) { + if ((*n)>=0) bus_w(nreg, *n); + printf ("n %d\n",*n); + *n=bus_r(nreg); + printf ("n %d\n",*n); + + } + + printf("level %d start %x stop %x nl %d\n",level, *start, *stop, *n); + lval=bus_r(areg); +/* printf("l=%x\n",bus_r16(areg)); */ +/* printf("m=%x\n",bus_r16_m(areg)); */ + + + + + + printf("lval %x\n",lval); + if (*start==-1) *start=(lval>> ASTART_OFFSET) & APATTERN_MASK; + printf("start %x\n",*start); + + + if (*stop==-1) *stop=(lval>> ASTOP_OFFSET) & APATTERN_MASK; + printf("stop %x\n",*stop); + + lval= ((*start & APATTERN_MASK) << ASTART_OFFSET) | ((*stop & APATTERN_MASK) << ASTOP_OFFSET); + printf("lval %x\n",lval); + + bus_w(areg,lval); + printf("lval %x\n",lval); + + + return ret; +} + + +int setPatternWaitAddress(int level, int addr) { + int reg; + + switch (level) { + case 0: + reg=PATTERN_WAIT0_AREG; + break; + case 1: + reg=PATTERN_WAIT1_AREG; + break; + case 2: + reg=PATTERN_WAIT2_AREG; + break; + default: + return -1; + }; + // printf("BEFORE *********PATTERN IOCTRL IS %llx (%x)\n",writePatternIOControl(-1), PATTERN_IOCTRL_REG_MSB); + + // printf ("%d addr %x (%x)\n",level,addr,reg); + if (addr>=0) bus_w(reg, addr); + // printf ("%d addr %x %x (%x) \n",level,addr, bus_r(reg), reg); + + // printf("AFTER *********PATTERN IOCTRL IS %llx (%x)\n",writePatternIOControl(-1), PATTERN_IOCTRL_REG_MSB); + + return bus_r(reg); +} + + +uint64_t setPatternWaitTime(int level, uint64_t t) { + int reglsb; + int regmsb; + + + switch (level) { + case 0: + reglsb=PATTERN_WAIT0_TIME_REG_LSB; + regmsb=PATTERN_WAIT0_TIME_REG_MSB; + break; + case 1: + reglsb=PATTERN_WAIT1_TIME_REG_LSB; + regmsb=PATTERN_WAIT1_TIME_REG_MSB; + break; + case 2: + reglsb=PATTERN_WAIT2_TIME_REG_LSB; + regmsb=PATTERN_WAIT2_TIME_REG_MSB; + break; + default: + return -1; + } + + + if (t>=0) set64BitReg(t,reglsb,regmsb); + return get64BitReg(reglsb,regmsb); + +} + + +void initDac(int dacnum) { + + + u_int32_t offw,codata; + u_int16_t valw; + int i,ddx,csdx,cdx; + + + + //setting int reference + offw=DAC_REG; + + + ddx=0; cdx=1; + csdx=dacnum/8+2; + + + printf("data bit=%d, clkbit=%d, csbit=%d",ddx,cdx,csdx); + codata=((((0x6)<<4)+((0xf))<<16)+((0x0<<4)&0xfff0)); /*warning: suggest parentheses around + or - inside shift*/ + + valw=0xffff; bus_w(offw,(valw)); // start point + valw=((valw&(~(0x1<>(24-i))&0x1)<>(24-i))&0x1)); + + + valw=((valw&(~(0x1<>16)&0xffff; */ +/* else */ +/* return retval&0xffff; */ + +} + + + + +int setPower(int ind, int val) { + int dacindex=-1; + int dacval=-1; + int pwrindex=-1; + int retval=-1; + int retval1=-1; + + u_int32_t preg; + + int vchip=2700-(getDacRegister(19)*1000)/4095; + int vmax=vchip-200; + int vmin=600; + + printf("---------------------------------------------Current V_Chip is %d mV\n",vchip); + + switch (ind) { + + case V_POWER_CHIP: + dacindex=19; + pwrindex=-1; + break; + case V_POWER_A: + dacindex=22; + pwrindex=1; + break; + case V_POWER_B: + dacindex=21; + pwrindex=2; + break; + case V_POWER_C: + dacindex=20; + pwrindex=3; + break; + case V_POWER_D: + dacindex=18; + pwrindex=4; + break; + case V_POWER_IO: + dacindex=23; + pwrindex=0; + break; + default: + pwrindex=-1; + dacindex=-1; + } + + if (val==-1) { + printf("get\n"); + dacval=-1; + } else { + if (pwrindex>=0) { + printf("vpower\n"); + dacval=((vmax-val)*4095)/(vmax-vmin); + if (dacval<0) + dacval=0; + if (dacval>4095) + dacval=-100; + if (val==-100) + dacval=-100; + + } else { + printf("vchip\n"); + dacval=((2700-val)*4095)/1000; + if (dacval<0) + dacval=0; + if (dacval>4095) + dacval=4095; + } + } + + if (pwrindex>=0 && val!=-1) { + preg=bus_r(POWER_ON_REG); + printf("power reg is %08x\n",bus_r(POWER_ON_REG)); + printf("Switching off power %d\n", pwrindex); + bus_w(POWER_ON_REG,preg&(~(1<<(16+pwrindex)))); + setDac(dacindex,-100); + printf("power reg is %08x\n",bus_r(POWER_ON_REG)); + retval=0; + } + + if (dacindex>0 && dacval!=-100) { + + printf("Setting power %d to %d mV\n",ind,val); + printf("Setting DAC %d to value %d\n",dacindex,dacval); + retval=setDac(dacindex,dacval); + if (pwrindex>=0 && dacval>=0 ) { + preg=bus_r(POWER_ON_REG); + printf("power reg is %08x\n",bus_r(POWER_ON_REG)); + printf("Switching on power %d\n", pwrindex); + bus_w(POWER_ON_REG,preg|((1<<(16+pwrindex)))); + printf("power reg is %08x\n",bus_r(POWER_ON_REG)); + } + } + + if (pwrindex>=0) { + if (bus_r(POWER_ON_REG)&(1<<(16+pwrindex))){ + retval1=vmax-(retval*1900)/4095; + vmax=2700-(getDacRegister(19)*1000)/4095-200; + if (retval1>vmax) + retval1=vmax; + if (retval1=0) + retval1=2700-(retval*1000)/4095; + else + retval1=-1; + } + + /* switch (ind) { */ +/* case V_POWER_A: */ +/* break; */ +/* case V_POWER_B: */ +/* break; */ +/* case V_POWER_C: */ +/* break; */ +/* case V_POWER_D: */ +/* break; */ +/* case V_POWER_IO: */ +/* break; */ +/* case V_POWER_CHIP: */ +/* break; */ +/* default: */ +/* retval1=retval; */ +/* } */ + + + return retval1; + + +} + + + + + + + + + + + + + + + + +int nextDac(){ + + u_int32_t offw,codata; + u_int16_t valw=bus_r(offw); + int i,ddx,csdx,cdx; + + int dacch=0; + + + // printf("**************************************************next dac\n"); + //setting int reference + offw=DAC_REG; + + + ddx=0; cdx=1; + + csdx=2; + + valw=0xffff&(~(0x1<>(24-i)))&0x1); + + valw=(valw&(~(0x1<>(24-i))&0x1)<>(24-i))&0x1)); + + + valw=((valw&(~(0x1<=0) { + + + + // printf("data bit=%d, clkbit=%d, csbit=%d",ddx,cdx,csdx); + + //modified to power down single channels + + // codata=((((0x2)<<4)+((dacch)&0xf))<<16)+((dacvalue<<4)&0xfff0); + codata=(0x3)<>(24-i)))&0x1); + valw=(valw&(~(0x1<>(24-i))&0x1)<>(24-i))&0x1)); + + + valw=((valw&(~(0x1< +#include +#include +#include +#include +#include +#include +//#include +#include +#include +#include +#include +#include +#include + + +int mapCSP0(void); + +u_int16_t bus_r16(u_int32_t offset); +u_int16_t bus_w16(u_int32_t offset, u_int16_t data);//aldos function +u_int32_t bus_w(u_int32_t offset, u_int32_t data); +u_int32_t bus_r(u_int32_t offset); + +int setPhaseShiftOnce(); +int phaseStep(int st); +int getPhase(); +int cleanFifo(); +int setDAQRegister(); + +u_int32_t putout(char *s, int modnum); +u_int32_t readin(int modnum); +u_int32_t setClockDivider(int d, int ic); +u_int32_t getClockDivider(int ic); + +void resetPLL(); +u_int32_t setPllReconfigReg(u_int32_t reg, u_int32_t val, int trig); +u_int32_t getPllReconfigReg(u_int32_t reg, int trig); + +u_int32_t setSetLength(int d); +u_int32_t getSetLength(); +u_int32_t setWaitStates(int d); +u_int32_t getWaitStates(); +u_int32_t setTotClockDivider(int d); +u_int32_t getTotClockDivider(); +u_int32_t setTotDutyCycle(int d); +u_int32_t getTotDutyCycle(); +u_int32_t setOversampling(int d); +u_int32_t adcPipeline(int d); + +u_int32_t setExtSignal(int d, enum externalSignalFlag mode); +int getExtSignal(int d); + +u_int32_t setFPGASignal(int d, enum externalSignalFlag mode); +int getFPGASignal(int d); + +int setTiming(int t); + + +int setConfigurationRegister(int d); +int setToT(int d); +int setContinousReadOut(int d); +int startReceiver(int d); + +int setDACRegister(int idac, int val, int imod); +int getDacRegister(int dacnum); + + +int getTemperature(int tempSensor,int imod); +int initHighVoltage(int val,int imod); +int initConfGain(int isettings,int val,int imod); + +int setADC(int adc); +//int configureMAC(int ipad, long long int macad, long long int detectormacadd, int detipad, int ival, int udpport); +int configureMAC(uint32_t destip,uint64_t destmac,uint64_t sourcemac,int detipad,int ival,uint32_t destport); +int getAdcConfigured(); + + +u_int64_t getDetectorNumber(); +u_int32_t getFirmwareVersion(); +u_int32_t getFirmwareSVNVersion(); + +int testFifos(void); +u_int32_t testFpga(void); +u_int32_t testRAM(void); +int testBus(void); +int setDigitalTestBit(int ival); + +int64_t set64BitReg(int64_t value, int aLSB, int aMSB); +int64_t get64BitReg(int aLSB, int aMSB); + +int64_t setFrames(int64_t value); +int64_t getFrames(); + +int64_t setExposureTime(int64_t value); +int64_t getExposureTime(); + +int64_t setGates(int64_t value); +int64_t getGates(); + +int64_t setDelay(int64_t value); +int64_t getDelay(); + +int64_t setPeriod(int64_t value); +int64_t getPeriod(); + +int64_t setTrains(int64_t value); +int64_t getTrains(); + +int64_t setProbes(int64_t value); +int64_t getProbes(); + +int64_t getProgress(); +int64_t setProgress(); + +int64_t getActualTime(); +int64_t getMeasurementTime(); +int64_t getFramesFromStart(); + +u_int32_t runBusy(void); +u_int32_t runState(void); +u_int32_t dataPresent(void); + + +int startStateMachine(); +int stopStateMachine(); +int startReadOut(); +u_int32_t fifoReset(void); +u_int32_t fifoReadCounter(int fifonum); +u_int32_t fifoReadStatus(); + + +u_int32_t fifo_full(void); + + + +u_int16_t* fifo_read_event(int ns); +u_int16_t* fifo_read_frame(); +u_int32_t* decode_data(int* datain); +//u_int32_t move_data(u_int64_t* datain, u_int64_t* dataout); +int setDynamicRange(int dr); +int getDynamicRange(); +int getNModBoard(); +int setNMod(int n); +int getNMod(); + +int setStoreInRAM(int b); +int allocateRAM(); + + +int writeADC(int addr, int val); +int prepareADC(); + + +int clearRAM(); + + +int setMaster(int f); +int setSynchronization(int s); + +int loadImage(int index, short int ImageVals[]); +int readCounterBlock(int startACQ, short int CounterVals[]); +int resetCounterBlock(int startACQ); + +int calibratePedestal(int frames); + +uint64_t writePatternWord(int addr, uint64_t word); +uint64_t writePatternIOControl(uint64_t word); +uint64_t writePatternClkControl(uint64_t word); +int setPatternLoop(int level, int *start, int *stop, int *n); +int setPatternWaitAddress(int level, int addr); +uint64_t setPatternWaitTime(int level, uint64_t t); + + +void initDac(int dacnum); +int setDac(int dacnum,int dacvalue); + +int setPower(int ind, int val); + +ROI *setROI(int nroi,ROI* arg,int *retvalsize, int *ret); +int getChannels(); + +/* + +u_int32_t setNBits(u_int32_t); +u_int32_t getNBits(); +*/ + +/* +//move to mcb_funcs? + +int readOutChan(int *val); +u_int32_t getModuleNumber(int modnum); +int testShiftIn(int imod); +int testShiftOut(int imod); +int testShiftStSel(int imod); +int testDataInOut(int num, int imod); +int testExtPulse(int imod); +int testExtPulseMux(int imod, int ow); +int testDataInOutMux(int imod, int ow, int num); +int testOutMux(int imod); +int testFpgaMux(int imod); +int calibration_sensor(int num, int *values, int *dacs) ; +int calibration_chip(int num, int *values, int *dacs); +*/ + + +#endif diff --git a/slsDetectorSoftware/jctbDetectorServer/gitInfoMoench.h b/slsDetectorSoftware/jctbDetectorServer/gitInfoMoench.h new file mode 100644 index 000000000..270653967 --- /dev/null +++ b/slsDetectorSoftware/jctbDetectorServer/gitInfoMoench.h @@ -0,0 +1,11 @@ +//#define SVNPATH "" +#define SVNURL "git@gitorious.psi.ch:sls_det_software/sls_detector_software.git/moenchDetectorServer" +//#define SVNREPPATH "" +#define SVNREPUUID "046a469b1e6582c4c55bd6eaeb4818b618d0a9a9" +//#define SVNREV 0x14 +//#define SVNKIND "" +//#define SVNSCHED "" +#define SVNAUTH "Maliakal_Dhanya" +#define SVNREV 0x14 +#define SVNDATE 0x20140603 +// diff --git a/slsDetectorSoftware/jctbDetectorServer/gitInfoMoenchTmp.h b/slsDetectorSoftware/jctbDetectorServer/gitInfoMoenchTmp.h new file mode 100644 index 000000000..58e48f497 --- /dev/null +++ b/slsDetectorSoftware/jctbDetectorServer/gitInfoMoenchTmp.h @@ -0,0 +1,11 @@ +//#define SVNPATH "" +#define SVNURL "" +//#define SVNREPPATH "" +#define SVNREPUUID "" +//#define SVNREV "" +//#define SVNKIND "" +//#define SVNSCHED "" +#define SVNAUTH "" +#define SVNREV "" +#define SVNDATE "" +// diff --git a/slsDetectorSoftware/jctbDetectorServer/jungfrauDetectorServerTest b/slsDetectorSoftware/jctbDetectorServer/jungfrauDetectorServerTest new file mode 100755 index 000000000..25804a0ba Binary files /dev/null and b/slsDetectorSoftware/jctbDetectorServer/jungfrauDetectorServerTest differ diff --git a/slsDetectorSoftware/jctbDetectorServer/mcb_funcs.c b/slsDetectorSoftware/jctbDetectorServer/mcb_funcs.c new file mode 100755 index 000000000..edf99652a --- /dev/null +++ b/slsDetectorSoftware/jctbDetectorServer/mcb_funcs.c @@ -0,0 +1,2701 @@ +#ifdef MCB_FUNCS + +#include +#include +#include +#include +#include +#include "registers_m.h" + +#ifndef PICASSOD +#include "server_defs.h" +#else +#include "picasso_defs.h" +#endif +#include "firmware_funcs.h" +#include "mcb_funcs.h" + + +/* global variables */ +#undef DEBUG +#undef DEBUGOUT + +extern int nModX; +//extern int dataBytes; +extern int dynamicRange; +enum detectorSettings thisSettings; + +int sChan, sChip, sMod, sDac, sAdc; +const int allSelected=-2; +const int noneSelected=-1; + + +sls_detector_module *detectorModules=NULL; +int *detectorChips=NULL; +int *detectorChans=NULL; +int *detectorDacs=NULL; +int *detectorAdcs=NULL; +//int numberOfProbes; + +ROI rois[MAX_ROIS]; +int nROI=0; +extern enum detectorType myDetectorType; + +/** for jungfrau reinitializing macro later in server_funcs.c in initDetector*/ +extern int N_CHAN; +extern int N_CHIP; +extern int N_DAC; +extern int N_ADC; +extern int N_CHANS; + +extern int nChans; +extern int nChips; +extern int nDacs; +extern int nAdcs; + +int initDetector() { + + int imod; + // sls_detector_module *myModule; + int n=getNModBoard(); + nModX=n; + +#ifdef VERBOSE + printf("Board is for %d modules\n",n); +#endif + + if(myDetectorType == JUNGFRAU){ + N_CHAN=JUNGFRAU_NCHAN; + N_CHIP=JUNGFRAU_NCHIP; + N_DAC=JUNGFRAU_NDAC; + N_ADC=JUNGFRAU_NADC; + N_CHANS=JUNGFRAU_NCHANS; + + nChans=N_CHAN; + nChips=N_CHIP; + nDacs=N_DAC; + nAdcs=N_ADC; + } + + detectorModules=malloc(n*sizeof(sls_detector_module)); + detectorDacs=malloc(n*N_DAC*sizeof(int)); + detectorAdcs=malloc(n*N_ADC*sizeof(int)); + detectorChips=NULL; + detectorChans=NULL; + detectorAdcs=NULL; + if(myDetectorType != JUNGFRAU){ + detectorChips=malloc(n*N_CHIP*sizeof(int)); + detectorChans=malloc(n*N_CHIP*N_CHAN*sizeof(int)); + } + +#ifdef VERBOSE + printf("modules from 0x%x to 0x%x\n",(unsigned int)(detectorModules), (unsigned int)(detectorModules+n)); + printf("dacs from 0x%x to 0x%x\n",(unsigned int)(detectorDacs), (unsigned int)(detectorDacs+n*N_DAC)); + printf("adcs from 0x%x to 0x%x\n",(unsigned int)(detectorAdcs), (unsigned int)(detectorAdcs+n*N_ADC)); + if(myDetectorType != JUNGFRAU){ + printf("chips from 0x%x to 0x%x\n",(unsigned int)(detectorChips), (unsigned int)(detectorChips+n*N_CHIP)); + printf("chans from 0x%x to 0x%x\n",(unsigned int)(detectorChans), (unsigned int)(detectorChans+n*N_CHIP*N_CHAN)); + } +#endif + + + for (imod=0; imoddacs=detectorDacs+imod*N_DAC; + (detectorModules+imod)->adcs=detectorAdcs+imod*N_ADC; + if(myDetectorType != JUNGFRAU){ + (detectorModules+imod)->chipregs=detectorChips+imod*N_CHIP; + (detectorModules+imod)->chanregs=detectorChans+imod*N_CHIP*N_CHAN; + } + (detectorModules+imod)->ndac=N_DAC; + (detectorModules+imod)->nadc=N_ADC; + (detectorModules+imod)->nchip=N_CHIP; + (detectorModules+imod)->nchan=N_CHIP*N_CHAN; + (detectorModules+imod)->module=imod; + (detectorModules+imod)->gain=0; + (detectorModules+imod)->offset=0; + (detectorModules+imod)->reg=0; + /* initialize registers, dacs, retrieve sn, adc values etc */ + } + thisSettings=UNINITIALIZED; + sChan=noneSelected; + sChip=noneSelected; + sMod=noneSelected; + sDac=noneSelected; + sAdc=noneSelected; + + /* + setCSregister(ALLMOD); //commented out by dhanya + setSSregister(ALLMOD); + counterClear(ALLMOD); + clearSSregister(ALLMOD); + putout("0000000000000000",ALLMOD); + */ + + /* initialize dynamic range etc. */ + /* dynamicRange=getDynamicRange(); //always 16 not required commented out + nModX=setNMod(-1);*/ + + // dynamicRange=32; + // initChip(0, 0,ALLMOD); + //nModX=n; + // + allocateRAM(); + + return OK; +} + + + + +int copyChannel(sls_detector_channel *destChan, sls_detector_channel *srcChan) { + destChan->chan=srcChan->chan; + destChan->chip=srcChan->chip; + destChan->module=srcChan->module; + destChan->reg=srcChan->reg; + return OK; +} + + +int copyChip(sls_detector_chip *destChip, sls_detector_chip *srcChip) { + + int ichan; + int ret=OK; + if ((srcChip->nchan)>(destChip->nchan)) { + printf("Number of channels of source is larger than number of channels of destination\n"); + return FAIL; + } + + destChip->nchan=srcChip->nchan; + destChip->reg=srcChip->reg; + destChip->chip=srcChip->chip; + destChip->module=srcChip->module; + for (ichan=0; ichan<(srcChip->nchan); ichan++) { + *((destChip->chanregs)+ichan)=*((srcChip->chanregs)+ichan); + } + return ret; +} + + +int copyModule(sls_detector_module *destMod, sls_detector_module *srcMod) { + + int ichip, idac, ichan, iadc; + + int ret=OK; + +#ifdef VERBOSE + printf("Copying module %x to module %x\n",(unsigned int)(srcMod),(unsigned int)(destMod)); +#endif + + if (srcMod->module>=0) { +#ifdef VERBOSE + printf("Copying module number %d to module number %d\n",srcMod->module,destMod->module); +#endif + destMod->module=srcMod->module; + } + if (srcMod->serialnumber>=0){ +/* #ifdef VERBOSE */ +/* printf("Copying module serial number %x to module serial number %x\n",srcMod->serialnumber,destMod->serialnumber); */ +/* #endif */ + destMod->serialnumber=srcMod->serialnumber; + } + if ((srcMod->nchip)>(destMod->nchip)) { + printf("Number of chip of source is larger than number of chips of destination\n"); + return FAIL; + } + if ((srcMod->nchan)>(destMod->nchan)) { + printf("Number of channels of source is larger than number of channels of destination\n"); + return FAIL; + } + if ((srcMod->ndac)>(destMod->ndac)) { + printf("Number of dacs of source is larger than number of dacs of destination\n"); + return FAIL; + } + if ((srcMod->nadc)>(destMod->nadc)) { + printf("Number of dacs of source is larger than number of dacs of destination\n"); + return FAIL; + } + +#ifdef VERBOSE + printf("DACs: src %d, dest %d\n",srcMod->ndac,destMod->ndac); + printf("ADCs: src %d, dest %d\n",srcMod->nadc,destMod->nadc); + printf("Chips: src %d, dest %d\n",srcMod->nchip,destMod->nchip); + printf("Chans: src %d, dest %d\n",srcMod->nchan,destMod->nchan); + +#endif + + + + destMod->ndac=srcMod->ndac; + destMod->nadc=srcMod->nadc; + destMod->nchip=srcMod->nchip; + destMod->nchan=srcMod->nchan; + if (srcMod->reg>=0) + destMod->reg=srcMod->reg; +#ifdef VERBOSE + printf("Copying register %x (%x)\n",destMod->reg,srcMod->reg ); +#endif + if (srcMod->gain>=0) + destMod->gain=srcMod->gain; + if (srcMod->offset>=0) + destMod->offset=srcMod->offset; + + // printf("copying gain and offset %f %f to %f %f\n",srcMod->gain,srcMod->offset,destMod->gain,destMod->offset); + + if(myDetectorType != JUNGFRAU){ + for (ichip=0; ichip<(srcMod->nchip); ichip++) { + if (*((srcMod->chipregs)+ichip)>=0) + *((destMod->chipregs)+ichip)=*((srcMod->chipregs)+ichip); + } + for (ichan=0; ichan<(srcMod->nchan); ichan++) { + if (*((srcMod->chanregs)+ichan)>=0) + *((destMod->chanregs)+ichan)=*((srcMod->chanregs)+ichan); + } + } + + for (idac=0; idac<(srcMod->ndac); idac++) { + if (*((srcMod->dacs)+idac)>=0) + *((destMod->dacs)+idac)=*((srcMod->dacs)+idac); + } + + for (iadc=0; iadc<(srcMod->nadc); iadc++) { + if (*((srcMod->adcs)+iadc)>=0) + *((destMod->adcs)+iadc)=*((srcMod->adcs)+iadc); + } + + return ret; +} + + + +/* Register commands */ + + +/* int clearDACSregister(int imod) { */ + +/* putout("1111111111111111",imod);//reset */ +/* putout("1111111111111110",imod);//cs down */ + +/* /\* commented out by dhanya */ +/* putout("0000000001000000",imod); */ +/* putout("0000000101000000",imod); */ +/* putout("0000000101000000",imod); */ +/* putout("0000000001000000",imod); */ +/* *\/ */ +/* #ifdef DEBUG */ +/* fprintf(stdout, "Clearing DAC shiftregister\n"); */ +/* #endif */ +/* // sDac=0; */ +/* sMod=imod; */ +/* if (imod==ALLMOD) */ +/* sMod=allSelected; */ +/* return OK; */ +/* } */ + +/* int nextDAC(int imod) { */ + +/* putout("1111111111111011",imod);//cs up */ +/* putout("1111111111111001",imod);//clk down */ +/* putout("1111111111111111",imod);//reset */ + +/* /\*commented out by dhanya */ +/* putout("0000000001000000",imod); */ +/* putout("0000000001001000",imod); */ +/* putout("0000000001000000",imod); */ +/* *\/ */ +/* #ifdef DEBUG */ +/* fprintf(stdout, "Next DAC\n"); */ +/* #endif */ +/* // sDac++; */ +/* sMod=imod; */ +/* if (imod==ALLMOD) */ +/* sMod=allSelected; */ +/* return OK; */ +/* } */ + + +int clearCSregister(int imod) { + + putout("0000000001000000",imod); + putout("0000100001000000",imod); + putout("0000100001000000",imod); + putout("0000000001000000",imod); +#ifdef DEBUG + fprintf(stdout, "Clearing CS shiftregister\n"); +#endif + /* + sChan=noneSelected; + sMod=noneSelected; + sDac=noneSelected; + sAdc=noneSelected; + */ + sChip=noneSelected; + sMod=imod; + if (imod==ALLMOD) + sMod=allSelected; + //putout("0000000000000000",imod); + return 0; +} + +int setCSregister(int imod){ + + putout("0000000001000000",imod); + putout("0001000001000000",imod); + putout("0001000001000000",imod); + putout("0000000001000000",imod); +#ifdef DEBUG + fprintf(stdout, "Setting CS shiftregister\n"); +#endif + putout("0000000000000000",imod); + sChip=allSelected; + sMod=imod; + if (imod==ALLMOD) + sMod=allSelected; + return 0; +} + +int nextChip(int imod){ + + putout("0000000001000000",imod); + putout("0010000001000000",imod); + putout("0000000001000000",imod); +#ifdef DEBUG + fprintf(stdout, "Next Chip\n"); +#endif + sChip++; + sMod=imod; + if (imod==ALLMOD) + sMod=allSelected; + return 0; +} + +int firstChip(int imod){ + + putout("0100000001000000",imod); + putout("0110000001000000",imod); + putout("0100000001000000",imod); +#ifdef DEBUG + fprintf(stdout, "First Chip\n"); +#endif + sChip=0; + sMod=imod; + if (imod==ALLMOD) + sMod=allSelected; + return 0; +} + +int clearSSregister(int imod){ + int i; + putout("0000011000000000",imod); + for (i=0; i<10; i++) + putout("0000111000000000",imod); + putout("0000011000000000",imod); +#ifdef DEBUG + fprintf(stdout,"Clearing SS shiftregister\n"); +#endif + putout("0000000000000000",imod); + sChan=noneSelected; + sMod=imod; + if (imod==ALLMOD) + sMod=allSelected; + return 0; +} + +int setSSregister(int imod){ + int i; + putout("0000011000000000",imod); + for (i=0; i<10; i++) + putout("0001011000000000",imod); + putout("0000011000000000",imod); +#ifdef DEBUG + fprintf(stdout,"Setting SS shiftregister\n"); +#endif + putout("0000000000000000",imod); + sChan=allSelected; + sMod=imod; + if (imod==ALLMOD) + sMod=allSelected; + return 0; +} + +int nextStrip(int imod){ + putout("0000011000000000",imod); + putout("0010011000000000",imod); + putout("0000011000000000",imod); +#ifdef DEBUG + fprintf(stdout,"|-"); +#endif + sChan++; + sMod=imod; + if (imod==ALLMOD) + sMod=allSelected; + return 0; +} + +int selChannel(const int strip,int imod) { + int istrip; + clearSSregister(imod); + nextStrip(imod); + for (istrip=0; istrip=0 && imod=0) */ +/* initDAC(ind,val, imod); */ + +/* if (imod>=0 && imodgain,(detectorModules+imod)->offset); */ +/* #endif */ +/* if ((detectorModules+imod)->gain>0) */ +/* myg=(detectorModules+imod)->gain; */ +/* else { */ +/* if (thisSettings>=0 && thisSettings<3) */ +/* myg=g[thisSettings]; */ +/* // else */ +/* //myg=-1; */ +/* } */ + +/* if ((detectorModules+imod)->offset>0) */ +/* myo=(detectorModules+imod)->offset; */ +/* else { */ +/* if (thisSettings>=0 && thisSettings<3) */ +/* myo=o[thisSettings]; */ +/* // else */ +/* //myo=-1; */ +/* } */ + +/* if (myg>0 && myo>0) { */ +/* //ethr=(myo-detectorDacs[VTHRESH+imod*N_DAC])*1000/myg; */ + +/* ethr=(myo-setDACRegister(VDAC0,-1,imod))*1000/myg;//edited by dhanya */ +/* // else */ +/* // ethr=-1; */ + +/* } */ +/* #ifdef VERBOSE */ +/* //printf("module=%d gain=%f, offset=%f, dacu=%f\n",imod, myg, myo, detectorDacs[VTHRESH+imod*N_DAC]); */ +/* printf("module=%d gain=%f, offset=%f, dacu=%d\n",imod, myg, myo,(int)(setDACRegister(VDAC0,-1,imod)));//edited by dhanya */ +/* printf("Threshold energy of module %d is %d eV\n", imod, ethr); */ +/* #endif */ + +/* if (imod==0) */ +/* ret=ethr; */ +/* else { */ +/* if (ethr>(ret+100) || ethr<(ret-100)) */ +/* return FAIL; */ +/* } */ +/* } */ +/* } */ +/* return ret; */ +/* } */ + +/* int setThresholdEnergy(int ethr) { */ +/* double g[3]=DEFAULTGAIN; */ +/* double o[3]=DEFAULTOFFSET; */ +/* double myg=-1, myo=-1; */ +/* int dacu; */ +/* int imod; */ +/* int ret=ethr; */ + +/* setSettings(GET_SETTINGS,-1);//-1 added by dhanya */ +/* if (thisSettings>=0 || thisSettings<3){ */ +/* myg=g[thisSettings]; */ +/* myo=o[thisSettings]; */ +/* } */ +/* for (imod=0; imodgain>0) */ +/* myg=(detectorModules+imod)->gain; */ +/* else */ +/* if (thisSettings>=0 && thisSettings<3) */ +/* myg=g[thisSettings]; */ +/* else */ +/* myg=-1; */ +/* if ((detectorModules+imod)->offset>0) */ +/* myo=(detectorModules+imod)->offset; */ +/* else */ +/* if (thisSettings>=0 && thisSettings<3) */ +/* myo=o[thisSettings]; */ +/* else */ +/* myo=-1; */ +/* } else { */ +/* if (thisSettings>=0 && thisSettings<3) */ +/* myo=o[thisSettings]; */ +/* else */ +/* myo=-1; */ +/* if (thisSettings>=0 && thisSettings<3) */ +/* myg=g[thisSettings]; */ +/* else */ +/* myg=-1; */ +/* } */ +/* if (myg>0 && myo>0) { */ +/* dacu=myo-myg*((double)ethr)/1000.; */ +/* #ifdef VERBOSE */ +/* printf("module %d (%x): gain %f, off %f, energy %d eV, dac %d\n",imod,(unsigned int)((detectorModules+imod)),(detectorModules+imod)->gain,(detectorModules+imod)->offset, ethr,dacu); */ +/* #endif */ +/* } else { */ +/* dacu=ethr; */ +/* #ifdef VERBOSE */ +/* printf("could not set threshold energy for module %d, settings %d (offset is %f; gain is %f)\n",imod,thisSettings,myo,myg); */ +/* #endif */ +/* } */ +/* initDACbyIndexDACU(VDAC0, dacu, imod); ///needs to be fixed dhanya */ +/* } */ +/* return ret; */ +/* } */ + + + +/* int getDACbyIndexDACU(int ind, int imod) { */ +/* /\* */ +/* if (detectorDacs) { */ +/* if (imodndac) */ +/* return (detectorDacs[ind+imod*N_DAC]); */ +/* } */ +/* return FAIL; */ +/* *\/ */ +/* return setDACRegister(ind, -1, imod); */ +/* } */ + + +/* int initDAC(int dac_addr, int value, int imod) { */ +/* // int i; */ +/* #ifdef VERBOSE */ +/* printf("Programming dac %d with value %d\n", dac_addr, value); */ +/* #endif */ +/* clearDACSregister(imod); */ +/* program_one_dac(dac_addr,value,imod); */ +/* nextDAC(imod); */ +/* clearDACSregister(imod); */ + +/* return 0; */ +/* } */ + +int getTemperatureByModule(int tempSensor, int imod) +{ + int im; + //for the particular module + if (imod>=0 && imod=0 && imod=0 && imod=0) { */ +/* #ifdef VERBOSE */ +/* fprintf(stdout, "voltage %d\n", *(v+iaddr)); */ +/* #endif */ +/* program_one_dac(iaddr, *(v+iaddr),imod); */ +/* } */ +/* nextDAC(imod); */ +/* } */ + + +/* clearDACSregister(imod); */ + +/* return 0; */ + +/* } */ + + + + +int setSettings(int i, int imod) { +#ifdef VERBOSE + if(i==-1) + printf("\nReading settings of detector...\n"); + else + printf("\ninside set settings wit settings=%d...\n",i); +#endif + int isett=-1,val=-1,retval=-1; + enum conf_gain { + dynamic = 0x0f00, //dynamic + dynamichighgain0 = 0x0f01, //dynamichighgain0 + fixgain1 = 0x0f02, //fixgain1 + fixgain2 = 0x0f06, //fixgain2 + forceswitchgain1 = 0x1f00, //forceswitchgain1 + forceswitchgain2 = 0x3f00 //forceswitchgain2 + }; + + //determine conf value to write + if(i!=GET_SETTINGS){ + switch(i){ + case DYNAMICGAIN: val = dynamic;break; + case DYNAMICHG0: val = dynamichighgain0;break; + case FIXGAIN1: val = fixgain1;break; + case FIXGAIN2: val = fixgain2;break; + case FORCESWITCHG1: val = forceswitchgain1;break; + case FORCESWITCHG2: val = forceswitchgain2;break; + default: + printf("Error: This settings is not defined for this detector %d\n",i); + return GET_SETTINGS; + } + } + + retval=initConfGainByModule(i,val,imod); + + switch(retval){ + case dynamic: isett=DYNAMICGAIN; break; + case dynamichighgain0: isett=DYNAMICHG0; break; + case fixgain1: isett=FIXGAIN1; break; + case fixgain2: isett=FIXGAIN2; break; + case forceswitchgain1: isett=FORCESWITCHG1; break; + case forceswitchgain2: isett=FORCESWITCHG2; break; + default: + isett=UNDEFINED; + printf("Error:Wrong settings read out from Gain Reg 0x%x\n",retval); + break; + } + + thisSettings=isett; +//#ifdef VERBOSE + printf("detector settings are %d\n",thisSettings); +//#endif + return thisSettings; +} + + + + +/* Initialization*/ + +int initChannelbyNumber(sls_detector_channel myChan) {printf("in init channel by number\n"); + int reg=myChan.reg; + int ft=reg & TRIM_DR; + int cae=(reg>>(NTRIMBITS))&1; + int ae=(reg>>(NTRIMBITS+1))&1; + int coe=(reg>>(NTRIMBITS+2))&1; + int ocoe=(reg>>(NTRIMBITS+3))&1; + int counts=(reg>>(NTRIMBITS+4)); +#ifdef VERBOSE + printf("Initializing channel %d chip %d module %d reg %x\n",myChan.chan,myChan.chip,myChan.module, reg); + printf("trim %d, cae %d, ae %d, coe %d, ocoe %d, counts %d\n",ft, cae, ae, coe, ocoe, counts); +#endif + + if (myChan.chip<0) + setCSregister(myChan.module); + else + selChip(myChan.chip,myChan.module); + + if (myChan.chan<0) + setSSregister(myChan.module); + else + selChannel(myChan.chan,myChan.module); + + initChannel(ft,cae,ae, coe, ocoe, counts,myChan.module); + + setDynamicRange(dynamicRange); + + setCSregister(ALLMOD); + clearSSregister(ALLMOD); + putout("0000000000000000",ALLMOD); + + return myChan.reg; + +} + +int getChannelbyNumber(sls_detector_channel* myChan) { + int imod, ichip, ichan; + imod=myChan->module; + ichip=myChan->chip; + ichan=myChan->chan; + + if (detectorChans) { + if (imod=0) { + if (ichip<(detectorModules+imod)->nchip && ichan<(detectorModules+imod)->nchan/(detectorModules+imod)->nchip) + myChan->reg=detectorChans[imod*N_CHAN*N_CHIP+ichip*N_CHAN+ichan]; + return OK; + } + } + return FAIL; + +} + +int getTrimbit(int imod, int ichip, int ichan) { + if (detectorChans) { + if (imod=0) + if (ichip<(detectorModules+imod)->nchip && ichan<(detectorModules+imod)->nchan/(detectorModules+imod)->nchip) + return (detectorChans[imod*N_CHAN*N_CHIP+ichip*N_CHAN+ichan] & TRIM_DR); + } + + return -1; +} + +int initChannel(int ft,int cae, int ae, int coe, int ocoe, int counts, int imod){ + + int ibit, bit, i, im, ichip, ichan; + int chanmi, chanma, chipmi, chipma, modmi, modma; + + + + sMod=imod; + // printf("initializing module %d\n",sMod); + if (imod==ALLMOD) { + sMod=allSelected; + + // printf("initializing all modules\n"); + } + + if (sChan==allSelected) { + // printf("initializing all channels ft=%d coe=%d\n",ft,coe); + chanmi=0; + chanma=N_CHAN; + } else if (sChan==noneSelected || sChan>N_CHAN || sChan<0) { + // printf("initializing no channels ft=%d coe=%d\n",ft,coe); + chanmi=0; + chanma=-1; + } else { + // printf("initializing channel %d ft=%d coe=%d\n",sChan, ft,coe); + chanmi=sChan; + chanma=sChan+1; + } + + if (sChip==allSelected) { + // printf("initializing all chips\n"); + chipmi=0; + chipma=N_CHIP; + } else if (sChip==noneSelected || sChip>N_CHIP || sChip<0) { + // printf("initializing no chips\n"); + chipmi=0; + chipma=-1; + } else { + // printf("initializing chip %d\n",sChip); + chipmi=sChip; + chipma=sChip+1; + } + + + if (sMod==allSelected) { + modmi=0; + modma=nModX;//getNModBoard(); + } else if (sMod==noneSelected || sMod>nModX || sMod<0) {//(sMod==noneSelected || sMod>getNModBoard() || sMod<0) { + modmi=0; + modma=-1; + return 1; + } else { + modmi=sMod; + modma=sMod+1; + } + + if (detectorChans) { + for (im=modmi; im63 || ft<0) { + fprintf(stdout,"Fine Threshold is %d while should be between 0 and 63!",ft); + return 1; + } + /*cal_enable*/ + if (cae) { + putout("0100000000000000",imod); + putout("0110000000000000",imod); + } else { + putout("0000000000000000",imod); + putout("0010000000000000",imod); + } + /*n_an_enable*/ + if (ae) { + putout("0000000000000000",imod); + putout("0010000000000000",imod); + putout("0000000000000000",imod); + } else { + putout("0100000000000000",imod); + putout("0110000000000000",imod); + putout("0100000000000000",imod); + } + /*trb5*/ + ibit=5; + bit=ft & (1<>1; + int nchan, ichan; + int ft, cae, ae, coe, ocoe, counts, chanreg; + + + + nchan=myChip.nchan; + if (ichip<0) + setCSregister(imod); + else + selChip(ichip,imod); + + clearSSregister(imod); + for (ichan=0; ichan>(NTRIMBITS+1))&1; + ae=(chanreg>>(NTRIMBITS+2))&1; + coe=((chanreg)>>(NTRIMBITS+3))&1; + ocoe=((chanreg)>>(NTRIMBITS+4))&1; + counts=((chanreg)>>(NTRIMBITS+5)); + nextStrip(imod); + initChannel(ft,cae,ae, coe, ocoe, counts,imod); + } + initChip(obe,ow,imod); + return myChip.reg; + +} + +int getChipbyNumber(sls_detector_chip* myChip){ + int imod, ichip; + imod=myChip->module; + ichip=myChip->chip; + + if (detectorChips) { + if (imodnchip) { + myChip->reg=detectorChips[ichip+imod*N_CHIP]; + myChip->nchan=N_CHAN; + myChip->chanregs=detectorChans+imod*N_CHAN*N_CHIP+ichip*N_CHIP; + return OK; + } + } + return FAIL; + +} + + + +int initChip(int obe, int ow,int imod){ + int i; + int im, ichip; + int chipmi, chipma, modmi, modma; + /* switch (ow) { + case 0:; + case 1: + setDynamicRange(32); + break; + case 2: + setDynamicRange(16); + break; + case 3: + setDynamicRange(8); + break; + case 4: + setDynamicRange(4); + break; + case 5: + setDynamicRange(1); + break; + default: + setDynamicRange(32); + break; + } + */ + +#ifdef DEBUGOUT + printf("Initializing chip\n"); +#endif + putout("0000000000000000",imod); +#ifdef DEBUGOUT + printf("Output mode= %d\n", ow); +#endif + + /* clearing shift in register */ + for (i=0; i<10; i++) + putout("0000100000000000",imod); + putout("0000000000000000",imod); + + if (ow>0) { + putout("0100000000000000",imod); + putout("0110000000000000",imod); + putout("0100000000000000",imod); + for (i=0; i<(OUTMUX_OFFSET-1); i++) { + putout("0000000000000000",imod); + putout("0010000000000000",imod); + putout("0000000000000000",imod); + } + if (ow>1) { + putout("0000000000000000",imod); + putout("0010000000000000",imod); + putout("0000000000000000",imod); + } + if (ow>2) { + putout("0000000000000000",imod); + putout("0010000000000000",imod); + putout("0000000000000000",imod); + } + if (ow>3) { + putout("0000000000000000",imod); + putout("0010000000000000",imod); + putout("0000000000000000",imod); + } + if (ow>4) { + putout("0000000000000000",imod); + putout("0010000000000000",imod); + putout("0000000000000000",imod); + } + } +#ifdef DEBUGOUT + printf("Output buffer enable= %d\n", obe); +#endif + if (obe) { + putout("0100000000000000",imod); + putout("0110000000000000",imod); + putout("0100000000000000",imod); + } else { + putout("0000000000000000",imod); + putout("0010000000000000",imod); + putout("0000000000000000",imod); + } + /*}*/ + putout("0000000000000000",imod); + + + + + + sMod=imod; + if (imod==ALLMOD) + sMod=allSelected; + + + if (sChip==allSelected) { + chipmi=0; + chipma=N_CHIP; + } else if (sChip==noneSelected || sChip>N_CHIP || sChip<0) { + chipmi=0; + chipma=-1; + } else { + chipmi=sChip; + chipma=sChip+1; + } + + + if (sMod==allSelected) { + modmi=0; + modma=nModX;//getNModBoard(); + } else if (sMod==noneSelected || sMod>nModX || sMod<0) {//(sMod==noneSelected || sMod>getNModBoard() || sMod<0) { + modmi=0; + modma=-1; + } else { + modmi=sMod; + modma=sMod+1; + } + + if (detectorChips) { + for (im=modmi; imN_CHIP || sChip<0) { + chipmi=0; + chipma=-1; + } else { + chipmi=sChip; + chipma=sChip+1; + } + + + if (sMod==allSelected) { + modmi=0; + modma=nModX;//getNModBoard(); + } else if (sMod==noneSelected || sMod>nModX || sMod<0) {//(sMod==noneSelected || sMod>getNModBoard() || sMod<0) { + modmi=0; + modma=-1; + } else { + modmi=sMod; + modma=sMod+1; + } + + if (detectorChips) { + for (im=modmi; imnModX || sMod<0) {//(sMod==noneSelected || sMod>getNModBoard() || sMod<0) { + modmi=0; + modma=-1; + } else { + modmi=sMod; + modma=sMod+1; + } + + if (detectorModules) { + for (im=modmi; imreg)=cm; +#ifdef VERBOSE + printf("imod=%d reg=%d (%x)\n",im,(detectorModules+im)->reg,(unsigned int)((detectorModules+im))); +#endif + } + } + return 0; +} + +int initModulebyNumber(sls_detector_module myMod) { + + printf("\ninside initmoduleynumberrrr..\n"); + printf("000\n"); + int nchip,nchan;//int ichip, nchip, ichan, nchan; + int im, modmi,modma; + // int ft, cae, ae, coe, ocoe, counts, chanreg; + int imod; + // int obe; + // int ow; + /* int v[N_DAC];*/ + int retval =-1, idac; + + + nchip=myMod.nchip; + nchan=(myMod.nchan)/nchip; + + imod=myMod.module; + sMod=imod; + + if (sMod==ALLMOD) + sMod=allSelected; + + if (sMod==allSelected) { + modmi=0; + modma=nModX;//getNModBoard(); + } else if (sMod==noneSelected || sMod>nModX || sMod<0) {// (sMod==noneSelected || sMod>getNModBoard() || sMod<0) { + modmi=0; + modma=-1; + } else { + modmi=sMod; + modma=sMod+1; + } + + printf("222\n"); + /* + for (idac=0; idacmodule; +#ifdef VERBOSE + printf("Getting module %d\n",imod); +#endif + if (detectorModules) { + copyModule(myMod,detectorModules+imod); + ; + } else + return FAIL; + + return OK; +} + +/* To chips */ +int clearCounter(int imod){ + int i; +#ifdef DEBUG + printf("Clearing counter with contclear\n"); +#endif + putout("0000000000000000",imod); + for (i=0; i<10; i++) + putout("0000000000010000",imod); + putout("0000000000000000",imod); + + return 0; +} + +int clearOutReg(int imod){ + int i; +#ifdef DEBUG + printf("Clearing output register\n"); +#endif + putout("0000010000000000",imod); + for (i=0; i<10; i++) + putout("0000110000000000",imod); + putout("0000010000000000",imod); + return 0; +} +int setOutReg(int imod){ + int i; +#ifdef DEBUG + printf("Setting output register\n"); +#endif + putout("0000010000000000",imod); + for (i=0; i<10; i++) + putout("0001010000000000",imod); + putout("0000010000000000",imod); + return 0; +} + + +int extPulse(int ncal, int imod) { + int ical; +#ifdef DEBUG + printf("Giving a clock pulse to the counter\n"); +#endif + for (ical=0; ical0 && i%2==0) { + printf("Shift in: module %d chip %i bit %d read %d instead of %d \n",k,j,i,val & 1<< j, i%2); + result++; + } + if (i%2>0 && (val & 1<0 && (dum & (1<0) { + printf("Shift out: module %d chip %i bit %d read %d instead of %d \n",k,j,i,val & 1<< j, (dum &1<0 && i%2==0) { + printf("Shift stsel: module %d chip %i bit %d read %d instead of %d \n",k,j,i,val & 1<< j, i%2); + result++; + } + if (i%2>0 && (val & 1<> 1; + + + putout("0000000000000000",ALLMOD); + putout("0010000000000000",ALLMOD); //change mux setting + putout("0000000000000000",ALLMOD); + } + + printf("Test FpgaMux module %d : %d errors\n", imod,result); + if (result) + return 1; + else + return 0; +} + + + + + + + + + +int calibration_sensor(int num, int *v, int *dacs) { + int ich, ichip, imod; + int val[10]; + + + printf("calibrating sensor..."); + for (imod=0; imod=0){ */ + +/* //clear rois */ +/* for(i=0;i=0) && (adc<=4)); */ +/* else { */ +/* printf("warning:adc value greater than 5. deleting roi\n"); */ +/* adc=-1; */ +/* } */ +/* } */ +/* } */ + + +/* //set rois for just 1 adc - take only 1st roi */ +/* if(adc!=-1){ */ +/* rois[0].xmin=adc*(GOTTHARDNCHAN*NCHIPS_PER_ADC); */ +/* rois[0].xmax=(adc+1)*(GOTTHARDNCHAN*NCHIPS_PER_ADC)-1; */ +/* rois[0].ymin=-1; */ +/* rois[0].ymax=-1; */ +/* nROI = 1; */ +/* }else */ +/* nROI = 0; */ + +/* if((arg[0].xmin!=rois[0].xmin)||(arg[0].xmax!=rois[0].xmax)||(arg[0].ymin!=rois[0].ymin)||(arg[0].ymax!=rois[0].ymax)) */ +/* *ret=FAIL; */ +/* if(n!=nROI) */ +/* *ret=FAIL; */ + +/* //set adc of interest */ +/* setADC(adc); */ +/* } */ + +/* //#ifdef VERBOSE */ +/* printf("Rois:\n"); */ +/* for( i=0;i +#include "communication_funcs.h" +#include "server_funcs.h" +#include + + + +extern int sockfd; +extern int phase_shift; + + + +void error(char *msg) +{ + perror(msg); +} + +int main(int argc, char *argv[]) +{ + int portno, b; + char cmd[500]; + int retval=OK; + int sd, fd; + int iarg; + int checkType = 1; + + + for(iarg=1; iarg 2) && (!strcasecmp(argv[2],"stopserver"))){ + portno = DEFAULT_PORTNO+1; + if ( sscanf(argv[1],"%d",&portno) ==0) { + printf("could not open stop server: unknown port\n"); + return 1; + } + b=0; + printf("\n\nStop Server\nOpening stop server on port %d\n",portno); + checkType=0; + + } + + //control server + else { + portno = DEFAULT_PORTNO; + if(checkType) + sprintf(cmd,"%s %d stopserver &",argv[0],DEFAULT_PORTNO+1); + else + sprintf(cmd,"%s %d stopserver -test with_gotthard &",argv[0],DEFAULT_PORTNO+1); + printf("\n\nControl Server\nOpening control server on port %d\n",portno ); + + //printf("\n\ncmd:%s\n",cmd); + system(cmd); + b=1; + checkType=1; + + } + + + + + + init_detector(b, checkType); + + + sd=bindSocket(portno); + sockfd=sd; + if (getServerError(sd)) { + printf("server error!\n"); + return -1; + } + + /* assign function table */ + function_table(); +#ifdef VERBOSE + printf("function table assigned \n"); +#endif + + + /* waits for connection */ + while(retval!=GOODBYE) { +#ifdef VERBOSE + printf("\n"); +#endif +#ifdef VERY_VERBOSE + printf("Waiting for client call\n"); +#endif + fd=acceptConnection(sockfd); +#ifdef VERY_VERBOSE + printf("Conenction accepted\n"); +#endif + retval=decode_function(fd); +#ifdef VERY_VERBOSE + printf("function executed\n"); +#endif + closeConnection(fd); +#ifdef VERY_VERBOSE + printf("connection closed\n"); +#endif + } + + exitServer(sockfd); + printf("Goodbye!\n"); + + return 0; +} + diff --git a/slsDetectorSoftware/jctbDetectorServer/server_defs.h b/slsDetectorSoftware/jctbDetectorServer/server_defs.h new file mode 100755 index 000000000..781cefc33 --- /dev/null +++ b/slsDetectorSoftware/jctbDetectorServer/server_defs.h @@ -0,0 +1,78 @@ +#ifndef SERVER_DEFS_H +#define SERVER_DEFS_H + +#include "sls_detector_defs.h" + +#include + + +// Hardware definitions +#define NMAXMODY 1 +#define NMAXMOD (NMAXMODX*NMAXMODY) + +#define NCHAN 32 +#define NCHIP 1 +#define NADC 1 + +#ifdef CTB +#define NDAC 24 +#define NPWR 5 +#else +#define NDAC 16 +#define NPWR 0 +#endif +#define DAC_CMD_OFF 20 + +#define NMAXMODX 1 +#define NCHANS (NCHAN*NCHIP*NMAXMOD) +#define NDACS (NDAC*NMAXMOD) + +#define JUNGFRAU_NCHAN (256*256) +#define JUNGFRAU_NCHIP 8 +#define JUNGFRAU_NADC 0 +#define JUNGFRAU_NDAC 16 +#define JUNGFRAU_NCHANS (JUNGFRAU_NCHAN*JUNGFRAU_NCHIP*NMAXMOD) + + + +/**when moench readout tested with gotthard module*/ +#define GOTTHARDNCHAN 128 +#define GOTTHARDNCHIP 10 + + +#define NTRIMBITS 6 +#define NCOUNTBITS 24 + +#define NCHIPS_PER_ADC 2 + +//#define TRIM_DR ((2**NTRIMBITS)-1) +//#define COUNT_DR ((2**NCOUNTBITS)-1) +#define TRIM_DR (((int)pow(2,NTRIMBITS))-1) +#define COUNT_DR (((int)pow(2,NCOUNTBITS))-1) + + +#define ALLMOD 0xffff +#define ALLFIFO 0xffff + +#define GOTTHARD_ADCSYNC_VAL 0x32214 +#define ADCSYNC_VAL 0x02111 +#define TOKEN_RESTART_DELAY 0x88000000 +#define TOKEN_RESTART_DELAY_ROI 0x1b000000 +#define TOKEN_TIMING_REV1 0x1f16 +#define TOKEN_TIMING_REV2 0x1f0f + +#define DEFAULT_PHASE_SHIFT 0 // 120 +#define DEFAULT_IP_PACKETSIZE 0x0522 +#define DEFAULT_UDP_PACKETSIZE 0x050E +#define ADC1_IP_PACKETSIZE 256*2+14+20 +#define ADC1_UDP_PACKETSIZE 256*2+4+8+2 + +#ifdef VIRTUAL +#define DEBUGOUT +#endif + +#define CLK_FREQ 156.25E+6 +#define ADC_CLK_FREQ 32E+6 + + +#endif diff --git a/slsDetectorSoftware/jctbDetectorServer/server_funcs.c b/slsDetectorSoftware/jctbDetectorServer/server_funcs.c new file mode 100755 index 000000000..e4551b3cb --- /dev/null +++ b/slsDetectorSoftware/jctbDetectorServer/server_funcs.c @@ -0,0 +1,3513 @@ +#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 "gitInfoMoench.h" + +#define FIFO_DATA_REG_OFF 0x50<<11 +// Global variables + + +int (*flist[256])(int); + + +//defined in the detector specific file +/* #ifdef MYTHEND */ +/* const enum detectorType myDetectorType=MYTHEN; */ +/* #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; */ +/* #else */ +enum detectorType myDetectorType=GENERIC; +/* #endif */ + + +extern int nModX; +extern int nModY; +extern int 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; + +/* global variables for optimized readout */ +extern unsigned int *ram_values; +char *dataretval=NULL; +int nframes, iframes, dataret; +char mess[1000]; + +int digitalTestBit = 0; + +extern int withGotthard; + + +int adcvpp=0x4; + +/** for jungfrau reinitializing macro later */ +int N_CHAN=NCHAN; +int N_CHIP=NCHIP; +int N_DAC=NDAC; +int N_ADC=NADC; +int N_CHANS=NCHANS; + + +int init_detector(int b, int checkType) { + + int i; + if (mapCSP0()==FAIL) { printf("Could not map memory\n"); + exit(1); + } + + //print version + printf("v: 0x%x\n",bus_r(FPGA_VERSION_REG)); + printf("fp: 0x%x\n",bus_r(FIX_PATT_REG)); + + //checktype + if (checkType) { + printf("Bus test... (checktype is %d; b is %d)",checkType,b ); + 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)) + printf("ERROR: wrote 0x%x, read 0x%x\n",i*100,bus_r(SET_DELAY_LSB_REG)); + } + printf("Finished\n"); + }else + printf("(checktype is %d; b is %d)",checkType,b ); + + + //confirm the detector type + switch ((bus_r(PCB_REV_REG) & DETECTOR_TYPE_MASK)>>DETECTOR_TYPE_OFFSET) { + case MOENCH03_MODULE_ID: + myDetectorType=MOENCH; + printf("This is a MOENCH03 module %d\n",MOENCH); + break; + + case JUNGFRAU_MODULE_ID: + myDetectorType=JUNGFRAU; + printf("This is a Jungfrau module %d\n", JUNGFRAU); + break; + + case JUNGFRAU_CTB_ID: + myDetectorType=JUNGFRAUCTB; + printf("This is a Jungfrau CTB %d\n", JUNGFRAUCTB); + break; + + default: + myDetectorType=GENERIC; + printf("Unknown detector type %02x\n",(bus_r(PCB_REV_REG) & DETECTOR_TYPE_MASK)>>DETECTOR_TYPE_OFFSET); + break; + + } + printf("Detector type is %d\n", myDetectorType); + + + //control server only-- + if (b) { + 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 + printf("\nBoard Revision:0x%x\n",(bus_r(PCB_REV_REG)&BOARD_REVISION_MASK)); + if(myDetectorType == JUNGFRAU) + initDetector(); /*allocating detectorModules, detectorsDacs etc for "settings", also does allocate RAM*/ + dataBytes=NMAXMOD*N_CHIP*N_CHAN*2; /**Nchip and Nchan real values get assigned in initDetector()*/ + printf("Initializing Detector\n"); + //bus_w16(CONTROL_REG, SYNC_RESET); // reset registers +#endif + + // testFpga(); + // testRAM(); + // printf("ADC_SYNC_REG:%x\n",bus_r(ADC_SYNC_REG)); + //moench specific + // setPhaseShiftOnce(); + /*some registers set, which is in common with jungfrau, please check */ + prepareADC(); + //setADC(-1); //already does setdaqreg and clean fifo + // setSettings(GET_SETTINGS,-1); + /*some registers set, which is in common with jungfrau, please check */ + initDac(0); initDac(8); //initializes the two dacs + + if(myDetectorType==JUNGFRAU){ + /** for jungfrau reinitializing macro */ + N_CHAN=JUNGFRAU_NCHAN; + N_CHIP=JUNGFRAU_NCHIP; + N_DAC=JUNGFRAU_NDAC; + N_ADC=JUNGFRAU_NADC; + N_CHANS=JUNGFRAU_NCHANS; + + + //set dacs + int retval = -1; + int dacvalues[14][2]={ + {0, 1250}, //vout_cm + {10, 1053}, //vin_com + {1, 600}, //vb_sda + {11, 1000}, //vb_colbuf + {2, 3000}, //vb_test_cur + {3, 830}, //vcascp_pixbuf + {4, 1630}, //vcascn_pixbuf + {12, 750}, //vb_pixbuf + {6, 480}, //vref_ds + {5, 1000}, //vb_ds + {7, 400}, //vref_comp + {13, 1220}, //vb_comp + {8, 1500}, //vref_prech + {9, 3000}, //vdd_prot + }; + for(i=0;i<14;++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); + } + + //power on the chips + bus_w(POWER_ON_REG,0x1); + + //reset adc + writeADC(ADCREG1,0x3); writeADC(ADCREG1,0x0); + writeADC(ADCREG2,0x40); + writeADC(ADCREG3,0xf); + writeADC(ADCREG4,0x3f); + //vrefs - configurable? + writeADC(ADCREG_VREFS,0x2); + + + //set ADCINVERSionreg (by trial and error) + bus_w(ADC_INVERSION_REG,0x453b2a9c); + + //set adc_pipeline + bus_w(ADC_PIPELINE_REG,0x20); //same as ADC_OFFSET_REG + + //set dbit_pipeline + bus_w(DBIT_PIPELINE_REG,0x100e); + usleep(1000000);//1s + + //reset mem machine fifos fifos + bus_w(MEM_MACHINE_FIFOS_REG,0x4000); + bus_w(MEM_MACHINE_FIFOS_REG,0x0); + + //reset run control + bus_w(MEM_MACHINE_FIFOS_REG,0x0400); + bus_w(MEM_MACHINE_FIFOS_REG,0x0); + + //set default setting + setSettings(DYNAMICGAIN,-1); + } + + + //Initialization of acquistion parameters + setFrames(-1); + setTrains(-1); + setExposureTime(-1); + setPeriod(-1); + setDelay(-1); + setGates(-1); + + setTiming(GET_EXTERNAL_COMMUNICATION_MODE); + setMaster(GET_MASTER); + setSynchronization(GET_SYNCHRONIZATION_MODE); + startReceiver(0); //firmware + }//end of control server only-- + else printf("\n\n"); + + + //common for both control and stop server + strcpy(mess,"dummy message"); + strcpy(lastClientIP,"none"); + strcpy(thisClientIP,"none1"); + lockStatus=0; + // getDynamicRange(); + + /* both these functions setROI and allocateRAM should go into the control server part. */ + if(myDetectorType!=JUNGFRAU){ + int retvalsize,ret; + setROI(-1,NULL,&retvalsize,&ret); + allocateRAM(); + } + + 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; + 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; + } + } + } + /*} 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; + 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); + + /* 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=-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; +/* case DETECTOR_FIRMWARE_SVN_VERSION: + retval=getFirmwareSVNVersion(); + 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 (ind2500) + val=-1; + printf("%d mV is ",val); + if (val>0) + val=val/2500*4095; + printf("%d DACu\n", val); + } else if (val>4095) + val=-1; + + + retval=setDac(ind,val); + } else { + switch (ind) { + case 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;; + break; + + case HV_NEW: + retval=initHighVoltageByModule(val,imod); + break; + + case V_POWER_A: + case V_POWER_B: + case V_POWER_C: + case V_POWER_D: + case V_POWER_IO: + case V_POWER_CHIP: + if (mV) { + retval=setPower(ind,val); + } else + printf("********power %d should be set in mV instead od DACu", ind); + break; + + + default: + printf("**********No dac with index %d\n",ind); + ret=FAIL; + } + + } + } + } + if(ret==OK){ + if (ind=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>=N_CHIP) + ret=FAIL; + if (myChan.chan>=N_CHAN) + 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>=N_CHIP) + 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(N_DAC*sizeof(int)); + int *myChip=NULL; + int *myChan=NULL; + int *myAdc=NULL; + + /*not required for jungfrau. so save memory*/ + if(myDetectorType != JUNGFRAU){ + myChip=malloc(N_CHIP*sizeof(int)); + myChan=malloc(N_CHIP*N_CHAN*sizeof(int)); + myAdc=malloc(N_ADC*sizeof(int)); + } + + + if (myDac) + myModule.dacs=myDac; + else { + sprintf(mess,"could not allocate dacs\n"); + ret=FAIL; + } + + + myModule.adcs=NULL; + myModule.chipregs=NULL; + myModule.chanregs=NULL; + /*not required for jungfrau. so save memory*/ + if(myDetectorType != JUNGFRAU){ + 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=N_DAC; + myModule.nchip=N_CHIP; + myModule.nchan=N_CHAN*N_CHIP; + myModule.nadc=N_ADC; + + + + 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-1) { + dataret=FAIL; + sprintf(mess,"no data and run stopped: %d frames left\n",(int)(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",(int)(getFrames())); +#endif + sendDataOnly(file_des,&dataret,sizeof(dataret)); + sendDataOnly(file_des,mess,sizeof(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) { + //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: + sprintf(mess,"can't set timer for moench\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"); + } 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",(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 { + /* 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 i; + int ret=OK; + int nroi=-1; + int n=0; + int retvalsize=0; + ROI arg[MAX_ROIS]; + ROI* retval=0; + strcpy(mess,"Could not set/get roi\n"); + // u_int32_t disable_reg=0; + + n = receiveDataOnly(file_des,&nroi,sizeof(nroi)); + if (n < 0) { + sprintf(mess,"Error reading from socket\n"); + ret=FAIL; + } + + if(myDetectorType == JUNGFRAU){ + ret = FAIL; + strcpy(mess,"Not applicable/implemented for this detector\n"); + printf("Error:Set ROI-%s",mess); + } + + else{ + + if(nroi>=0){ + n = receiveDataOnly(file_des,arg,nroi*sizeof(ROI)); + if (n != (nroi*sizeof(ROI))) { + sprintf(mess,"Received wrong number of bytes for ROI\n"); + ret=FAIL; + } + + printf("Setting ROI to:"); + for( i=0;i=0) { + ret=FAIL; + sprintf(mess,"Detector locked by %s\n",lastClientIP); + } else { + switch (arg) { + case CLOCK_DIVIDER: + retval=setClockDivider(val,0); + break; + +/* case PHASE_SHIFT: */ +/* retval=phaseStep(val,0); */ +/* break; */ + + case OVERSAMPLING: + retval=setOversampling(val); + break; + + case ADC_CLOCK: + retval=setClockDivider(val,1); + break; + +/* case ADC_PHASE: */ +/* retval=phaseStep(val,1); */ +/* break; */ + + + case ADC_PIPELINE: + retval=adcPipeline(val); + break; + + + + default: + ret=FAIL; + sprintf(mess,"Unknown speed parameter %d",arg); + } + } + } + + + } + + + switch (arg) { + case CLOCK_DIVIDER: + retval=getClockDivider(0); + break; + + case PHASE_SHIFT: + retval=getPhase(); + // retval=phaseStep(-1); + //ret=FAIL; + //sprintf(mess,"Cannot read phase",arg); + break; + + case OVERSAMPLING: + retval=setOversampling(-1); + break; + + case ADC_CLOCK: + retval=getClockDivider(1); + break; + + case ADC_PHASE: + retval=getPhase(); + break; + + + case ADC_PIPELINE: + retval=adcPipeline(-1); + 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 moench\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 moench\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[N_CHAN*N_CHIP]; + + 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[N_CHAN*N_CHIP]; + + 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=OK; + int n=0; + strcpy(mess,"Could not start receiver\n"); + + /* execute action if the arguments correctly arrived*/ +#ifdef MCB_FUNCS + if (lockStatus==1 && differentClients==1){//necessary??? + sprintf(mess,"Detector locked by %s\n", lastClientIP); + ret=FAIL; + } + else + ret = startReceiver(1); + +#endif + + + if(ret==OK && differentClients){ + printf("Force update\n"); + ret=FORCE_UPDATE; + } + + /* send answer */ + n = sendDataOnly(file_des,&ret,sizeof(ret)); + if(ret==FAIL) + n = sendDataOnly(file_des,mess,sizeof(mess)); + /*return ok/fail*/ + return ret; +} + + + + + + +int stop_receiver(int file_des) { + int ret=OK; + int n=0; + + strcpy(mess,"Could not stop receiver\n"); + + /* execute action if the arguments correctly arrived*/ +#ifdef MCB_FUNCS + if (lockStatus==1 && differentClients==1){//necessary??? + sprintf(mess,"Detector locked by %s\n", lastClientIP); + ret=FAIL; + } + else + ret=startReceiver(0); + +#endif + + + if(ret==OK && differentClients){ + printf("Force update\n"); + ret=FORCE_UPDATE; + } + + /* send answer */ + n = sendDataOnly(file_des,&ret,sizeof(ret)); + if(ret==FAIL) + 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; + +} diff --git a/slsDetectorSoftware/jctbDetectorServer/server_funcs.h b/slsDetectorSoftware/jctbDetectorServer/server_funcs.h new file mode 100755 index 000000000..2d674a1d0 --- /dev/null +++ b/slsDetectorSoftware/jctbDetectorServer/server_funcs.h @@ -0,0 +1,98 @@ +#ifndef SERVER_FUNCS_H +#define SERVER_FUNCS_H + + +#include "sls_detector_defs.h" + + +#include +/* +#include +#include +#include +*/ +#include "communication_funcs.h" + + + + +#define GOODBYE -200 + +int sockfd; + +int function_table(); + +int decode_function(int); +int init_detector(int,int); + +int M_nofunc(int); +int exit_server(int); + + + + +// General purpose functions +int get_detector_type(int); +int set_number_of_modules(int); +int get_max_number_of_modules(int); + + +int exec_command(int); +int set_external_signal_flag(int); +int set_external_communication_mode(int); +int get_id(int); +int digital_test(int); +int write_register(int); +int read_register(int); +int set_dac(int); +int get_adc(int); +int set_channel(int); +int set_chip(int); +int set_module(int); +int get_channel(int); +int get_chip(int); +int get_module(int); + +int get_threshold_energy(int); +int set_threshold_energy(int); +int set_settings(int); +int start_acquisition(int); +int stop_acquisition(int); +int start_readout(int); +int get_run_status(int); +int read_frame(int); +int read_all(int); +int start_and_read_all(int); +int set_timer(int); +int get_time_left(int); +int set_dynamic_range(int); +int set_roi(int); +int get_roi(int); +int set_speed(int); +int set_readout_flags(int); +int execute_trimming(int); +int lock_server(int); +int set_port(int); +int get_last_client_ip(int); +int set_master(int); +int set_synchronization(int); + +int update_client(int); +int send_update(int); +int configure_mac(int); + +int load_image(int); +int read_counter_block(int); +int reset_counter_block(int); + +int start_receiver(int); +int stop_receiver(int); + + +int calibrate_pedestal(int); + +int set_roi(int); +int set_ctb_pattern(int); + +int write_adc_register(int);; +#endif diff --git a/slsDetectorSoftware/jctbDetectorServer/sharedmemory.c b/slsDetectorSoftware/jctbDetectorServer/sharedmemory.c new file mode 100755 index 000000000..4504cfe05 --- /dev/null +++ b/slsDetectorSoftware/jctbDetectorServer/sharedmemory.c @@ -0,0 +1,39 @@ +#include "sharedmemory.h" + +struct statusdata *stdata; + +int inism(int clsv) { + +static int scansmid; + + if (clsv==SMSV) { + if ( (scansmid=shmget(SMKEY,1024,IPC_CREAT | 0666 ))==-1 ) { + return -1; + } + if ( (stdata=shmat(scansmid,NULL,0))==(void*)-1) { + return -2; + } + } + + if (clsv==SMCL) { + if ( (scansmid=shmget(SMKEY,0,0) )==-1 ) { + return -3; + } + if ( (stdata=shmat(scansmid,NULL,0))==(void*)-1) { + return -4; + } + } + return 1; +} + +void write_status_sm(char *status) { + strcpy(stdata->status,status); +} + +void write_stop_sm(int v) { + stdata->stop=v; +} + +void write_runnumber_sm(int v) { + stdata->runnumber=v; +} diff --git a/slsDetectorSoftware/jctbDetectorServer/sharedmemory.h b/slsDetectorSoftware/jctbDetectorServer/sharedmemory.h new file mode 100755 index 000000000..bdbddf719 --- /dev/null +++ b/slsDetectorSoftware/jctbDetectorServer/sharedmemory.h @@ -0,0 +1,48 @@ +#ifndef SM +#define SM + +#include "sls_detector_defs.h" + +#include +#include +#include +#include +#include +#include +#include +//#include +#include +#include +#include +#include +#include +#include + + +#include + +#include +#include + +/* key for shared memory */ +#define SMKEY 10001 + +#define SMSV 1 +#define SMCL 2 + + +struct statusdata { + int runnumber; + int stop; + char status[20]; +} ; + + +/* for shared memory */ + +int inism(int clsv); +void write_status_sm(char *status); +void write_stop_sm(int v); +void write_runnumber_sm(int v); + +#endif diff --git a/slsDetectorSoftware/jctbDetectorServer/sls_detector_defs.h b/slsDetectorSoftware/jctbDetectorServer/sls_detector_defs.h new file mode 120000 index 000000000..c5062e03f --- /dev/null +++ b/slsDetectorSoftware/jctbDetectorServer/sls_detector_defs.h @@ -0,0 +1 @@ +../commonFiles/sls_detector_defs.h \ No newline at end of file diff --git a/slsDetectorSoftware/jctbDetectorServer/sls_detector_funcs.h b/slsDetectorSoftware/jctbDetectorServer/sls_detector_funcs.h new file mode 120000 index 000000000..844b67129 --- /dev/null +++ b/slsDetectorSoftware/jctbDetectorServer/sls_detector_funcs.h @@ -0,0 +1 @@ +../commonFiles/sls_detector_funcs.h \ No newline at end of file diff --git a/slsDetectorSoftware/jctbDetectorServer/sls_receiver_defs.h b/slsDetectorSoftware/jctbDetectorServer/sls_receiver_defs.h new file mode 120000 index 000000000..1de31caf5 --- /dev/null +++ b/slsDetectorSoftware/jctbDetectorServer/sls_receiver_defs.h @@ -0,0 +1 @@ +../../slsReceiverSoftware/include/sls_receiver_defs.h \ No newline at end of file diff --git a/slsDetectorSoftware/jctbDetectorServer/sls_receiver_funcs.h b/slsDetectorSoftware/jctbDetectorServer/sls_receiver_funcs.h new file mode 120000 index 000000000..c2ea4ded9 --- /dev/null +++ b/slsDetectorSoftware/jctbDetectorServer/sls_receiver_funcs.h @@ -0,0 +1 @@ +../../slsReceiverSoftware/include/sls_receiver_funcs.h \ No newline at end of file diff --git a/slsDetectorSoftware/jctbDetectorServer/stop_server.c b/slsDetectorSoftware/jctbDetectorServer/stop_server.c new file mode 100755 index 000000000..e3c8ff7e1 --- /dev/null +++ b/slsDetectorSoftware/jctbDetectorServer/stop_server.c @@ -0,0 +1,46 @@ +/* A simple server in the internet domain using TCP + The port number is passed as an argument */ + + +#include "sls_detector_defs.h" + + +#include "communication_funcs.h" +#include "firmware_funcs.h" + + +int sockfd; + +int main(int argc, char *argv[]) +{ + int portno; + int retval=0; + + portno = DEFAULT_PORTNO; + + + bindSocket(portno); + if (getServerError()) + return -1; + + + + /* waits for connection */ + while(retval!=GOODBYE) { +#ifdef VERBOSE + printf("\n"); +#endif +#ifdef VERY_VERBOSE + printf("Stop server: waiting for client call\n"); +#endif + acceptConnection(); + retval=stopStateMachine(); + closeConnection(); + } + + exitServer(); + printf("Goodbye!\n"); + + return 0; +} +