WebSVN - f9daq - Rev 342 - /Samo/l2d/l2d.c

/* Program l2d.c za testiranje povrsinske obcutljivosti

Avtor: Samo Korpar
Verzija:
1.00 3.5.2007
-
*/

#define USE_DAQ
#define USE_MIKRO

// Izberi ustrezni interface v meniju projektnega okna
// Options->CompilerDefines (dodaj /DSISVME ali /DWIENVME)

#ifdef USE_DAQ
# define USE_CAMAC
# include "camac.h"
//# ifdef SISVME
//# include "sisvme_dll.h"
//# endif
# ifdef WIENVME
# include "wienvme_dll.h"
# endif
# define VME_START(NODE) WIENVME_VME_START((NODE))
# define VME_STOP() WIENVME_VME_STOP()
# include "CAENV965.h"
#endif

#ifdef USE_MIKRO
# include "MIKRO.h"
#endif

#include <userint.h>
#include <ansi_c.h>
#include <utility.h>
#include <analysis.h>

#include "l2d_ui.h"

#ifdef USE_DAQ
//# define VTDC_ADDR 0x330000
# define VADC_ADDR 0x350000
//# define VTDC 0
# define VADC 1
//# define IO1_ADDR 0x100200
//# define NTDCP 20
# define NTDCJ 20
# define NGL 23
#endif

#ifdef USE_MIKRO
# define MIKRO_COM 3
#endif

#define MAXCH 0x1000
#define MAX_THREADS 10

#define IWAIT 2000

# define NCH 2
static int p1h, pID, rID, tfID;
static int ph_tdc, ph_adc;
static int dtdc[NCH][2][MAXCH];
static int dadc[NCH][2][MAXCH];
static int daq_on;
static int poolHandle = 0;
static int ntics,dummy;
// 0 1 2 3 4 5 6 7 8 9 A B C D E F
static int tdcmap[16]= { 0, 1, 2, 3, 4, 5, 6, 7,99,99,99,99,99,99,99,99};
static int adcmap[16]= {99,99,99,99,99,99,99,99, 0, 1, 2, 3, 4, 5, 6, 7};
static int ctdcmap[16]= { 0, 1, 2, 3, 4, 5, 6, 7,99,99,99,99,99,99,99,99};

/************************************************************/
void wait_loop(unsigned long iloop)

{
int i;

for (i=0; i<iloop; i++);
return;
}

int CVICALLBACK cb_timer (int panel, int control, int event, void *callbackData,
int eventData1, int eventData2) {
QueueUserEvent (9000, p1h, P1_TIMER);
return (0);
}

int update_plots (void) {
int irange, ch;

GetCtrlVal (p1h, P1_PLCH, &ch);

if (ph_tdc>0) DeleteGraphPlot (p1h, P1_TDC, ph_tdc, VAL_DELAYED_DRAW);
GetCtrlVal (p1h, P1_TDCHL, &irange);
ph_tdc = PlotY (p1h, P1_TDC, &dtdc[ch][irange], MAXCH, VAL_INTEGER,
VAL_VERTICAL_BAR, VAL_EMPTY_SQUARE, VAL_SOLID, 1, VAL_RED);

if (ph_adc>0) DeleteGraphPlot (p1h, P1_ADC, ph_adc, VAL_DELAYED_DRAW);
GetCtrlVal (p1h, P1_ADCHL, &irange);
ph_adc = PlotY (p1h, P1_ADC, &dadc[ch][irange], MAXCH, VAL_INTEGER,
VAL_VERTICAL_BAR, VAL_EMPTY_SQUARE, VAL_SOLID, 1, VAL_BLUE);
return (0);
}

