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

Merge branch 'master' of gitorious.psi.ch:sls_det_software/sls_detector_software

Browse Source
This commit is contained in:
Dhanya Maliakal 2015-03-31 14:59:49 +02:00
commit b4f995084c
9 changed files with 362 additions and 219 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
slsDetectorSoftware/commonFiles/sls_detector_defs.h
View File

@ -341,7 +341,8 @@ enum dacIndex {
E_Vcp, /**< eiger */ E_Vcp, /**< eiger */
E_Vcn, /**< eiger */ E_Vcn, /**< eiger */
E_Vis, /**< eiger */ E_Vis, /**< eiger */
IO_DELAY /**< eiger io delay */ IO_DELAY, /**< eiger io delay */
ADC_VPP /**< adc vpp for jctb */
}; };
/** /**

2
slsDetectorSoftware/jungfrauDetectorServer/Makefile
View File

@ -6,7 +6,7 @@
CROSS = bfin-uclinux- CROSS = bfin-uclinux-
CC = $(CROSS)gcc CC = $(CROSS)gcc
CFLAGS += -Wall -DMOENCHD -DMCB_FUNCS -DDACS_INT -DDEBUG #-DVERBOSE #-DVERYVERBOSE #-DVIRTUAL #-DDACS_INT_CSERVER CFLAGS += -Wall -DMOENCHD -DMCB_FUNCS -DDACS_INT -DDEBUG -DV1#-DVERBOSE #-DVERYVERBOSE #-DVIRTUAL #-DDACS_INT_CSERVER
PROGS= jungfrauDetectorServer PROGS= jungfrauDetectorServer

232
slsDetectorSoftware/jungfrauDetectorServer/firmware_funcs.c
View File

@ -1,7 +1,7 @@
//#define TESTADC //#define TESTADC
#define TESTADC1 #define TESTADC1
//#define TIMEDBG
#include "server_defs.h" #include "server_defs.h"
#include "firmware_funcs.h" #include "firmware_funcs.h"
#include "mcb_funcs.h" #include "mcb_funcs.h"
@ -20,6 +20,10 @@
#include <sys/stat.h> #include <sys/stat.h>
#include <stdlib.h> #include <stdlib.h>
#include <sys/time.h>
struct timeval tss,tse,tsss; //for timing
//for memory mapping //for memory mapping
u_int64_t CSP0BASE; u_int64_t CSP0BASE;
@ -375,7 +379,7 @@ u_int32_t setPllReconfigReg(u_int32_t reg, u_int32_t val, int trig) {
printf("*********** pll busy: %08x\n",bus_r(STATUS_REG)&PLL_RECONFIG_BUSY); // printf("*********** pll busy: %08x\n",bus_r(STATUS_REG)&PLL_RECONFIG_BUSY);
bus_w(PLL_PARAM_REG,val); bus_w(PLL_PARAM_REG,val);
// printf("param: %x\n",val); // printf("param: %x\n",val);
@ -396,7 +400,7 @@ u_int32_t setPllReconfigReg(u_int32_t reg, u_int32_t val, int trig) {
// printf("wrote: %08x\n",vv); // printf("wrote: %08x\n",vv);
bus_w(PLL_CNTRL_REG,vv); bus_w(PLL_CNTRL_REG,vv);
usleep(10000); usleep(10000);
printf("+++++++++ pll busy: %08x\n",bus_r(STATUS_REG)&PLL_RECONFIG_BUSY); // printf("+++++++++ pll busy: %08x\n",bus_r(STATUS_REG)&PLL_RECONFIG_BUSY);
// bus_w(PLL_CNTRL_REG,(1<<PLL_CNTR_READ_BIT)|(reg<<PLL_CNTR_ADDR_OFF)); // bus_w(PLL_CNTRL_REG,(1<<PLL_CNTR_READ_BIT)|(reg<<PLL_CNTR_ADDR_OFF));
// usleep(1000); // usleep(1000);
@ -418,8 +422,8 @@ u_int32_t getPllReconfigReg(u_int32_t reg, int trig) {
u_int32_t val=reg<<PLL_CNTR_ADDR_OFF; u_int32_t val=reg<<PLL_CNTR_ADDR_OFF;
u_int32_t vv; u_int32_t vv;
printf("cntrlreg: %08x\n",PLL_CNTRL_REG); // printf("cntrlreg: %08x\n",PLL_CNTRL_REG);
printf("wrote: %08x\n",val); // printf("wrote: %08x\n",val);
bus_w(PLL_CNTRL_REG,val); bus_w(PLL_CNTRL_REG,val);
// printf("read: %08x\n",bus_r(PLL_CNTRL_REG)); // printf("read: %08x\n",bus_r(PLL_CNTRL_REG));
usleep(100); usleep(100);
@ -441,7 +445,7 @@ u_int32_t getPllReconfigReg(u_int32_t reg, int trig) {
usleep(100); usleep(100);
val=0; val=0;
printf("wrote: %08x\n",val); // printf("wrote: %08x\n",val);
bus_w(PLL_CNTRL_REG,val); bus_w(PLL_CNTRL_REG,val);
while(bus_r(STATUS_REG)&PLL_RECONFIG_BUSY) { while(bus_r(STATUS_REG)&PLL_RECONFIG_BUSY) {
@ -489,29 +493,61 @@ void configurePll(int i) {
val= (i<<18)| (odd<<17) | l | (h<<8); val= (i<<18)| (odd<<17) | l | (h<<8);
printf("Counter %d, val: %08x\n", i, val); setPllReconfigReg(PLL_C_COUNTER_REG, val,0); printf("Counter %d, val: %08x\n", i, val);
setPllReconfigReg(PLL_C_COUNTER_REG, val,0);
// usleep(20); // 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 { } else {
// if (mode==1) { // if (mode==1) {
// } else { // } else {
printf("phase in %d\n",clkPhase[0]); printf("phase in %d\n",clkPhase[1]);
if (clkPhase[0]>0) { if (clkPhase[1]>0) {
inv=0; inv=0;
phase=clkPhase[0]; phase=clkPhase[1];
} else { } else {
inv=1; inv=1;
phase=-1*clkPhase[0]; phase=-1*clkPhase[1];
} }
printf("phase out %d %08x\n",phase,phase); printf("phase out %d %08x\n",phase,phase);
val=phase | (inv<<16);;// | (inv<<21); 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 // 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
val=phase | (2<<16);// | (inv<<21);
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("**************** phase word %08x\n",val);
// printf("Phase, val: %08x\n", val);
setPllReconfigReg(PLL_PHASE_SHIFT_REG,val,0); //shifts counter 0
}
} }
printf("Start reconfig\n"); setPllReconfigReg(PLL_START_REG, 1,0); printf("Start reconfig\n"); setPllReconfigReg(PLL_START_REG, 1,0);
@ -521,14 +557,14 @@ void configurePll(int i) {
// printf("PLL mode\n"); setPllReconfigReg(PLL_MODE_REG,0,0); // printf("PLL mode\n"); setPllReconfigReg(PLL_MODE_REG,0,0);
usleep(10000); usleep(10000);
/* if (mode!=1) { */ if (i<2) {
/* printf("reset pll\n"); */ printf("reset pll\n");
/* bus_w(PLL_CNTRL_REG,((1<<PLL_CNTR_PLL_RESET_BIT))); //reset PLL */ bus_w(PLL_CNTRL_REG,((1<<PLL_CNTR_PLL_RESET_BIT))); //reset PLL
/* usleep(100); */ usleep(100);
/* bus_w(PLL_CNTRL_REG, 0); */ bus_w(PLL_CNTRL_REG, 0);
/* } */ }
} }
@ -578,45 +614,29 @@ u_int32_t setClockDivider(int d, int ic) {
} }
int phaseStep(int st, int ic){ int phaseStep(int st){
u_int32_t addr, val=( (1<<PLL_CNTR_UPDN_BIT)| (1<<PLL_CNTR_CNTSEL_OFF) | (1<< PLL_CNTR_PHASE_EN_BIT));
/* int ic=0 is run clk; ic=1 is adc clk */
/* if (st>0) */
/* ic=1; */
/* else { */
/* ic=0; */
/* st*=-1; */
/* } */
int i; int i;
if (st>65535 || st<-65535) if (st>65535 || st<-65535)
return -1; return clkPhase[0];
printf("phase %d\n", st);
clkPhase[1]=st-clkPhase[0];
printf("ic=%d; phase %d\n", ic, st);
if (ic==1)
clkPhase[0]=-st;
else if (ic==0)
clkPhase[0]=st;
/* printf("Changin phase %d\n",st); */
/* for (i=0; i<st; i++) { */
/* bus_w(PLL_CNTRL_REG,0); */
/* bus_w(PLL_CNTRL_REG,val); */
/* } */
/* sleep(1); */
// bus_w(PLL_CNTRL_REG,0);
configurePll(2); configurePll(2);
clkPhase[0]=st;
return clkPhase[0]; return clkPhase[0];
} }
int getPhase() {
return clkPhase[0];
};
u_int32_t getClockDivider(int ic) { u_int32_t getClockDivider(int ic) {
@ -1959,44 +1979,62 @@ u_int32_t fifo_full(void)
} }
u_int16_t* fifo_read_event() u_int16_t* fifo_read_event(int ns)
{ {
int i=0; int i=0;
u_int16_t *dum;
/* #ifdef TIMEDBG */
/* gettimeofday(&tse,NULL); */
/* #endif */
if (ns==0) {
volatile u_int32_t t = bus_r16(LOOK_AT_ME_REG); volatile u_int32_t t = bus_r16(LOOK_AT_ME_REG);
bus_w(DUMMY_REG,0); bus_w(DUMMY_REG,0);
while(t!=0xffffffff) { while(t!=0xffffffff) {
if (runBusy()==0) { if (runBusy()==0) {
t = bus_r(LOOK_AT_ME_REG); t = bus_r(LOOK_AT_ME_REG);
if (t!=0xffffffff) { if (t!=0xffffffff) {
printf("no frame found and acquisition finished - exiting\n"); printf("no frame found and acquisition finished - exiting\n");
printf("%08x %08x\n", runState(), bus_r(LOOK_AT_ME_REG)); printf("%08x %08x\n", runState(), bus_r(LOOK_AT_ME_REG));
return NULL; return NULL;
} else { } else {
// printf("status idle, look at me %x status %x\n", bus_r(LOOK_AT_ME_REG),runState()); // printf("status idle, look at me %x status %x\n", bus_r(LOOK_AT_ME_REG),runState());
break; break;
}
} }
} t = bus_r(LOOK_AT_ME_REG);
t = bus_r(LOOK_AT_ME_REG);
#ifdef VERBOSE #ifdef VERBOSE
printf("."); printf(".");
#endif #endif
} }
/* #ifdef TIMEDBG */
/* // tsss=tss; */
/* gettimeofday(&tss,NULL); */
/* printf("look for data = %ld usec\n", (tss.tv_usec) - (tse.tv_usec)); */
/* #endif */
}
// printf("%08x %08x\n", runState(), bus_r(LOOK_AT_ME_REG)); // printf("%08x %08x\n", runState(), bus_r(LOOK_AT_ME_REG));
/* dma_memcpy(now_ptr,values ,dataBytes); */ /* dma_memcpy(now_ptr,values ,dataBytes); */
/* #else */ /* #else */
bus_w16(DUMMY_REG,1<<8); // read strobe to all fifos
bus_w16(DUMMY_REG,0);
for (i=0; i<32; i++) { for (i=0; i<32; i++) {
dum=((u_int16_t*)(now_ptr))+i; bus_w16(DUMMY_REG,i);
bus_w(DUMMY_REG,i<<1); // dum=((u_int16_t*)(now_ptr))+i;
// usleep(10); // *dum=bus_r16(FIFO_DATA_REG);
bus_w(DUMMY_REG,(i<<1) | 1); //dum=;
// usleep(10); *(((u_int16_t*)(now_ptr))+i)=bus_r16(FIFO_DATA_REG);
bus_w(DUMMY_REG,i<<1);
/* usleep(10); */
*dum=bus_r16(FIFO_DATA_REG);
} }
/* #ifdef TIMEDBG */
/* gettimeofday(&tss,NULL); */
/* printf("read data loop = %ld usec\n",(tss.tv_usec) - (tse.tv_usec)); */
/* #endif */
#ifdef VERBOSE #ifdef VERBOSE
printf("*"); printf("*");
#endif #endif
@ -2007,23 +2045,31 @@ u_int16_t* fifo_read_event()
u_int16_t* fifo_read_frame() u_int16_t* fifo_read_frame()
{ {
u_int16_t *dum; #ifdef TIMEDBG
gettimeofday(&tsss,NULL);
#endif
// u_int16_t *dum;
int ns=0; int ns=0;
now_ptr=(char*)ram_values; now_ptr=(char*)ram_values;
while(ns<nSamples) { while(ns<nSamples && fifo_read_event(ns)) {
dum=fifo_read_event(); now_ptr+=dataBytes;
if (dum==NULL) break; ns++;
now_ptr+=dataBytes;
ns++;
} }
#ifdef TIMEDBG
// usleep(10);
gettimeofday(&tss,NULL);
printf("total read data loop = %ld usec\n",(tss.tv_usec) - (tsss.tv_usec));
#endif
// printf("%x %d\n",dum, ns); // printf("%x %d\n",dum, ns);
if (ns==0) return NULL; if (ns) return ram_values;
#ifdef VERBOSE #ifdef VERBOSE
printf("+\n"); printf("+\n");
#else #else
printf("+"); printf("+");
#endif #endif
return ram_values; return NULL;
} }
@ -2240,37 +2286,37 @@ int writeADC(int addr, int val) {
printf("***** ADC SPI WRITE TO REGISTER %04X value %04X\n",addr,val); printf("***** ADC SPI WRITE TO REGISTER %04X value %04X\n",addr,val);
// start point // start point
valw=0xff; valw=0xff;
bus_w(ADC_WRITE_REG,(valw)); bus_w16(ADC_WRITE_REG,(valw));
//chip sel bar down //chip sel bar down
valw=((0xffffffff&(~csmask))); valw=((0xffffffff&(~csmask)));
bus_w(ADC_WRITE_REG,valw); bus_w16(ADC_WRITE_REG,valw);
for (i=0;i<24;i++) { for (i=0;i<24;i++) {
//cldwn //cldwn
valw=valw&(~(0x1<<cdx)); valw=valw&(~(0x1<<cdx));
bus_w(ADC_WRITE_REG,valw); bus_w16(ADC_WRITE_REG,valw);
usleep(0); // usleep(0);
//write data (i) //write data (i)
valw=(valw&(~(0x1<<ddx)))+(((codata>>(23-i))&0x1)<<ddx); valw=(valw&(~(0x1<<ddx)))+(((codata>>(23-i))&0x1)<<ddx);
bus_w(ADC_WRITE_REG,valw); bus_w16(ADC_WRITE_REG,valw);
usleep(0); // usleep(0);
//clkup //clkup
valw=valw+(0x1<<cdx); valw=valw+(0x1<<cdx);
bus_w(ADC_WRITE_REG,valw); bus_w16(ADC_WRITE_REG,valw);
usleep(0); // usleep(0);
} }
// stop point =start point // stop point =start point
valw=valw&(~(0x1<<cdx)); valw=valw&(~(0x1<<cdx));
usleep(0); // usleep(0);
valw=0xff; valw=0xff;
bus_w(ADC_WRITE_REG,(valw)); bus_w16(ADC_WRITE_REG,(valw));
//usleep in between //usleep in between
usleep(50000); // usleep(50000);
return OK; return OK;
} }
@ -2759,7 +2805,7 @@ int calibratePedestal(int frames){
while(dataret==OK){ while(dataret==OK){
//got data //got data
if (fifo_read_event()) { if (fifo_read_event(0)) {
dataret=OK; dataret=OK;
//sendDataOnly(file_des,&dataret,sizeof(dataret)); //sendDataOnly(file_des,&dataret,sizeof(dataret));
//sendDataOnly(file_des,dataretval,dataBytes); //sendDataOnly(file_des,dataretval,dataBytes);
@ -3042,6 +3088,8 @@ void initDac(int dacnum) {
ddx=0; cdx=1; ddx=0; cdx=1;
csdx=dacnum/8+2; csdx=dacnum/8+2;
printf("data bit=%d, clkbit=%d, csbit=%d",ddx,cdx,csdx); printf("data bit=%d, clkbit=%d, csbit=%d",ddx,cdx,csdx);
codata=((((0x6)<<4)+((0xf))<<16)+((0x0<<4)&0xfff0)); codata=((((0x6)<<4)+((0xf))<<16)+((0x0<<4)&0xfff0));

5
slsDetectorSoftware/jungfrauDetectorServer/firmware_funcs.h
View File

@ -29,7 +29,8 @@ u_int32_t bus_w(u_int32_t offset, u_int32_t data);
u_int32_t bus_r(u_int32_t offset); u_int32_t bus_r(u_int32_t offset);
int setPhaseShiftOnce(); int setPhaseShiftOnce();
int phaseStep(int st, int ic); int phaseStep(int st);
int getPhase();
int cleanFifo(); int cleanFifo();
int setDAQRegister(); int setDAQRegister();
@ -134,7 +135,7 @@ u_int32_t fifo_full(void);
u_int16_t* fifo_read_event(); u_int16_t* fifo_read_event(int ns);
u_int16_t* fifo_read_frame(); u_int16_t* fifo_read_frame();
u_int32_t* decode_data(int* datain); u_int32_t* decode_data(int* datain);
//u_int32_t move_data(u_int64_t* datain, u_int64_t* dataout); //u_int32_t move_data(u_int64_t* datain, u_int64_t* dataout);

6
slsDetectorSoftware/jungfrauDetectorServer/mcb_funcs.c
View File

@ -1985,7 +1985,7 @@ int testExtPulse(int imod) {
//startStateMachine(); //startStateMachine();
startReadOut(); startReadOut();
usleep(100); usleep(100);
val1=(int*)(decode_data((int*)(fifo_read_event()))); val1=(int*)(decode_data((int*)(fifo_read_event(0))));
// val1=fifo_read_event(); // val1=fifo_read_event();
//imod=0; //imod=0;
//for (imod=0; imod<nModX; imod++) { //for (imod=0; imod<nModX; imod++) {
@ -2054,7 +2054,7 @@ int testExtPulseMux(int imod, int ow) {
startReadOut(); startReadOut();
usleep(100); usleep(100);
v1=(int*)(fifo_read_event()); v1=(int*)(fifo_read_event(0));
if (v1) if (v1)
values=(int*)(decode_data(v1)); values=(int*)(decode_data(v1));
else { else {
@ -2129,7 +2129,7 @@ int testDataInOutMux(int imod, int ow, int num) {
printf("mux %d\n",ow); printf("mux %d\n",ow);
startReadOut(); startReadOut();
usleep(100); usleep(100);
v1=(int*)(fifo_read_event()); v1=(int*)(fifo_read_event(0));
if (v1) if (v1)
values=(int*)(decode_data(v1)); values=(int*)(decode_data(v1));
else { else {

75
slsDetectorSoftware/jungfrauDetectorServer/server_funcs.c
View File

@ -54,6 +54,8 @@ int digitalTestBit = 0;
extern int withGotthard; extern int withGotthard;
int adcvpp=0x4;
int init_detector(int b, int checkType) { int init_detector(int b, int checkType) {
int i; int i;
@ -995,22 +997,36 @@ int set_dac(int file_des) {
sprintf(mess,"Detector locked by %s\n",lastClientIP); sprintf(mess,"Detector locked by %s\n",lastClientIP);
} else{ } else{
if (mV) { if (ind<16) {
if (val>2500)
val=-1; if (mV) {
if (val>2500)
val=-1;
printf("%d mV is ",val); printf("%d mV is ",val);
if (val>0) if (val>0)
val=16535*val/2500; val=4095*val/2500;
printf("%d DACu\n", val); printf("%d DACu\n", val);
} else if (val>16535) } else if (val>4095)
val=-1; val=-1;
retval=setDac(ind,val); retval=setDac(ind,val);
/* if(idac==HIGH_VOLTAGE) */ /* if(idac==HIGH_VOLTAGE) */
/* retval=initHighVoltageByModule(val,imod); */ /* retval=initHighVoltageByModule(val,imod); */
/* else */ /* else */
/* retval=initDACbyIndexDACU(idac,val,imod); */ /* retval=initDACbyIndexDACU(idac,val,imod); */
}
else if (ind==ADC_VPP) {
printf("Setting ADC VPP to %d\n",val);
if (val>4 || val<0)
printf("Cannot set ADC VPP to %d\n",val);
else {
writeADC(0x18,val);
adcvpp=val;
}
retval=adcvpp;;
}
} }
} }
if(ret==OK){ if(ret==OK){
@ -1024,8 +1040,8 @@ int set_dac(int file_des) {
/* ret=OK; */ /* ret=OK; */
/* }//since v r saving only msb */ /* }//since v r saving only msb */
/* else if ((retval-val)<=3 || val==-1) */ /* else if ((retval-val)<=3 || val==-1) */
/* ret=OK; */ /* ret=OK; */
if (ind<16) {
if (mV) { if (mV) {
printf("%d DACu is ",retval); printf("%d DACu is ",retval);
@ -1039,7 +1055,7 @@ int set_dac(int file_des) {
#ifdef VERBOSE #ifdef VERBOSE
printf("DAC set to %d V\n", retval); printf("DAC set to %d V\n", retval);
#endif #endif
}
if(ret==FAIL) if(ret==FAIL)
printf("Setting dac %d of module %d: wrote %d but read %d\n", ind, imod, val, retval); printf("Setting dac %d of module %d: wrote %d but read %d\n", ind, imod, val, retval);
else{ else{
@ -2361,7 +2377,17 @@ int set_speed(int file_des) {
if (ret==OK) { if (ret==OK) {
if (arg==PHASE_SHIFT || arg==ADC_PHASE) {
retval=phaseStep(val);
} else {
if (val!=-1) { if (val!=-1) {
if (differentClients==1 && lockStatus==1 && val>=0) { if (differentClients==1 && lockStatus==1 && val>=0) {
ret=FAIL; ret=FAIL;
sprintf(mess,"Detector locked by %s\n",lastClientIP); sprintf(mess,"Detector locked by %s\n",lastClientIP);
@ -2371,9 +2397,9 @@ int set_speed(int file_des) {
retval=setClockDivider(val,0); retval=setClockDivider(val,0);
break; break;
case PHASE_SHIFT: /* case PHASE_SHIFT: */
retval=phaseStep(val,0); /* retval=phaseStep(val,0); */
break; /* break; */
case OVERSAMPLING: case OVERSAMPLING:
retval=setOversampling(val); retval=setOversampling(val);
@ -2383,9 +2409,9 @@ int set_speed(int file_des) {
retval=setClockDivider(val,1); retval=setClockDivider(val,1);
break; break;
case ADC_PHASE: /* case ADC_PHASE: */
retval=phaseStep(val,1); /* retval=phaseStep(val,1); */
break; /* break; */
case ADC_PIPELINE: case ADC_PIPELINE:
@ -2402,16 +2428,19 @@ int set_speed(int file_des) {
} }
}
switch (arg) { switch (arg) {
case CLOCK_DIVIDER: case CLOCK_DIVIDER:
retval=getClockDivider(0); retval=getClockDivider(0);
break; break;
case PHASE_SHIFT: case PHASE_SHIFT:
retval=getPhase();
// retval=phaseStep(-1); // retval=phaseStep(-1);
//ret=FAIL; //ret=FAIL;
//sprintf(mess,"Cannot read phase",arg); //sprintf(mess,"Cannot read phase",arg);
retval=-1;
break; break;
case OVERSAMPLING: case OVERSAMPLING:
@ -2423,7 +2452,7 @@ int set_speed(int file_des) {
break; break;
case ADC_PHASE: case ADC_PHASE:
retval=-1; retval=getPhase();
break; break;

10
slsDetectorSoftware/jungfrauDetectorServer/trimming_funcs.c
View File

@ -236,7 +236,7 @@ int choose_vthresh_and_vtrim(int countlim, int nsigma, int im) {
while (runBusy()) { while (runBusy()) {
} }
usleep(500); usleep(500);
fifodata=fifo_read_event(); fifodata=fifo_read_event(0);
scan=decode_data(fifodata); scan=decode_data(fifodata);
for (imod=modmi; imod<modma; imod++) { for (imod=modmi; imod<modma; imod++) {
for (ichan=0; ichan<nChans*nChips; ichan++){ for (ichan=0; ichan<nChans*nChips; ichan++){
@ -377,7 +377,7 @@ int trim_with_level(int countlim, int im) {
} }
usleep(500); usleep(500);
fifodata=fifo_read_event(); fifodata=fifo_read_event(0);
scan=decode_data(fifodata); scan=decode_data(fifodata);
for (imod=modmi; imod<modma; imod++) { for (imod=modmi; imod<modma; imod++) {
for (ichan=0; ichan<nChans*nChips; ichan++) { for (ichan=0; ichan<nChans*nChips; ichan++) {
@ -515,7 +515,7 @@ int choose_vthresh() {
} }
usleep(500); usleep(500);
fifodata=fifo_read_event(); fifodata=fifo_read_event(0);
scan=decode_data(fifodata); scan=decode_data(fifodata);
// //
scan1=decode_data(fifodata); scan1=decode_data(fifodata);
@ -553,7 +553,7 @@ int choose_vthresh() {
} }
usleep(500); usleep(500);
fifodata=fifo_read_event(); fifodata=fifo_read_event(0);
scan=decode_data(fifodata); scan=decode_data(fifodata);
// //
scan1=decode_data(fifodata); scan1=decode_data(fifodata);
@ -680,7 +680,7 @@ int trim_with_median(int stop, int im) {
while (runBusy()) { while (runBusy()) {
} }
usleep(500); usleep(500);
fifodata=fifo_read_event(); fifodata=fifo_read_event(0);
scan=decode_data(fifodata); scan=decode_data(fifodata);
scan1=decode_data(fifodata); scan1=decode_data(fifodata);

68
slsDetectorSoftware/slsDetector/slsDetectorCommand.cpp
View File

@ -699,6 +699,12 @@ slsDetectorCommand::slsDetectorCommand(slsDetectorUtils *det) {
i++; i++;
descrToFuncMap[i].m_pFuncName="adcvpp"; //
descrToFuncMap[i].m_pFuncPtr=&slsDetectorCommand::cmdDAC;
i++;
/* r/w timers */ /* r/w timers */
descrToFuncMap[i].m_pFuncName="temp_adc"; // descrToFuncMap[i].m_pFuncName="temp_adc"; //
@ -898,6 +904,14 @@ slsDetectorCommand::slsDetectorCommand(slsDetectorUtils *det) {
/* pattern generator */ /* pattern generator */
descrToFuncMap[i].m_pFuncName="adcinvert"; //
descrToFuncMap[i].m_pFuncPtr=&slsDetectorCommand::cmdPattern;
i++;
descrToFuncMap[i].m_pFuncName="adcdisable"; //
descrToFuncMap[i].m_pFuncPtr=&slsDetectorCommand::cmdPattern;
i++;
descrToFuncMap[i].m_pFuncName="pattern"; // descrToFuncMap[i].m_pFuncName="pattern"; //
descrToFuncMap[i].m_pFuncPtr=&slsDetectorCommand::cmdPattern; descrToFuncMap[i].m_pFuncPtr=&slsDetectorCommand::cmdPattern;
i++; i++;
@ -3383,6 +3397,8 @@ string slsDetectorCommand::cmdDAC(int narg, char *args[], int action) {
printf("chiptestboard!\n"); printf("chiptestboard!\n");
dac=(dacIndex)idac; dac=(dacIndex)idac;
} }
else if (cmd=="adcvpp")
dac=ADC_VPP;
else if (cmd=="vthreshold") else if (cmd=="vthreshold")
dac=THRESHOLD; dac=THRESHOLD;
else if (cmd=="vcalibration") else if (cmd=="vcalibration")
@ -3942,15 +3958,17 @@ string slsDetectorCommand::cmdSpeed(int narg, char *args[], int action) {
index=TOT_CLOCK_DIVIDER; index=TOT_CLOCK_DIVIDER;
else if (cmd=="totdutycycle") else if (cmd=="totdutycycle")
index=TOT_DUTY_CYCLE; index=TOT_DUTY_CYCLE;
else if (cmd=="phasestep") else if (cmd=="phasestep") {
index=PHASE_SHIFT; index=PHASE_SHIFT;
else if (cmd=="oversampling") t=100000;
} else if (cmd=="oversampling")
index=OVERSAMPLING; index=OVERSAMPLING;
else if (cmd=="adcclk") else if (cmd=="adcclk")
index=ADC_CLOCK; index=ADC_CLOCK;
else if (cmd=="adcphase") else if (cmd=="adcphase") {
index=ADC_PHASE; index=ADC_PHASE;
else if (cmd=="adcpipeline") t=100000;
} else if (cmd=="adcpipeline")
index=ADC_PIPELINE; index=ADC_PIPELINE;
else else
return string("could not decode speed variable ")+cmd; return string("could not decode speed variable ")+cmd;
@ -3961,6 +3979,7 @@ string slsDetectorCommand::cmdSpeed(int narg, char *args[], int action) {
; ;
else else
return string("cannot scan speed value ")+string(args[1]); return string("cannot scan speed value ")+string(args[1]);
} }
myDet->setOnline(ONLINE_FLAG); myDet->setOnline(ONLINE_FLAG);
@ -4335,6 +4354,9 @@ string slsDetectorCommand::helpPattern(int narg, char *args[], int action) {
os << "patwaittime0 nclk \t sets wait 0 waiting time in clock number " << std::endl; os << "patwaittime0 nclk \t sets wait 0 waiting time in clock number " << std::endl;
os << "patwaittime1 nclk \t sets wait 1 waiting time in clock number " << std::endl; os << "patwaittime1 nclk \t sets wait 1 waiting time in clock number " << std::endl;
os << "patwaittime2 nclk \t sets wait 2 waiting time in clock number " << std::endl; os << "patwaittime2 nclk \t sets wait 2 waiting time in clock number " << std::endl;
os << "adcinvert mask\t sets the adcinversion mask (hex)" << std::endl;
os << "adcdisable mask\t sets the adcdisable mask (hex)" << std::endl;
} }
if (action==GET_ACTION || action==HELP_ACTION){ if (action==GET_ACTION || action==HELP_ACTION){
os << "pattern \t cannot get" << std::endl; os << "pattern \t cannot get" << std::endl;
@ -4354,6 +4376,9 @@ string slsDetectorCommand::helpPattern(int narg, char *args[], int action) {
os << "patwaittime0 \t returns the wait 0 waiting time in clock number " << std::endl; os << "patwaittime0 \t returns the wait 0 waiting time in clock number " << std::endl;
os << "patwaittime1 \t returns the wait 1 waiting time in clock number " << std::endl; os << "patwaittime1 \t returns the wait 1 waiting time in clock number " << std::endl;
os << "patwaittime2 \t returns the wait 2 waiting time in clock number " << std::endl; os << "patwaittime2 \t returns the wait 2 waiting time in clock number " << std::endl;
os << "adcinvert \t returns the adcinversion mask " << std::endl;
os << "adcdisable \t returns the adcdisable mask " << std::endl;
} }
return os.str(); return os.str();
@ -4757,7 +4782,42 @@ string slsDetectorCommand::cmdPattern(int narg, char *args[], int action) {
os << myDet->setCTBPatWaitTime(2,-1); os << myDet->setCTBPatWaitTime(2,-1);
} else if (cmd=="adcinvert") {
if (action==PUT_ACTION) {
if (sscanf(args[1],"%x",&addr))
;
else
return string("Could not scan adcinvert reg ")+string(args[1]);
myDet->writeRegister(67,addr);
}
os << hex << myDet->readRegister(67) << dec;
} else if (cmd=="adcdisable") {
if (action==PUT_ACTION) {
if (sscanf(args[1],"%x",&addr))
;
else
return string("Could not scan adcdisable reg ")+string(args[1]);
myDet->writeRegister(94,addr);
}
os << hex << myDet->readRegister(94) << dec;
} }
else return helpPattern(narg, args, action); else return helpPattern(narg, args, action);

180
slsDetectorSoftware/slsDetector/slsDetectorUtils.cpp
View File

@ -786,118 +786,122 @@ int slsDetectorUtils::dumpDetectorSetup(string const fname, int level){
slsDetectorCommand *cmd; slsDetectorCommand *cmd;
string names[100]; string names[100];
int nvar=0; int nvar=0;
int nvar1=0;
names[nvar++]="fname";
names[nvar++]="index";
names[nvar++]="dr";
names[nvar++]="settings";
names[nvar++]="exptime";
names[nvar++]="period";
names[nvar++]="frames";
names[nvar++]="cycles";
names[nvar++]="measurements";
names[nvar++]="timing";
switch (getDetectorsType()) { switch (getDetectorsType()) {
case EIGER: case EIGER:
names[nvar++]="fname"; names[nvar++]="flags";
names[nvar++]="index";
names[nvar++]="flags";
names[nvar++]="dr";
names[nvar++]="settings";
names[nvar++]="threshold"; names[nvar++]="threshold";
names[nvar++]="exptime";
names[nvar++]="period";
names[nvar++]="frames";
names[nvar++]="cycles";
names[nvar++]="timing";
names[nvar++]="fineoff";
names[nvar++]="startscript";
names[nvar++]="startscriptpar";
names[nvar++]="stopscript";
names[nvar++]="stopscriptpar";
names[nvar++]="scriptbefore";
names[nvar++]="scriptbeforepar";
names[nvar++]="scriptafter";
names[nvar++]="scriptafterpar";
names[nvar++]="scan0script";
names[nvar++]="scan0par";
names[nvar++]="scan0prec";
names[nvar++]="scan0steps";
names[nvar++]="scan1script";
names[nvar++]="scan1par";
names[nvar++]="scan1prec";
names[nvar++]="scan1steps";
names[nvar++]="ratecorr"; names[nvar++]="ratecorr";
names[nvar++]="flatfield";
names[nvar++]="badchannels";
break; break;
case GOTTHARD: case GOTTHARD:
names[nvar++]="fname"; names[nvar++]="flags";
names[nvar++]="index";
names[nvar++]="flags";
names[nvar++]="dr";
names[nvar++]="settings";
names[nvar++]="exptime";
names[nvar++]="period";
names[nvar++]="delay"; names[nvar++]="delay";
names[nvar++]="gates"; names[nvar++]="gates";
names[nvar++]="frames";
names[nvar++]="cycles";
names[nvar++]="timing";
names[nvar++]="fineoff";
names[nvar++]="startscript";
names[nvar++]="startscriptpar";
names[nvar++]="stopscript";
names[nvar++]="stopscriptpar";
names[nvar++]="scriptbefore";
names[nvar++]="scriptbeforepar";
names[nvar++]="scriptafter";
names[nvar++]="scriptafterpar";
names[nvar++]="scan0script";
names[nvar++]="scan0par";
names[nvar++]="scan0prec";
names[nvar++]="scan0steps";
names[nvar++]="scan1script";
names[nvar++]="scan1par";
names[nvar++]="scan1prec";
names[nvar++]="scan1steps";
names[nvar++]="ratecorr"; names[nvar++]="ratecorr";
names[nvar++]="flatfield";
names[nvar++]="badchannels";
break; break;
case MYTHEN: case MYTHEN:
names[nvar++]="fname"; names[nvar++]="flags";
names[nvar++]="index";
names[nvar++]="flags";
names[nvar++]="dr";
names[nvar++]="settings";
names[nvar++]="threshold"; names[nvar++]="threshold";
names[nvar++]="exptime";
names[nvar++]="period";
names[nvar++]="delay"; names[nvar++]="delay";
names[nvar++]="gates"; names[nvar++]="gates";
names[nvar++]="frames";
names[nvar++]="cycles";
names[nvar++]="probes"; names[nvar++]="probes";
names[nvar++]="timing";
names[nvar++]="fineoff"; names[nvar++]="fineoff";
names[nvar++]="startscript";
names[nvar++]="startscriptpar";
names[nvar++]="stopscript";
names[nvar++]="stopscriptpar";
names[nvar++]="scriptbefore";
names[nvar++]="scriptbeforepar";
names[nvar++]="scriptafter";
names[nvar++]="scriptafterpar";
names[nvar++]="scan0script";
names[nvar++]="scan0par";
names[nvar++]="scan0prec";
names[nvar++]="scan0steps";
names[nvar++]="scan1script";
names[nvar++]="scan1par";
names[nvar++]="scan1prec";
names[nvar++]="scan1steps";
names[nvar++]="ratecorr"; names[nvar++]="ratecorr";
names[nvar++]="flatfield";
names[nvar++]="badchannels";
names[nvar++]="trimbits"; names[nvar++]="trimbits";
break; break;
case JUNGFRAUCTB:
names[nvar++]="dac:0";
names[nvar++]="dac:1";
names[nvar++]="dac:2";
names[nvar++]="dac:3";
names[nvar++]="dac:4";
names[nvar++]="dac:5";
names[nvar++]="dac:6";
names[nvar++]="dac:7";
names[nvar++]="dac:8";
names[nvar++]="dac:9";
names[nvar++]="dac:10";
names[nvar++]="dac:11";
names[nvar++]="dac:12";
names[nvar++]="dac:13";
names[nvar++]="dac:14";
names[nvar++]="dac:15";
names[nvar++]="adcvpp";
names[nvar++]="adcclk";
names[nvar++]="clkdivider";
names[nvar++]="adcphase";
names[nvar++]="adcpipeline";
names[nvar++]="adcinvert"; //
names[nvar++]="adcdisable";
names[nvar++]="patioctrl";
names[nvar++]="patclkctrl";
names[nvar++]="patlimits";
names[nvar++]="patloop0";
names[nvar++]="patnloop0";
names[nvar++]="patwait0";
names[nvar++]="patwaittime0";
names[nvar++]="patloop1";
names[nvar++]="patnloop1";
names[nvar++]="patwait1";
names[nvar++]="patwaittime1";
names[nvar++]="patloop2";
names[nvar++]="patnloop2";
names[nvar++]="patwait2";
names[nvar++]="patwaittime2";
} }
names[nvar++]="startscript";
names[nvar++]="startscriptpar";
names[nvar++]="stopscript";
names[nvar++]="stopscriptpar";
names[nvar++]="scriptbefore";
names[nvar++]="scriptbeforepar";
names[nvar++]="scriptafter";
names[nvar++]="scriptafterpar";
names[nvar++]="scan0script";
names[nvar++]="scan0par";
names[nvar++]="scan0prec";
names[nvar++]="scan0steps";
names[nvar++]="scan1script";
names[nvar++]="scan1par";
names[nvar++]="scan1prec";
names[nvar++]="scan1steps";
switch (getDetectorsType()) {
case EIGER:
case MYTHEN:
case GOTTHARD:
names[nvar++]="flatfield";
names[nvar++]="badchannels";
break;
}
switch (getDetectorsType()) {
case EIGER:
case MYTHEN:
names[nvar++]="trimbits";
break;
}
// char ext[100]; // char ext[100];
@ -907,8 +911,8 @@ int slsDetectorUtils::dumpDetectorSetup(string const fname, int level){
ofstream outfile; ofstream outfile;
char *args[2]; char *args[4];
for (int ia=0; ia<2; ia++) { for (int ia=0; ia<4; ia++) {
args[ia]=new char[1000]; args[ia]=new char[1000];
} }