Subversion Repositories f9daq

Compare Revisions

Ignore whitespace Rev 232 → Rev 233

/cvi/RedPitaya/soccli/soccli.c
26,8 → 26,11
int initialized = 0;
#define MAX_THREADS 10
int nsamples=0;
int ithreshold;
float athreshold;
float timebins[0XFFFF];
 
FILE *foutput;
 
static CmtThreadPoolHandle poolHandle = 0;
int ctrl_c=0;
 
40,8 → 43,8
char filename[0xFF],rootcmd[0xFF];
int type=0;
int neve;
GetCtrlVal(panelHandle,PANEL_FILENAME,filename);
GetCtrlVal(panelHandle,PANEL_EXPORTNAME,filename);
GetCtrlVal(panelHandle,PANEL_FILETYPE,&type);
FILE *fp;
85,20 → 88,9
SetStdioPort (CVI_STDIO_WINDOW);
SetSleepPolicy(VAL_SLEEP_MORE);
CmtNewThreadPool (MAX_THREADS, &poolHandle);
H1D_Init(1, "ADC ch 1","Pulse height", 100, 0, 5000 );
H1D_SetTitleX(1,"ADC (a.u.)");
H1D_SetTitleY(1,"N");
H1D_Init(3, "TDC ch 1","TDC", 200, 0, 1000 );
H1D_SetTitleX(3,"TDC (a.u.)");
H1D_SetTitleY(3,"N");
H1D_Init(2, "ADC ch 2","Pulse height", 100, 0, 5000 );
H1D_SetTitleX(2,"ADC (a.u.)");
H1D_SetTitleY(2,"N");
H1D_Init(4, "TDC ch 2","TDC", 200, 0, 1000 );
H1D_SetTitleX(4,"TDC (a.u.)");
H1D_SetTitleY(4,"N");
//for (int i=0;i<1000;i++) H1D_Fill(1,i,i);
H1D_Draw(1,panelHandle,PANEL_ADC1,&adcplothandle[0]);
//H1D_Draw(1,panelHandle,PANEL_ADC1,&adcplothandle[0]);
printf("size of double = %d\n",sizeof(double));
DisplayPanel (panelHandle);
RunUserInterface ();
130,19 → 122,66
return(ret);
}
 