int CVICALLBACK daq_run(void *functionData) {
int i,j;
int ndat,dtype,ch,rg,adc,cres;
unsigned long a,b,ec1,ec2;
unsigned long data[100];
unsigned short aa[NCH][4];

int dsave,status,fmax,fcount,fev;
char dfile[MAX_PATHNAME_LEN],dfile0[MAX_PATHNAME_LEN];
int supr0,tdcmin,fseed,esave;
float frac;
double fracg;

FILE *fp=NULL;
#define RUNREC_ID 1
#define ENDREC_ID 2
#define POSREC_ID 3
#define EVTREC_ID 4

typedef struct {
unsigned long id,len;
unsigned long fver,time;
unsigned long nev,nch,ped,xy;
long nx,x0,dx,ny,y0,dy;
} RUNREC;
RUNREC runrec;

typedef struct {
unsigned long id,len;
unsigned long time;
} ENDREC;
ENDREC endrec;

typedef struct {
unsigned long id,len;
unsigned long time;
long ix,x,xset,iy,y,yset;
} POSREC;
POSREC posrec;

typedef struct {
unsigned long id,len;
unsigned long nev;
unsigned short data[NCH*2];
} EVTREC;
EVTREC evtrec;

runrec.id = RUNREC_ID;
runrec.len = sizeof(runrec);
runrec.fver = 0x10000;
runrec.nch = NCH;
runrec.xy = 1;
endrec.id = ENDREC_ID;
endrec.len = sizeof(endrec);
posrec.id = POSREC_ID;
posrec.len = sizeof(posrec);
evtrec.id = EVTREC_ID;
evtrec.len = sizeof(evtrec);

cres = 0;

GetCtrlVal (p1h, P1_NEVE, &runrec.nev);
GetCtrlVal (p1h, P1_PEDESTAL, &runrec.ped);

GetCtrlVal (p1h, P1_NX, &runrec.nx);
GetCtrlVal (p1h, P1_XSTEP, &runrec.dx);
GetCtrlVal (p1h, P1_XMIN, &runrec.x0);
GetCtrlVal (p1h, P1_NY, &runrec.ny);
GetCtrlVal (p1h, P1_YSTEP, &runrec.dy);
GetCtrlVal (p1h, P1_YMIN, &runrec.y0);

GetCtrlVal (p1h, P1_DSAVE, &dsave);
if (dsave) {
GetCtrlVal (p1h, P1_DFILE, dfile0);

fev=0;
fcount=1;
GetCtrlVal (p1h, P1_NEWF, &fmax);
}
GetCtrlVal (p1h, P1_SUPR, &supr0);
if (supr0) {
GetCtrlVal (p1h, P1_TDCMIN, &tdcmin);
GetCtrlVal (p1h, P1_FRAC, &frac);
}

#ifdef USE_DAQ
// V965_map (VTDC, VTDC_ADDR, 1);
// V965_init (VTDC, pedestal);

V965_map (VADC, VADC_ADDR, 1);
V965_init (VADC, runrec.ped);

# ifdef USE_CAMAC
BZ(&cres);
CCCZ(&cres);
CCCC(&cres);
CREM_I(&cres);
CSSA_R(NGL,0,25,&cres);
Delay(0.01);
# ifdef NTDCJ
CSSA_R(NTDCJ,0,9,&cres);
printf("CSSA_R(NTDCJ,0,9,&cres)=0x%0x\n", cres);
CSSA_R(NTDCJ,0,26,&cres);
printf("CSSA_R(NTDCJ,0,26,&cres)=0x%0x\n", cres);
# endif
# ifdef NTDCP
CSSA_R(NTDCP,0,9,&cres);
CSSA_R(NTDCP,0,11,&cres);
CSSA_R(NTDCP,0,26,&cres);
printf("CSSA_R(NTDCP,0,26,&cres)=0x%0x\n", cres);
# endif
# endif
#endif

if (dsave) {
sprintf(dfile,"%s_file%02d.dat",dfile0,fcount);
fp = fopen (dfile, "wb");
time (&runrec.time);
status = fwrite (&runrec, 1, runrec.len, fp);
if (supr0) {
fseed = runrec.time & 0x7fffffff;
Uniform (1, fseed, &fracg);
}
}

for (posrec.ix=0; posrec.ix<runrec.nx; posrec.ix++) {
posrec.xset=runrec.x0+posrec.ix*runrec.dx;
#ifdef USE_MIKRO
// printf("MIKRO_MoveTo (1, x);%d\n",x);
MIKRO_MoveTo (1, posrec.xset);
// printf("->MIKRO_MoveTo (1, x);%d\n",x);
#endif

SetCtrlVal (p1h, P1_X, posrec.xset);
SetCtrlVal (p1h, P1_IX, posrec.ix);
for (posrec.iy=0; posrec.iy<runrec.ny; posrec.iy++) {

posrec.yset=runrec.y0+posrec.iy*runrec.dy;
#ifdef USE_MIKRO
// printf("MIKRO_MoveTo (2, y);%d\n",y);
MIKRO_MoveTo (2, posrec.yset);
// printf("->MIKRO_MoveTo (2, y);%d\n",y);
#endif

SetCtrlVal (p1h, P1_Y, posrec.yset);
SetCtrlVal (p1h, P1_IY, posrec.iy);

if (dsave) {
time (&posrec.time);
status = fwrite (&posrec, 1, posrec.len, fp);
}

// clear the plots
for (j=0; j<NCH; j++) {
for (i=0; i<MAXCH; i++) {
dtdc[j][0][i]=0;
dtdc[j][1][i]=0;
dadc[j][0][i]=0;
dadc[j][1][i]=0;
}
}

evtrec.nev=1;
do {
for (j=0; j<NCH; j++)
for (i=0; i<4; i++)
aa[j][i]=0;
// if((neve%1000)==0) printf("Events %ld\n",neve);

#ifdef USE_DAQ
ndat = 0;
// a = 0x0001;
// VME_A24D16_W(IO1_ADDR + 0x000008, &a); //poslje laserski sunek

ntics=0;
# ifdef USE_CAMAC
CSSA_R(NGL,0,10,&cres);
// do {
// wait_loop(IWAIT);
// Delay(0.1);
# ifdef NTDCJ
// CSSA_R(NTDCJ,0,8,&cres);
# endif
# ifdef NTDCP
// CSSA_R(NTDCP,0,8,&cres);
# endif
// if (!(cres&0x8000)) printf("CSSA_R(NTDCJ,0,8,&cres)=0x%0x\n", cres) ;
// } while ((!(cres&0x8000))&&(ntics<2)&&daq_on);
# endif
// wait_loop(2000);
while((!(V965_status(VADC)&0x1))&&(ntics<2)&&daq_on);
if (!daq_on) break;
if (ntics>=2) {
ndat=V965_read (VADC, &data[0]);
continue;
} else {
# ifdef USE_CAMAC
# ifdef NTDCJ
wait_loop(20000);
// ntics=0;
// do {
// wait_loop(IWAIT);
CSSA_R(NTDCJ,0,8,&cres);
// if (!(cres&0x8000)) printf("CSSA_R(NTDCJ,0,8,&cres)=0x%0x\n", cres) ;
// } while ((!(cres&0x8000))&&(ntics<2)&&daq_on);
// if (!daq_on) break;
// if (ntics>=2) {
if (!(cres&0x8000)) {
CSSA_R(NGL,0,25,&cres);
ndat=V965_read (VADC, &data[0]);
CSSA_R(NTDCJ,0,9,&cres);
CSSA_R(NTDCJ,0,26,&cres);
continue;
}
# endif
# endif
}
/*
ndat=V965_read (VTDC, &data[0]);
for (i=0; i<ndat; i++) {
dtype=(data[i]>>25)&0x3;
if (dtype==0) {
ch=tdcmap[(data[i]>>17)&0xf];
if (ch<NCH) {
rg=(data[i]>>16)&0x1;
adc=data[i]&0xfff;
aa[ch][rg]=adc;
dtdc[ch][rg][adc]+=1;
}
}
}
*/
for (i=0; i<NCH; i++) {
wait_loop(IWAIT);
# ifdef USE_CAMAC
# ifdef NTDCJ
CSSA_R(NTDCJ,ctdcmap[i],0,&adc);
# endif
# ifdef NTDCP
CSSA_R(NTDCP,ctdcmap[i],0,&adc);
# endif
# endif
// printf("TDC=0x%04X\n",adc);
// adc=adc&0xfff;
if (adc&0x1000) adc=0xfff; else adc&=0xfff;
aa[i][0]=adc;
dtdc[i][0][adc]+=1;
}

ndat=V965_read (VADC, &data[0]);
for (i=0; i<ndat; i++) {
dtype=(data[i]>>25)&0x3;
if (dtype==0) {
ch=adcmap[(data[i]>>17)&0xf];
if (ch<NCH) {
rg=(data[i]>>16)&0x1;
adc=data[i]&0xfff;
aa[ch][rg+2]=adc;
dadc[ch][rg][adc]+=1;
}
}
}

# ifdef USE_CAMAC
wait_loop(IWAIT);
# ifdef NTDCJ
CSSA_R(NTDCJ,0,9,&cres);
# endif
# ifdef NTDCP
CSSA_R(NTDCP,0,9,&cres);
CSSA_R(NTDCP,0,26,&cres);
// printf("2 CSSA_R(NTDCP,0,26,&cres)=0x%0x\n", cres);
# endif
// Delay(0.001);
// wait_loop(IWAIT);
// CSSA_R(NGL,0,10,&cres);
# endif

#else /* generate test data */
if (!daq_on) break;
for (i=0; i<NCH; i++) {
adc=100+evtrec.nev%200;
dtdc[i][1][adc]+=1;
dadc[i][1][adc]+=1;
aa[i][0]=adc;
aa[i][2]=adc;
adc=200+evtrec.nev%400;
dtdc[i][0][adc]+=1;
dadc[i][0][adc]+=1;
aa[i][1]=adc;
aa[i][3]=adc;
}
#endif
esave=dsave;
if (supr0 && esave) {
Uniform (1, -1, &fracg);
if (fracg > frac) {
esave=0;
for (i=0; i<NCH; i++) {
if ((aa[i][0] >= tdcmin) && (aa[i][0] < 4000)) esave=1;
}
}
}
if (esave) {
// time (&evtrec.time);
for (i=0; i<NCH; i++) {
evtrec.data[i] = aa[i][0];
evtrec.data[i+NCH] = aa[i][2];
}
status = fwrite (&evtrec, 1, evtrec.len, fp);
}

if (!(evtrec.nev%1000)) SetCtrlVal (p1h, P1_CEVE, evtrec.nev);
} while (evtrec.nev++<runrec.nev);
if (!daq_on) break;
}
if (!daq_on) break;
}

if (dsave) {
time (&endrec.time);
status = fwrite (&endrec, 1, endrec.len, fp);
fclose(fp);
}

daq_on=0;
SetCtrlVal (p1h, P1_DAQ, daq_on);
SetCtrlVal (p1h, P1_CEVE, evtrec.nev);

return 0;
}