int histoinit() {
int nch;
float min,max;
GetCtrlVal(panelHandle,PANEL_NCH_1, &nch);
GetCtrlVal(panelHandle,PANEL_MINX_1, &min);
GetCtrlVal(panelHandle,PANEL_MAXX_1, &max);
 
H1D_Init(1, "ADC ch 1","Pulse height", nch, min, max );
H1D_SetTitleX(1,"ADC (a.u.)");
H1D_SetTitleY(1,"N");
 
int analyse(int neve, unsigned char *cdata) {
GetCtrlVal(panelHandle,PANEL_NCH_2, &nch);
GetCtrlVal(panelHandle,PANEL_MINX_2, &min);
GetCtrlVal(panelHandle,PANEL_MAXX_2, &max);
 
H1D_Init(2, "ADC ch 2","Pulse height", nch, min, max );
H1D_SetTitleX(2,"ADC (a.u.)");
H1D_SetTitleY(2,"N");
 
GetCtrlVal(panelHandle,PANEL_NCH_3, &nch);
GetCtrlVal(panelHandle,PANEL_MINX_3, &min);
GetCtrlVal(panelHandle,PANEL_MAXX_3, &max);
 
H1D_Init(3, "TDC ch 1","TDC", nch, min, max );
H1D_SetTitleX(3,"TDC (a.u.)");
H1D_SetTitleY(3,"N");
 
GetCtrlVal(panelHandle,PANEL_NCH_4, &nch);
GetCtrlVal(panelHandle,PANEL_MINX_4, &min);
GetCtrlVal(panelHandle,PANEL_MAXX_4, &max);
 
H1D_Init(4, "TDC ch 2","TDC", nch, min, max );
H1D_SetTitleX(4,"TDC (a.u.)");
H1D_SetTitleY(4,"N");
GetCtrlVal(panelHandle,PANEL_MINX_5, &min);
GetCtrlVal(panelHandle,PANEL_MAXX_5, &max);
SetAxisScalingMode (panelHandle, PANEL_GRAPH, VAL_LEFT_YAXIS, VAL_MANUAL, min, max);
int *data = (int *) cdata;
for (int i=0; i<neve; i++) {
return 0;
}
 
int analyse(int nb, unsigned char *cdata) {
int *ibuf = (int *)cdata;
float *fbuf = (float *)cdata;
int neve=0;
int *data = (ibuf+3);
int nr=0;
printf("Run HDR LEN=%d NEVE=%d dt=%f\n", ibuf[0],ibuf[1],fbuf[2]);
while (nr<nb) {
 
int recid = *data++;
int chmask = *data++;
nr +=8;
if (recid!=0x2) continue;
for (int id=0;id<2;id++){
if ( !(chmask & (1 << id)) ) {
if (i % pfreq == 0)
if (neve % pfreq == 0)
if (plothandle[id]) {
DeleteGraphPlot (panelHandle, PANEL_GRAPH, plothandle[id], VAL_IMMEDIATE_DRAW);
plothandle[id] = 0;
150,21 → 189,23
continue;
}
if ( id != *(data++) ) printf("Error\n");
int nsamples = *(data++);
if (nsamples<=0 || nsamples>16*1024){
printf("Error nsamples %d\n", nsamples);
return -1;
}
if ( nsamples>0 && i % pfreq == 0) {
float *fdata = (float *) data;
if ( nsamples>0 && neve % pfreq == 0) {
const int col[4]= {VAL_RED,VAL_GREEN,VAL_BLUE,VAL_WHITE};
if (plothandle[id]) DeleteGraphPlot (panelHandle, PANEL_GRAPH, plothandle[id], VAL_IMMEDIATE_DRAW);
//float fdata[nsamples];
//for (int k=0;k<nsamples;k++) fdata[k] = *(float *) (data+k);
//printf("data0 %f %d\n", fdata[0], data[0]);
//plothandle[id] = PlotXY (panelHandle, PANEL_GRAPH, timebins, fdata, nsamples, VAL_FLOAT, VAL_FLOAT, VAL_THIN_LINE, VAL_NO_POINT, VAL_SOLID, 1, col[id]);
plothandle[id] = PlotXY (panelHandle, PANEL_GRAPH, timebins, fdata, nsamples, VAL_FLOAT, VAL_FLOAT, VAL_THIN_LINE, VAL_NO_POINT, VAL_SOLID, 1, col[id]);
 
plothandle[id] = PlotXY (panelHandle, PANEL_GRAPH, timebins, data, nsamples, VAL_FLOAT, VAL_INTEGER, VAL_THIN_LINE, VAL_NO_POINT, VAL_SOLID, 1, col[id]);
//plothandle[id] = PlotXY (panelHandle, PANEL_GRAPH, timebins, data, nsamples, VAL_FLOAT, VAL_INTEGER, VAL_THIN_LINE, VAL_NO_POINT, VAL_SOLID, 1, col[id]);
H1D_Draw(1,panelHandle,PANEL_ADC1,&adcplothandle[0]);
H1D_Draw(2,panelHandle,PANEL_ADC2,&adcplothandle[1]);
H1D_Draw(3,panelHandle,PANEL_TDC1,&tdcplothandle[0]);
173,26 → 214,33
if (debug) for (int k=0; k<10; k++) printf("%d %d (%f , %d)\n", id,k, timebins[k],data[k]);
}
nr+=8;
float adcdata = 10000;
for (int k=0; k<nsamples; k++) {
if (data[k] < adcdata) adcdata = data[k];
if (data[k] < ithreshold && data[k-1] > ithreshold) H1D_Fill(3+id, k,1);
for (int k=1; k<nsamples; k++) {
if (fdata[k] < adcdata) adcdata = fdata[k];
if (fdata[k]< athreshold && fdata[k-1]> athreshold) {
double t0= timebins[k-1]+(athreshold-fdata[k-1])/(fdata[k]-fdata[k-1])* (timebins[k]-timebins[k-1]);
//printf("TDC = %f\n", t0);
H1D_Fill(3+id, t0,1);
}
}
H1D_Fill(1+id, -adcdata,1);
nr+=4*nsamples;
data+=nsamples;
}
recid = *data++;
int event = *data++;
nr+=8;
neve++;
//printf("recid %d event %d\n",recid, event );
}
 
return 0;
return neve;
}
 
unsigned char data[100000000];
const int maxlen = 100000000;
unsigned char data[maxlen];
int *idata = (int *) &data[0];
 
 
202,7 → 250,7
int nb = 0 ;
static int event = 0;
static int ncalls = 0;
unsigned char cmd;
switch (xType) {
case TCP_DISCONNECT:
printf("TCP_DISCONNECT ErrorString %s\n",GetTCPErrorString(errCode));
211,46 → 259,38
chandle = 0;
break;
case TCP_DATAREADY: {
printf("Data Ready \n");
nb = ClientTCPRead(handle,&cmd,1,1000);
printf("Server Response = %d\n", cmd);
int hdr[3]= {0,0,0};
int hdr[2]={0,0};
nb = ClientTCPRead(handle,&hdr[0],8,1000);
switch (cmd) {
case 1: // init finished
initialized = 1;
int size = hdr[1] - 8;
if (size>maxlen) size=maxlen;
nb = 0;
while (nb < size) {
int retval = ClientTCPRead(handle,&data[nb],size-nb,1000);
if (retval<1) break;
nb += retval;
}
printf("Received RECID %d HDRLEN %d == read %d\n", hdr[0], size, nb);
switch (hdr[0]) {
case 0:
data[nb]=0;
printf("%s\n",data);
break;
case 2:
break;
case 3: // data ready
cmd = 4;
ClientTCPWrite(handle,&cmd,1,5000); // read
break;
case 4:// read
{
ClientTCPRead(handle,&hdr[0],12,5000);
int neve = hdr[1];
printf("Client: Data received: %d, %d, %d\n", hdr[0], neve, hdr[2]);
int size = hdr[0]-12;
nb = 0;
while (nb < size) {
int retval = ClientTCPRead(handle,&data[nb],size-nb,5000);
if (retval<1) break;
nb += retval;
}
printf("Read nb = %d size %d\n", nb, size);
analyse(neve, data);
case 1:// read
GetCtrlVal(panelHandle,PANEL_CEVE , &event);
GetCtrlVal(panelHandle,PANEL_NCALLS , &ncalls);
event +=1;
GetCtrlVal(panelHandle,PANEL_NTOTAL , &ncalls);
event += analyse(nb,data);
if (foutput) fwrite(data, 1, nb, foutput);
SetCtrlVal(panelHandle,PANEL_CEVE , event);
if (ctrl_c==0 && event < ncalls) StartCB (panelHandle, PANEL_START,EVENT_COMMIT,NULL, 0, 0 );
}
if (event>=ncalls) StartCB (panelHandle, PANEL_END, EVENT_COMMIT, NULL,0,0);
break;
default:
printf("Unknown command = %d\n", cmd);
printf("Unknown command = %d\n", hdr[0]);
break;
}
break;
264,11 → 304,11
 
int CVICALLBACK StartCB (int panel, int control, int event,
void *callbackData, int eventData1, int eventData2) {
char msg[0xFF];
char ip[0xFF];
int *hdr = (int *)&msg[1] ;
unsigned short *sbuff = (unsigned short *)&msg[1] ;
unsigned char *cbuff = (unsigned char *)&msg[1] ;
int hdr[0xFF];
char filename[0xFF];
unsigned short *sbuff = (unsigned short *)&hdr[5] ;
unsigned char *cbuff = (unsigned char *)&sbuff[3] ;
int imask[2];
unsigned char mask;
unsigned char trigger;
277,6 → 317,7
int nbefore;
unsigned short decimation;
unsigned short neve;
int output;
switch (event) {
case EVENT_COMMIT: {
GetCtrlVal(panel,PANEL_IP, ip);
289,6 → 330,8
GetCtrlVal(panel,PANEL_PFREQ , &pfreq);
GetCtrlVal(panel,PANEL_DEBUG , &debug);
GetCtrlVal(panel,PANEL_NBEFORE , &nbefore);
GetCtrlVal(panel,PANEL_ENABLEDOUTPUT, &output);
GetCtrlVal(panel,PANEL_FILENAME, filename);
delay= MINTRGDELAY + nsamples - nbefore + 1;
//delay= nsamples - NBEFORE + 1;
299,37 → 342,43
 
double level =0;
GetCtrlVal(panel,PANEL_TRGLEVEL , &level);
GetCtrlVal(panel,PANEL_ITRGLEVEL , &ithreshold);
GetCtrlVal(panel,PANEL_ITRGLEVEL , &athreshold);
 
switch (control) {
case PANEL_CONNECT:
ConnectToTCPServerEx (&chandle, 9930, ip, SocketCB, NULL, 0, TCP_ANY_LOCAL_PORT);
break;
case PANEL_INIT:
case PANEL_DISCONNECT:
if (chandle!=0) DisconnectFromTCPServer (chandle);
chandle = 0;
break;
case PANEL_START:
histoinit();
if (output) foutput = fopen(filename, "wb");
SetCtrlVal(panel,PANEL_CEVE , 0);
ctrl_c=0;
msg[0] = 1;
hdr[0] = delay;
hdr[1] = decimation;
hdr[2] = level * 1000;
SetCtrlVal(panel,PANEL_CEVE , 0);
ClientTCPWrite(chandle,&msg[0],13,5000); // init
break;
case PANEL_START:
msg[0] = 3;
hdr[0] = 0;
hdr[1] = 7*sizeof(int);
hdr[2] = delay;
hdr[3] = decimation;
hdr[4] = level * 1000;
sbuff[0] = neve;
sbuff[1] = nsamples;
sbuff[2] = 1000; //tout
cbuff[6] = trigger;
cbuff[7] = mask;
ClientTCPWrite(chandle,&msg[0],9,5000); // acquire
 
cbuff[0] = trigger;
cbuff[1] = mask;
ClientTCPWrite(chandle,&hdr[0],hdr[1],5000); // acquire
break;
 
case PANEL_END:
msg[0] = 0;
 
ClientTCPWrite(chandle,&msg[0],1,5000); // disconnect
chandle = 0;
hdr[0] = 1;
hdr[1] = 2*sizeof(int);
ClientTCPWrite(chandle,&hdr[0],hdr[1],5000); // stop the transfer
if (foutput) fclose(foutput);
foutput=NULL;
break;
default:
printf("Unknown command\n");
347,17 → 396,6
}
 
 
 
int CVICALLBACK OpenGuiCB (int panel, int control, int event,
void *callbackData, int eventData1, int eventData2) {
switch (event) {
case EVENT_COMMIT:
 
break;
}
return 0;
}
 
int CVICALLBACK ExitCB (int panel, int control, int event,
void *callbackData, int eventData1, int eventData2) {
switch (event) {
368,17 → 406,8
return 0;
}
 
int CVICALLBACK StopCB (int panel, int control, int event,
void *callbackData, int eventData1, int eventData2) {
switch (event) {
case EVENT_COMMIT:
//if (chandle != 0)
ctrl_c=1;
break;
}
return 0;
}
 
 
int CVICALLBACK ExportCB (int panel, int control, int event,
void *callbackData, int eventData1, int eventData2) {
int hid=0;
401,6 → 430,7
void *callbackData, int eventData1, int eventData2) {
switch (event) {
case EVENT_COMMIT:
for (int i=1;i<=4;i++) H1D_Clear(i);
break;
}