int __stdcall WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
LPSTR lpszCmdLine, int nCmdShow) {
int i,j,status,refon;
long int zpos;
char dfile[300];
FILE *fp;

typedef struct {
unsigned long id,len;
unsigned long fver,time;
unsigned long nev,nch,ped,xy;
long nx,x0,dx,ny,y0,dy;
} RUNREC;
RUNREC runrec;

if (InitCVIRTE (hInstance, 0, 0) == 0)
return -1; /* out of memory */

SetSleepPolicy(VAL_SLEEP_MORE);
CmtNewThreadPool (MAX_THREADS, &poolHandle);

SetStdioWindowOptions (1000, 0, 0);
SetStdioWindowSize (150, 600);
SetStdioWindowPosition (825, 20);

#ifdef USE_DAQ
VME_START(NULL);
#endif

#ifdef USE_MIKRO
MIKRO_Open (MIKRO_COM);
MIKRO_Init (1,0);
MIKRO_Init (2,0);
MIKRO_Init (3,0);
#endif

if ((p1h = LoadPanel (0, "l2d_ui.uir", P1)) < 0) return -1;
DisplayPanel (p1h);
SetCtrlAttribute (p1h, P1_PLCH, ATTR_MAX_VALUE, NCH-1);

QueueUserEvent (1000, p1h, P1_RESET);

do {
GetUserEvent (1, &pID, &rID);
switch (rID) {
case P1_TIMER:
ntics+=1;
GetCtrlVal (p1h, P1_REFON, &refon);
if (refon) update_plots();
break;
case P1_REFRESH:
update_plots();
break;
case P1_DAQ:
GetCtrlVal (p1h, P1_DAQ, &daq_on);
if (daq_on) {
CmtScheduleThreadPoolFunction (poolHandle, daq_run, (void *)&dummy, &tfID);
} else {
CmtWaitForThreadPoolFunctionCompletion (poolHandle, tfID,
OPT_TP_PROCESS_EVENTS_WHILE_WAITING);
CmtReleaseThreadPoolFunctionID (poolHandle, tfID);
}
break;
case P1_ZSET:
if (!daq_on) {
GetCtrlVal (p1h, P1_ZSET, &zpos);
#ifdef USE_MIKRO
MIKRO_MoveTo (3, zpos);
#endif
}
break;
case P1_REREAD:
if (!daq_on) {
status = FileSelectPopup ("", "*.dat", ".dat",
"Izberi datoteko s podatki",
VAL_LOAD_BUTTON, 0, 0, 1, 0, dfile);
if (status==1) {
fp = fopen (dfile, "rb");
status = fread (&runrec, 1, sizeof(runrec), fp);
fclose(fp);
if (runrec.id==1) {
SetCtrlVal (p1h, P1_NX, runrec.nx);
SetCtrlVal (p1h, P1_XSTEP, runrec.dx);
SetCtrlVal (p1h, P1_XMIN, runrec.x0);
SetCtrlVal (p1h, P1_NY, runrec.ny);
SetCtrlVal (p1h, P1_YSTEP, runrec.dy);
SetCtrlVal (p1h, P1_YMIN, runrec.y0);
SetCtrlVal (p1h, P1_NEVE, runrec.nev);
}
}
}
break;
case P1_HO:
if (!daq_on) {
SetWaitCursor (1);
#ifdef USE_MIKRO
MIKRO_ReferenceMove (1);
MIKRO_ReferenceMove (2);
MIKRO_ReferenceMove (3);
#endif
SetWaitCursor (0);
}
break;
case P1_RESET:
for (j=0; j<NCH; j++) {
for (i=0; i<MAXCH; i++) {
dtdc[j][0][i]=0;
dtdc[j][1][i]=0;
dadc[j][0][i]=0;
dadc[j][1][i]=0;
}
}
update_plots();
break;
case P1_TDCLOG:
GetCtrlVal (p1h, P1_TDCLOG, &status);
SetCtrlAttribute (p1h, P1_TDC, ATTR_YMAP_MODE, status);
update_plots();
break;
case P1_ADCLOG:
GetCtrlVal (p1h, P1_ADCLOG, &status);
SetCtrlAttribute (p1h, P1_ADC, ATTR_YMAP_MODE, status);
update_plots();
break;
}

} while ((rID != P1_EXIT)||daq_on);

CmtDiscardThreadPool (poolHandle);
DiscardPanel (p1h);

#ifdef USE_MIKRO
MIKRO_Close ();
#endif

#ifdef USE_DAQ
VME_STOP();
#endif
return 0;

}

Subversion Repositories f9daq

(root)/Samo/l2d/l2d.c - Rev 342