WebSVN – f9daq – Blame – //cvi/apps/sa02_daq/cvi/sa02_CVI.c

Rev	Author	Line No.	Line
326	f9daq	1	//#include "tabela.h"
		2	//#include "proba.h"
		3
		4
		5	#include "vme.h"
		6
		7	//#define PTS_ADDR 0x025F0000
		8	//#define PTS_ADDR 0x26000000
		9
		10	#include "PtsModule.h"
		11	#define PTS_ADDR 0x61000000
		12	#include <windows.h>
		13	#include <formatio.h>
		14	#include <analysis.h>
		15	#include "toolbox.h"
		16	#include <cvirte.h>
		17	#include <stdlib.h>
		18	#include <stdio.h>
		19
		20	#include <string.h>
		21	#include <ctype.h>
		22	#include <stdint.h>
		23
		24	#include <signal.h>
		25	#include <utility.h>
		26	#include <ansi_c.h>
		27	#include <userint.h>
		28	#include "toolbox.h"
		29
		30	#include "sa02lib.h"
		31	#include "CAEN_V729.h"
		32	#include "CAEN_V729_CVI.h"
		33	#include "icfa.h"
		34
		35	#include "MIKRO.h"
		36	const int dsize = 144*4;
		37
		38	#include "H1D.h"
		39	#include "H2D.h"
		40	#include "H3D.h"
		41	#include "HDraw.h"
		42	#include "dataio.h"
		43	#include "sa02lib.h"
		44	#include "sa02_CVI.h"
		45
		46	int ProcessUserEvent(int pID, int rID,int mode);
		47
		48	const char palaser[0xFF]="\"C:\\home\\software\\daq\\LaserDriver-Ver2.0\\Particulars LASER control.exe\"";
		49
		50	#define MAX_THREADS 10
		51	const char slowcname[20][20]= {"TMON0","TMON1","VDD","V2P","V2N","VSS","VTH1","VTH2", "VCC12", "VCC15" ,"VCC25", "V38P" };
		52	const int chart_control[4]= {P1_CHART_1,P1_CHART_2,P1_CHART_3,P1_CHART_4};
		53	const int hapd_serials [4]= { P1_SERIAL_1, P1_SERIAL_2, P1_SERIAL_3, P1_SERIAL_4 };
		54	const int fpga_serials [4]= { P1_SERIAL_FPGA_1, P1_SERIAL_FPGA_2, P1_SERIAL_FPGA_3, P1_SERIAL_FPGA_4 };
		55	const int hapd_onoff [4]= { P1_ONOFF_1, P1_ONOFF_2, P1_ONOFF_3, P1_ONOFF_4 };
		56	const int p2graph [4]= { P2_GRAPH_1, P2_GRAPH_2, P2_GRAPH_3, P2_GRAPH_4 };
		57
		58	#define PTS_ADDR 0x61000000
		59
		60	#define MIKRO_COM 4
		61	#define MIKRO_X 1
		62	#define MIKRO_Y 2
		63	#define MIKRO_Z 3
		64
		65	#define TRUE 1
		66	#define FALSE 0
		67	#define TIMEOUT 3
		68
		69	#define CHECK_BIT(var,pos) ((var) & (1<<(pos)))
		70	uint32_t gVME_CONTROLLER=WIENER_VMEMM;
		71	uint32_t gCAEN_V288=0;
		72	uint32_t gBELLEPTS=PTS_ADDR;
		73	uint32_t gMIKRO_PORT=MIKRO_COM;
		74	uint32_t gMIKRO_X=MIKRO_X, gMIKRO_Y=MIKRO_Y, gMIKRO_Z=MIKRO_Y;
		75	uint32_t gCENTER_X=176000, gCENTER_Y=170000;
		76	double gCENTER_KX=6./300, gCENTER_KY=3./300;
		77	uint32_t gCAEN_V729=0;
		78	uint32_t gCAEN_V1495=0;
		79	uint32_t gFEBParamRead=0;
		80	uint32_t gFEBMask=0xF;
		81	uint32_t gTriggerType=2;
		82	char gFEBParam[0xFF]="";
		83
		84	uint32_t uInterf = 0;
		85
		86	RUNINFO runinfo;
		87	RUNREC runrec;
		88	ENDREC endrec;
		89	POSREC posrec;
		90	EVTREC evtrec;
		91	EVTREC evtrec1;
		92	DATREC datrec;
		93	MONREC monrec;
		94	ITERATORREC iteratorrec;
		95
		96
		97	typedef struct {
		98	int chip;
		99	int ch;
		100	int chx;
		101	int chy;
		102	} EID2HAPDY;
		103
		104	EID2HAPDY eid2hapdxy[144];
		105
		106	// Variables
		107	static int p1h, pID, rID, tfID;
		108	static int p2h;
		109	static int p3h;
		110	static int p4h;
		111	static int p5h;
		112	static int pm1;
		113	static int daq_on,loop_on;
		114	static CmtThreadPoolHandle poolHandle = 0;
		115	static CmtTSQHandle pTSQ = 0;
		116	static int pTSQData[2];
		117
		118	double datay[10000];
		119	double datax[10000];
		120	double datayfit[10000];
		121
		122	//const int mux_map[4]={ 1,3,0,2};
		123
		124	int ctrl_c=0;
		125	int integer_val=0;
		126	FILE *gFp=NULL;
		127
		128	//*********************VARIABLE ZA BRANJE NAPETOSTI*********************//
		129
		130	#include "CAENV288.h"
		131
		132	#define ReadOperationalParam 0x02 //N470
		133	#define TurnChanelOn 0x0a //N470
		134	#define TurnChanelOff 0x0b //N470
		135	#define ReadStatus 0x01 //SYS403
		136	#define ReadParameters 0x02 //SYS403
		137
		138	int hvmon=0;
		139	int hvmonFirst=0;
		140	int32_t vset[24], iset[24];
		141
		142
		143	// reads the run number from the first line in the file
		144	int GetRunNumberFromFile(char *fname) {
		145	char line[MAX_PATHNAME_LEN];
		146	int ndim= MAX_PATHNAME_LEN;
		147	int current_run = -1;
		148	FILE *fp = NULL;
		149	ssize_t size;
		150
		151	if ( GetFileInfo(fname,&size) ) fp = fopen(fname,"r");
		152
		153	if (fp) {
		154	if (fgets(line,ndim,fp)!= NULL) current_run = atoi(line);
		155	fclose(fp);
		156	}
		157	return current_run;
		158
		159	}
		160
		161	int IncreaseRunNumberInFile(char *fname) {
		162
		163	int current_run = GetRunNumberFromFile(fname);
		164	FILE *fp = fopen(fname,"w");
		165
		166	if (fp) {
		167	fprintf(fp,"%d", current_run+1 );
		168	fclose(fp);
		169	}
		170	return current_run+1;
		171	}
		172
		173
		174	//**************************** get station parameters from ini file
		175	int readIni(char *fname) {
		176
		177	FILE *fp = NULL;
		178	char cmd[0xFF],val[0xFF];
		179	int ndim=400;
		180	char line[ndim];
		181	ssize_t size;
		182
		183	if ( GetFileInfo(fname,&size) ) fp = fopen(fname,"r");
		184	if (!fp) {
		185	sprintf(line, "%s not found. Using default values.\n",fname);
		186	MessagePopup ("Info", line);
		187	return -1;
		188	}
		189	while (fgets(line,ndim,fp)!=NULL) {
		190	sscanf(line,"%s%s",cmd, val);
		191	if (cmd[0]=='#') continue;
		192	if ( strstr(cmd,"VME_CONTROLLER")!= NULL ) {
		193	if ( strstr(val,"WIENER_VMUSB")!= NULL ) gVME_CONTROLLER=WIENER_VMUSB;
		194	if ( strstr(val,"WIENER_VMEMM")!= NULL ) gVME_CONTROLLER=WIENER_VMEMM;
		195	if ( strstr(val,"CAEN_V1718") != NULL ) gVME_CONTROLLER=CAEN_V1718;
		196	if ( strstr(val,"SIS3153_USB") != NULL ) gVME_CONTROLLER=SIS3153_USB;
		197	}
		198	if ( strstr(cmd,"CAEN_V288" )!= NULL ) gCAEN_V288 =strtoul(val,NULL,0);
		199	if ( strstr(cmd,"BELLEPTS") != NULL ) gBELLEPTS =strtoul(val,NULL,0);
		200	if ( strstr(cmd,"CAEN_V1495") != NULL ) gCAEN_V1495 =strtoul(val,NULL,0);
		201	if ( strstr(cmd,"MIKRO_PORT")!= NULL ) gMIKRO_PORT=strtoul(val,NULL,0);
		202	if ( strstr(cmd,"MIKRO_X") != NULL ) gMIKRO_X =strtoul(val,NULL,0);
		203	if ( strstr(cmd,"MIKRO_Y") != NULL ) gMIKRO_Y =strtoul(val,NULL,0);
		204	if ( strstr(cmd,"MIKRO_Z") != NULL ) gMIKRO_Z =strtoul(val,NULL,0);
		205	if ( strstr(cmd,"CENTER_X") != NULL ) gCENTER_X =strtoul(val,NULL,0);
		206	if ( strstr(cmd,"CENTER_Y") != NULL ) gCENTER_Y =strtoul(val,NULL,0);
		207	if ( strstr(cmd,"CENTER_KX") != NULL ) gCENTER_KX =strtod(val,NULL);
		208	if ( strstr(cmd,"CENTER_KY") != NULL ) gCENTER_KY =strtod(val,NULL);
		209	if ( strstr(cmd,"CAEN_V729") != NULL ) gCAEN_V729 =strtoul(val,NULL,0);
		210	if ( strstr(cmd,"FEBParam") != NULL ) sprintf(gFEBParam,"%s", val);
		211	if ( strstr(cmd,"UI") != NULL ) uInterf =strtoul(val,NULL,0);
		212	if ( strstr(cmd,"FEBMask") != NULL ) gFEBMask =strtoul(val,NULL,0);
		213	if ( strstr(cmd,"TriggerType") != NULL ) gTriggerType =strtoul(val,NULL,0);
		214	}
		215	fclose(fp);
		216	return 0;
		217	}
		218	//**************************** missing declarations in the library
		219	char strbuf[0xFF];
		220
		221	int gLog=0;
		222	int sa02Printf(const char *format, ...) {
		223	va_list aptr;
		224	int ret;
		225	FILE *flog;
		226
		227	va_start(aptr, format);
		228	ret = vsprintf(strbuf, format, aptr);
		229	va_end(aptr);
		230	SetCtrlVal(p1h,P1_STDIO,strbuf);
		231
		232	if (gLog) {
		233	flog = fopen ("stdio.log", "a");
		234	fprintf (flog, "%s", strbuf);
		235	fclose (flog);
		236	}
		237	return(ret);
		238	}
		239
		240
		241	int CVICALLBACK sa02timeout (int panel, int control, int event,
		242	void *callbackData, int eventData1, int eventData2) {
		243	switch (event) {
		244	case EVENT_TIMER_TICK:
		245	sa02TimerOut = TRUE;
		246	sa02Printf("sa02timeout\n");
		247	//sa02Printf("TIMEOUT %s in line %d\n", __FILE__ , __LINE__);
		248	break;
		249	}
		250	return 0;
		251	}
		252	void sa02Timerast (int signumber) {
		253	sa02TimerOut = TRUE;
		254	sa02Printf("TIMEOUT !!!\n");
		255	SetCtrlAttribute (p1h, P1_DAQ_TIMEOUT, ATTR_ENABLED, 0);
		256	}
		257
		258	void sa02Tmlnk (int tout) {
		259	sa02TimerOut = FALSE;
		260	SetCtrlAttribute (p1h, P1_DAQ_TIMEOUT, ATTR_INTERVAL,
		261	(float)tout/100.);
		262	SetCtrlAttribute (p1h, P1_DAQ_TIMEOUT, ATTR_ENABLED, 1);
		263	// ResetTimer (p1h, P1_DAQ_TIMEOUT);
		264	}
		265
		266	void sa02Tmulk ( void ) {
		267	SetCtrlAttribute (p1h, P1_DAQ_TIMEOUT, ATTR_ENABLED, 0);
		268	}
		269	//****************************
		270
		271
		272	int EscapeString(const char i, char o) {
		273	unsigned int iptr=0, optr = 0;
		274	// walk though the input string
		275	for (iptr = 0; iptr < strlen(i); iptr++, optr++) {
		276	// search for
		277	if ( (i[iptr]=='\\') ) {
		278	sa02Printf("Escape String %d %d \n",i[iptr] , i[iptr]==92 ) ;
		279	//sa02Printf("Escape String %d %d \n",i[iptr] , ( (i[iptr] == 92) \|\| (i[iptr] == 42) )) ;
		280	o[optr] = i[iptr];
		281	optr++;
		282	}
		283
		284	o[optr] = i[iptr];
		285	}
		286
		287	o[optr] = '\0';
		288
		289
		290	return 0;
		291	}
		292
		293
		294
		295	int p1plothandle=0;
		296	int p2plothandle[4]= {0,0,0,0};
		297	int p3plothandle=0;
		298
		299	int plothandle=0;
		300
		301	int phandle[4]= {0,0,0,0};
		302
		303
		304	int plothandle2dfit=0;
		305	int plothandleslix=0;
		306	int plothandlesliy=0;
		307	int plothandlefit=0;
		308
		309	void SigInt (int sig) {
		310	ctrl_c = 1;
		311	sa02TimerOut=1;
		312	}
		313
		314	//int sa02Verbose=0;
		315	int module_header(int recid,uint32_t *data,int len) {
		316	data[0] = recid;
		317	data[1] = (len >0)? len : 0 ;
		318	return data[1]+2;
		319	}
		320
		321	int PrintData(uint32_t *rdata, int count) {
		322	int j;
		323	uint32_t i;
		324	for (j=0; j<count; j++) {
		325	uint32_t recid = rdata[j++];
		326	uint32_t len = rdata[j++];
		327	sa02Printf(" recid=0x%0x len=%d pos=%d(maxpos %d) val=",recid, len, j, count);
		328	if (len>2) {
		329	sa02Printf("\n");
		330	}
		331	for (i=0; i<len; i++) {
		332	if (j< count) {
		333	sa02Printf("0x%0x\t", rdata[j]);
		334	}
		335	if (i%4==3) {
		336	sa02Printf("\n");
		337	}
		338	j++;
		339	}
		340	sa02Printf("\n");
		341	if (len) {
		342	j--;
		343	}
		344	}
		345	return 0;
		346	}
		347
		348	//-------------------------------------------------------------------------
		349	int CVICALLBACK PlotSliceY (int panel, int control, int event,
		350	void *callbackData, int eventData1, int eventData2) {
		351	int nslice,i;
		352	int h2=(int) callbackData;
		353
		354	switch (event) {
		355	case EVENT_COMMIT: {
		356	int ny = H2DGetNbinsY(h2);
		357	double miny = H2DGetMinY(h2);
		358	double stepy = H2DGetStepY(h2);
		359	GetCtrlVal(panel,P1_NSLIX,&nslice);
		360
		361	for (i=0; i < ny; i++ ) {
		362	datax[i]=H2DGetBinContent(h2,nslice,i);
		363	}
		364	if (ny>0) {
		365	if (plothandleslix) {
		366	DeleteGraphPlot (p1h, P1_GRAPHY, plothandleslix, VAL_IMMEDIATE_DRAW);
		367	}
		368
		369	plothandleslix = PlotWaveform (p1h, P1_GRAPHY, datax, ny,
		370	VAL_DOUBLE, 1.0, 0.0, miny,
		371	stepy, VAL_FAT_LINE,
		372	VAL_EMPTY_SQUARE, VAL_SOLID, 1,
		373	VAL_BLUE);
		374	}
		375
		376	}
		377	break;
		378	}
		379	return 0;
		380	}
		381
		382
		383	int CVICALLBACK PlotSliceX (int panel, int control, int event,
		384	void *callbackData, int eventData1, int eventData2) {
		385	int nslice,i;
		386	int h2=(int) callbackData;
		387
		388	switch (event) {
		389	case EVENT_COMMIT: {
		390	int nx = H2DGetNbinsX(h2);
		391	double minx = H2DGetMinX(h2);
		392	double stepx = H2DGetStepX(h2);
		393	GetCtrlVal(panel,P1_NSLIY,&nslice);
		394	for (i=0; i < nx; i++ ) {
		395	datax[i]=H2DGetBinContent(h2,i,nslice);
		396	}
		397	if (nx>0) {
		398	if (plothandlesliy) {
		399	DeleteGraphPlot (p1h, P1_GRAPHX, plothandlesliy, VAL_IMMEDIATE_DRAW);
		400	}
		401
		402	plothandlesliy = PlotWaveform (p1h, P1_GRAPHX, datax, nx,
		403	VAL_DOUBLE, 1.0, 0.0, minx,
		404	stepx, VAL_FAT_LINE,
		405	VAL_EMPTY_SQUARE, VAL_SOLID, 1,
		406	VAL_BLUE);
		407	}
		408
		409	}
		410	break;
		411	}
		412	return 0;
		413	}
		414
		415
		416
		417	void plot1d(int npoints, double x0, double dx) {
		418	sa02Printf("TEST %d\n", npoints);
		419	if (npoints>0) {
		420	if (plothandle) {
		421	DeleteGraphPlot (p1h, P1_GRAPH, plothandle, VAL_IMMEDIATE_DRAW);
		422	}
		423	plothandle = PlotWaveform (p1h, P1_GRAPH, datay, npoints, VAL_DOUBLE,
		424	1.0, 0.0, x0, dx, VAL_CONNECTED_POINTS,
		425	VAL_EMPTY_SQUARE, VAL_SOLID, 1, VAL_BLUE);
		426	}
		427	}
		428
		429	/*
		430	void plotxy(int h2d){
		431	if (plothandlexy > 0 ) DeleteGraphPlot (p2h, P2_GRAPHXY, plothandlexy, VAL_IMMEDIATE_DRAW);
		432	RangeColors(H2DGetMin(h2d),H2DGetMax(h2d));
		433	plothandlexy = PlotScaledIntensity (p2h, P2_GRAPHXY, H2DGetData(h2d),
		434	H2DGetNbinsX(h2d), H2DGetNbinsY(h2d), VAL_DOUBLE,
		435	H2DGetStepY(h2d),H2DGetMinY(h2d),H2DGetStepX(h2d),H2DGetMinX(h2d),
		436	colormap->array,
		437	colormap->HiColor,
		438	colormap->numberofColors, 1, 0);
		439	ProcessSystemEvents ();
		440	}
		441	*/
		442
		443	int CVICALLBACK ZoomToFebCB (int panel, int control, int event,
		444	void *callbackData, int eventData1, int eventData2) {
		445	int feb=-1;
		446	float xmin=0, xmax=0;
		447	switch (event) {
		448	case EVENT_COMMIT:
		449	GetCtrlVal(panel,control,&feb);
		450	switch (feb) {
		451	case -1:
		452	xmin=0;
		453	xmax=144*4-1;
		454	break;
		455	default:
		456	xmin = feb *144;
		457	xmax =xmin+144 -1;
		458	break;
		459	}
		460	SetAxisRange (p1h, P1_GRAPH2D, VAL_MANUAL, xmin, xmax, VAL_NO_CHANGE, 0.0, 1.0);
		461	break;
		462	}
		463	return 0;
		464	}
		465
		466
		467
		468
		469	void plot2d(int h2d, int nslice) {
		470	if (nslice < 0 ) {
		471	nslice=0;
		472	}
		473	if (plothandle2dfit > 0 ) {
		474	DeleteGraphPlot (p1h, P1_GRAPH2D, plothandle2dfit, VAL_IMMEDIATE_DRAW);
		475	plothandle2dfit=0;
		476	}
		477	H2DDraw(h2d,p1h, P1_GRAPH2D, &p1plothandle);
		478
		479	if (sa02Verbose > 2) {
		480	sa02Printf("min %f max %f x:min %f step%f y:min %f step%f\n",
		481	H2DGetMin(h2d),H2DGetMax(h2d), H2DGetMinX(h2d),
		482	H2DGetStepX(h2d),H2DGetMinY(h2d), H2DGetStepY(h2d));
		483	}
		484	SetCtrlVal(p1h, P1_NSLIY, nslice);
		485	PlotSliceX(p1h,P1_GRAPHY,EVENT_COMMIT, NULL,0,0);
		486	PlotSliceY(p1h,P1_GRAPHY,EVENT_COMMIT, NULL,0,0);
		487	ProcessSystemEvents ();
		488	}
		489
		490	void SetDimming(int state) {
		491	SetCtrlAttribute (p1h, P1_MULTIFPGAWRITE, ATTR_DIMMED, state);
		492	SetCtrlAttribute (p1h, P1_DAQ, ATTR_DIMMED, state);
		493	SetCtrlAttribute (p1h, P1_READOUT, ATTR_DIMMED, state);
		494	SetCtrlAttribute (p1h, P1_FPGAWRITE, ATTR_DIMMED, state);
		495	SetCtrlVal (p1h, P1_LED, state);
		496	SetCtrlAttribute (p2h, P2_DAQ, ATTR_DIMMED, state);
		497	SetCtrlAttribute (p2h, P2_RUNSCRIPT, ATTR_DIMMED, state);
		498	SetCtrlAttribute (p3h, P3_DAQ, ATTR_DIMMED, state);
		499	SetCtrlAttribute (p4h, P4_DAQ, ATTR_DIMMED, state);
		500	SetCtrlAttribute (p1h, P1_STOP, ATTR_DIMMED, !state);
		501	SetCtrlAttribute (p2h, P2_STOP, ATTR_DIMMED, !state);
		502	SetCtrlAttribute (p3h, P3_STOP, ATTR_DIMMED, !state);
		503	SetCtrlAttribute (p4h, P4_STOP, ATTR_DIMMED, !state);
		504	}
		505
		506
		507	uint16_t GetConnectedFebMask(void) {
		508
		509	uint16_t mask=0;
		510	int ison;
		511	for (int i=0; i<4; i++) {
		512	GetCtrlVal(p1h,hapd_onoff[i], &ison);
		513	mask \|= (ison << i);
		514	}
		515	sa02Printf("Connected FEBs mask, 0x%0x\n",mask);
		516	return mask;
		517	}
		518
		519	int CVICALLBACK daq(void *functionData) {
		520
		521	char title[256], serial[64];
		522	int daqmode=1;
		523	#define MAXSIZE 10000
		524	int h2=0;
		525	int maxsize = MAXSIZE;
		526	uint32_t *rdata;
		527	uint32_t response[2]= {0,0};
		528
		529	uint32_t fixeddata =0;
		530	int testfixeddata =0;
		531	uint32_t data =0;
		532	uint32_t data0 =0;
		533	uint32_t dataoff =0;
		534	uint32_t dataon =0;
		535
		536	uint32_t cmd =0;
		537	uint32_t chip =0;
		538	uint32_t asicpar =0;
		539	uint32_t asicshft=0;
		540	uint32_t dstep =0;
		541	uint32_t sendswtrg =0;
		542	uint32_t tpenb =0;
		543
		544	uint32_t trglen;
		545	uint16_t mask;
		546	//uint32_t boardnumber_current=0;
		547	// uint32_t hdr[10];
		548
		549	unsigned int aborttimeout =0;
		550	int append =0;
		551	int remap =0;
		552	int neve =0;
		553	int towrite =0;
		554	int toread =0;
		555	int ch =0;
		556	int output =0;
		557	int externalcmd =0;
		558	int i=0,j=0, ir;
		559	int ich;
		560	//int ison;
		561
		562	char sfixeddata[0xFF]="";
		563	char scmd[0xFF]="";
		564
		565	char filename[0xFF]="";
		566
		567	char externalcommand[0xFF]="";
		568
		569	FILE *fp=NULL;
		570	int nbtotal=0;
		571	time_t t,told, tstart;
		572	int ncount=0;
		573	int nerrors=0;
		574	int readerror=0;
		575	//int writeevents=0;
		576	double fraction=0;
		577	int board;
		578	double t0;
		579
		580	rdata = malloc(sizeof(uint32_t)*maxsize);
		581
		582	// intercept routine
		583	if (signal (SIGINT, SigInt) == SIG_ERR) {
		584	perror ("sigignore");
		585	}
		586
		587
		588	mask=GetConnectedFebMask();
		589	GetCtrlVal(p1h,P1_OUTPUTFILE, filename);
		590	GetCtrlVal(p1h,P1_APPEND,&append); // append the data to the file filename
		591	GetCtrlVal(p1h,P1_FRACTION, &fraction);
		592
		593	GetCtrlVal(p1h,P1_ABORTTOUT, &aborttimeout);
		594
		595	GetCtrlVal( p1h,P1_EXTERNALCMD, externalcommand);
		596	GetCtrlVal( p1h,P1_EXTCMD, &externalcmd);
		597
		598	GetCtrlVal(p1h,P1_FIXEDDATA, sfixeddata);
		599	fixeddata = strtoul (sfixeddata,NULL,0);
		600	GetCtrlVal(p1h,P1_TESTFIXEDDATA, &testfixeddata);
		601
		602
		603	GetCtrlVal(p1h,P1_TOREAD, &toread);
		604
		605
		606	GetCtrlVal(p1h,P1_NEVE, &neve);
		607	GetCtrlVal(p1h,P1_DSTEP, &dstep );
		608
		609
		610	GetCtrlVal(p1h,P1_SENDSWTRIG,&sendswtrg);
		611	GetCtrlVal(p1h,P1_INTTRGLEN, &trglen);
		612	GetCtrlVal(p1h,P1_DAQMODE, &daqmode);
		613	Sa02DaqMode (daqmode);
		614	Sa02SelectTriggerWithMaskAndLength (sendswtrg, mask, trglen);
		615
		616
		617	GetCtrlVal(p1h,P1_CHIP,&chip);
		618	GetCtrlVal(p1h,P1_CHANNEL,&ch);
		619	GetCtrlVal(p1h,P1_DATA,&data);
		620	data0=data;
		621	GetCtrlVal(p1h,P1_SCANTYPE,&towrite);
		622	switch (towrite) {
		623	case 1:
		624	GetCtrlVal(p1h,P1_WRITECMD,scmd);
		625	if (strcmp(scmd,"MUXASIC")==0) {
		626	remap=1;
		627	}
		628	cmd =sa02GetCmdCode(scmd);
		629	break;
		630	case 3:
		631	GetCtrlVal(p1h,P1_CHANNELOFF,scmd);
		632	dataoff = strtoul (scmd,NULL,0);
		633	GetCtrlVal(p1h,P1_CHANNELON,scmd);
		634	dataon = strtoul (scmd,NULL,0);
		635	chip =data/36;
		636	ch =data%36;
		637	sprintf(scmd,"channel");
		638	case 2:
		639	GetCtrlVal(p1h,P1_ASICPAR,scmd);
		640	if (strlen(scmd)) cmd = sa02GetAsicCode(scmd,&asicpar, &asicshft);
		641
		642	break;
		643	}
		644
		645
		646	if (remap) {
		647	data = sa02MuxMap(data);
		648	sa02Printf("MUX %d\n",data);
		649	}
		650
		651	GetCtrlVal(p1h,P1_TPENB,&tpenb);
		652	//ReplaceAxisItem (p1h, P1_GRAPH2D, VAL_LEFT_YAXIS, 0, scmd, data0);
		653
		654	if (strlen(filename)>0) {
		655	if (sa02Verbose) {
		656	sa02Printf("Data in the file:%s\n", filename);
		657	}
		658	if (gFp) {
		659	fp=gFp;
		660	} else {
		661	if (append) {
		662	fp=fopen(filename,"ab");
		663	} else {
		664	fp=fopen(filename,"wb");
		665	}
		666	}
		667	output=1;
		668	// run header
		669	runinfo.id= RUNINFO_ID; // run record ID
		670	runinfo.len= sizeof(runinfo);
		671	runinfo.cmd= cmd;
		672	runinfo.x0 = data;
		673	runinfo.dx = dstep;
		674	runinfo.nx = neve;
		675	runinfo.chip= chip;
		676	runinfo.ch = ch;
		677	runinfo.neve= toread;
		678	runinfo.writemode= towrite;
		679	sa02Printf("RUNINFO x0=%d nx=%d dx=%d\n", runinfo.x0,runinfo.dx,runinfo.nx);
		680	nbtotal+=fwrite(&runinfo, 1,sizeof(runinfo),fp); //gzip
		681	} else {
		682	if (sa02Verbose) {
		683	sa02Printf("Data are not written to the file!\n");
		684	}
		685	}
		686
		687	if (!neve & (towrite \|\| toread) ) {
		688	neve=1;
		689	}
		690
		691
		692	time(&t);
		693	tstart=t;
		694	told=t;
		695	t0 = Timer();
		696
		697
		698	title[0] = 0;
		699	for (i=0; i<4; i++) {
		700	int febon=0;
		701	Sa02TestPulseEnable(i, tpenb); // Enable/disable test pulse
		702	sa02GetSerial(i, serial);
		703	GetCtrlVal(p1h,hapd_onoff[i], &febon);
		704	if (strstr(serial,"0x00000000000000")!=NULL && febon) {
		705	char txt[0xFF];
		706	sprintf(txt, "FEB %d not connected or firmware not loaded? Serial number error! Switch Off FEB!",i);
		707	MessagePopup ("Error", txt);
		708	return -1;
		709	}
		710	sprintf(title,"%s FEB%d=%s", title, i, serial);
		711	}
		712
		713	///////////////////////////////////////////////////////////////
		714	int icfa_visible=0;
		715	int icfa_add=0;
		716	GetPanelAttribute (p6h, ATTR_VISIBLE, &icfa_visible);
		717	GetCtrlVal (p6h, MINIRICH_ADD, &icfa_add);
		718	if (icfa_visible) {
		719	icfa_Init();
		720	icfa_Histo();
		721	}
		722	///////////////////////////////////////////////////////////////
		723	SetCtrlAttribute (p1h, P1_GRAPH2D, ATTR_LABEL_TEXT , title);
		724	H2DInit(h2, "h2d",title, 144*4, 0,1,neve,data0, dstep);
		725	H2DSetTitleY(h2,scmd);
		726
		727	sa02Printf("H2D nx=%d ny=%d i=%d neve=%d\n", H2DGetNbinsX(h2),H2DGetNbinsY(h2), i, neve);
		728
		729
		730	plot2d(h2,1);
		731	for (i=0; i<neve; i++) {
		732	int nb = sizeof(uint32_t);
		733	int count=0;
		734
		735
		736	for (board=0; board<4; board++) {
		737
		738	switch (towrite) {
		739	case 1: {
		740	rdata[count+2]= data;
		741	rdata[count+3]= sa02Cmd(board, cmd, data, chip, ch,1,response);
		742	count+=module_header(cmd,&rdata[count],2 );
		743	break;
		744	}
		745	case 2: {
		746	uint32_t datal = asicpar & (data << asicshft);
		747	rdata[count+2] = data;
		748	rdata[count+3] = sa02AsicWrite(board, cmd, datal, chip, ch, asicpar,asicshft);
		749	count+=module_header(cmd ,&rdata[count],2); // recid cmd
		750	break;
		751	}
		752	case 3: {
		753	rdata[count+2] = chip*36+ch;
		754	rdata[count+3] = sa02AsicWrite(board, cmd, dataon, chip, ch, asicpar,asicshft); // switch on the channel
		755	count+=module_header(cmd ,&rdata[count],2); // recid cmd
		756	break;
		757	}
		758	}
		759	if (towrite==3) {
		760	SetCtrlVal(p1h,P1_SETVALUE, chip*36+ch );
		761	} else {
		762	SetCtrlVal(p1h,P1_SETVALUE, data);
		763	}
		764
		765
		766
		767	}
		768
		769	Sa02SetNeve(toread);
		770	sa02Reset();
		771
		772	// for ( j=0; j< toread; j++)
		773	{
		774	int eventerror = 0;
		775
		776	if ( (count +2 +dsize) >= maxsize) {
		777
		778	maxsize*=2;
		779	sa02Printf("Increasing data buffer to %d elements\n", maxsize);
		780	rdata=realloc(rdata ,sizeof(uint32_t)*maxsize);
		781	}
		782
		783	do {
		784	if (sendswtrg == 1) Sa02SoftwareTrigger();
		785	nb = sa02Read(mask, &rdata[count+2] );
		786	} while ( nb==0 && !ctrl_c);
		787	if (nb==0) sa02Printf("nb==0 LINE=%d\n",__LINE__);
		788
		789	if (testfixeddata && nb>0) {
		790	int len = nb / sizeof(uint32_t);
		791	for (ir=0; ir<len; ir++) {
		792	if ( rdata[count+2+ir]!=fixeddata ) {
		793	time(&t);
		794	sa02Printf("INSERT INTO fixederror VALUES ( '%d', '%d','%d','%d','0x%08x','0x%08x' ) \n", t, t-tstart, i*toread+j, ir, rdata[count+2+ir], fixeddata );
		795	eventerror++;
		796	}
		797	}
		798	}
		799	if (eventerror) {
		800	readerror++;
		801	if (readerror==3) {
		802	ctrl_c = 1;
		803	system("date >> firmware.lock");
		804	}
		805	} else {
		806	readerror= 0;
		807	}
		808
		809	for (ich=0; ich<144*4; ich++) {
		810	int xch = (143 - ich%144) + ich/144*144;
		811	H2DFillBin(h2, xch,i,rdata[count+2+ich]);
		812	}
		813
		814	if (icfa_visible) icfa_Event(&rdata[count+2], icfa_add );
		815
		816	/*
		817	for (ich=0; ich<144; ich++) {
		818	// id=(35-ich/4)+gBoardNumber*36;
		819	// shft=(ich%4)*8;
		820	id=(17-ich/8)+sa02BoardNumber*18;
		821	shft=(ich%8)*4;
		822
		823	// if ( rdata[count+2+id] & (0xFF <<shft) ) {
		824	if ( rdata[count+2+id] & (0xF <<shft) ) {
		825	H2DFillBin(h2, ich,i,1);
		826	}
		827	if (sa02Verbose>2) {
		828	sa02Printf("%02X ",(rdata[count+2+id]>> shft)& 0xF );
		829	// sa02Printf("%02X ",(rdata[count+2+id]>> shft)& 0xFF );
		830	}
		831	}
		832	*/
		833
		834	if (sa02Verbose>2) sa02Printf("\n" );
		835	if (nb>=0) count+=module_header(0x3,&rdata[count],nb/sizeof(uint32_t)); // recid 0x3
		836
		837	if (ctrl_c) {
		838	sa02Printf("ctrl_c detected ....\n");
		839	break;
		840	}
		841
		842	time(&t);
		843	if (t!=told ) {
		844	double done= (double) (i)/neve;
		845	EstimatedFinish(p1h, P1_PROGRESS, P1_ETA, tstart, done);
		846	plot2d(h2,i-1);
		847	GetPanelAttribute (p6h, ATTR_VISIBLE, &icfa_visible);
		848	if (icfa_visible) icfa_Draw();
		849	SetCtrlVal(p1h,P1_CUREVE, j);
		850	sa02Printf("%d events in %2.2f min (%d s) TIMEOUTS=%d %s",ncount, (double)(t-tstart)/60.,t-tstart, nerrors, ctime(&t));
		851	}
		852	if (aborttimeout && (t-tstart)>aborttimeout) {
		853	sa02Printf("Abort timeout reached ....\n");
		854	ctrl_c=1;
		855	break;
		856	}
		857	told=t;
		858	if (nb==0) {
		859	nerrors++;
		860	//j--; /// kako potem pride cez zeljeno stevil ozadetkov?
		861	} else {
		862	ncount++;
		863	}
		864	}
		865	if (externalcmd) {
		866	char ecmd[256];
		867	sprintf(ecmd,"%s %u %u %u %u",externalcommand,(unsigned int) tstart,data, rdata[2], rdata[3]);
		868	if (sa02Verbose) {
		869	sa02Printf("Executing external command %s\n",ecmd);
		870	}
		871	system(ecmd);
		872	}
		873
		874	if (output && Random(0,1)<fraction) {
		875	evtrec.id = EVTREC_ID;
		876	evtrec.len=count*sizeof(uint32_t)+ sizeof(evtrec);
		877	evtrec.time= (uint32_t) time(NULL);
		878	evtrec.nev=i;
		879	nb = (int) fwrite( &evtrec, 1, sizeof(evtrec),fp); //gzip
		880	if (count) {
		881	nb+= (int) fwrite(&rdata[0],1,count*sizeof(uint32_t),fp); //gzip
		882	}
		883	if (nb!= (int) evtrec.len) {
		884	sa02Printf("Error writing! %d!=%d\n",nb,evtrec.len);
		885	}
		886	nbtotal+= nb;
		887	}
		888
		889	if (sa02Verbose==1) {
		890	sa02Printf("[%d/%d] %u \t", i,count, (unsigned int) time(NULL));
		891	PrintData(rdata,count);
		892	}
		893	if (towrite ==3) {
		894	sa02AsicWrite(board, cmd, dataoff, chip, ch, asicpar, asicshft);
		895	ch += dstep;
		896	if (ch>35) {
		897	ch-=36;
		898	chip++;
		899	}
		900	} else {
		901	data += dstep;
		902	}
		903	if (ctrl_c ) {
		904	if (!testfixeddata) {
		905	sa02Printf("Ctrl+C Program interrupted ....\n");
		906	}
		907	break;
		908	}
		909	}
		910	plot2d(h2, i-1);
		911	if (icfa_visible) icfa_Draw();
		912
		913	if (output) {
		914	sprintf(scmd,"channel;daqtime=%f", Timer()-t0 );
		915	H2DSetTitleX(h2,scmd);
		916	H2DWrite2File(h2,fp);
		917	if (!gFp) {
		918	fclose(fp);
		919	}
		920	}
		921	if (sa02Verbose>1) sa02Printf("%d bytes written to file %s\n", nbtotal, filename);
		922	time(&t);
		923	if (toread && !testfixeddata) sa02Printf("%d events in %2.2f min (%f s) TIMEOUTS=%d %s",ncount, (double)(Timer()-t0)/60.,Timer()-t0, nerrors, ctime(&t));
		924	free(rdata);
		925
		926	return 0;
		927	}
		928
		929	int CVICALLBACK quit (int panel, int event, void *callbackData,
		930	int eventData1, int eventData2) {
		931	switch (event) {
		932	case EVENT_CLOSE:
		933	// Stop timer callbacks
		934	SuspendTimerCallbacks();
		935	QuitUserInterface (0);
		936	break;
		937	}
		938	return 0;
		939	}
		940
		941	int CVICALLBACK Exit (int panel, int control, int event,
		942	void *callbackData, int eventData1, int eventData2) {
		943	switch (event) {
		944	case EVENT_COMMIT:
		945	quit(0,0,NULL,0,0);
		946	exit(0);
		947	}
		948	return 0;
		949	}
		950
		951	int SetParametersFromFile( const char *fname) {
		952	uint32_t gdata;
		953	uint32_t cdata;
		954
		955	sa02AsicGlobalRegister greg = (sa02AsicGlobalRegister ) &gdata ;
		956	sa02AsicChannelRegister creg = (sa02AsicChannelRegister ) &cdata ;
		957	unsigned short cregdata[81444];
		958	unsigned short gregdata[744];
		959	#define NDIM 400
		960	int ndim=NDIM;
		961	char line[NDIM];
		962	char cmd[NDIM];
		963	char sasic[NDIM];
		964	char v0[NDIM];
		965	char v1[NDIM];
		966	int asic=0, ch=0;
		967	int gval=0, cval=0;
		968	int board=0;
		969	int row=0;
		970	uint32_t sa02code;
		971	int i;
		972	ssize_t size;
		973	FILE *fp = NULL;
		974	if ( GetFileInfo(fname,&size) ) fp = fopen(fname,"r");
		975	if (!fp) {
		976	sa02Printf("Error! Cannot open file %s\n",fname);
		977	return -1;
		978	}
		979	for (i=0; i<81444; i++) {
		980	cregdata[i]=0;
		981	}
		982	for (i=0; i<744; i++) {
		983	gregdata[i]=0;
		984	}
		985	gdata=0;
		986	cdata=0;
		987	ResetTextBox(p3h,P3_FPGAPAR,"");
		988	while (fgets(line,ndim,fp)!=NULL) {
		989	int nb = sscanf(line,"%s%s%s%s",cmd,sasic,v0,v1);
		990	if (nb<1 \|\| cmd[0]=='#') {
		991	continue;
		992	}
		993	asic = strtoul (sasic,NULL,0);
		994	ch = strtoul (v0,NULL,0);
		995	gval = strtoul (v0,NULL,0);
		996	cval = strtoul (v1,NULL,0);
		997	if (sa02Verbose>2) {
		998	sa02Printf("%d %s",nb,line);
		999	}
		1000	sa02code = sa02GetCmdCode(cmd);
		1001	if (strcmp(cmd,"MUXASIC")==0) {
		1002	asic = sa02MuxMap(asic);
		1003	}
		1004	switch (nb) {
		1005	case 1: {
		1006	if ( sa02code ) {
		1007	SetCtrlVal(p3h,P3_FPGAPAR,line);
		1008
		1009	break;
		1010	}
		1011	break;
		1012	}
		1013	case 2: {
		1014	if ( sa02code ) {
		1015	SetCtrlVal(p3h,P3_FPGAPAR,line);
		1016
		1017	break;
		1018	}
		1019	if (strcmp(cmd,"param_board")==0) {
		1020	board= asic;
		1021	}
		1022	if (strcmp(cmd,"load_global")==0) {
		1023	row= asic+1;
		1024	greg->id=13;
		1025	/*
		1026	SetTableCellVal (p3h, P3_GREG, MakePoint (1,row), greg->phasecmps);
		1027	SetTableCellVal (p3h, P3_GREG, MakePoint (2,row), greg->gain);
		1028	SetTableCellVal (p3h, P3_GREG, MakePoint (3,row), greg->shapingtime);
		1029	SetTableCellVal (p3h, P3_GREG, MakePoint (4,row), greg->comparator);
		1030	SetTableCellVal (p3h, P3_GREG, MakePoint (5,row), greg->vrdrive);
		1031	SetTableCellVal (p3h, P3_GREG, MakePoint (6,row), greg->monitor);
		1032	SetTableCellVal (p3h, P3_GREG, MakePoint (7,row), greg->id);
		1033	*/
		1034	gregdata[(board4+asic)7] = greg->phasecmps;
		1035	gregdata[(board4+asic)7+1] = greg->gain;
		1036	gregdata[(board4+asic)7+2] = greg->shapingtime;
		1037	gregdata[(board4+asic)7+3] = greg->comparator;
		1038	gregdata[(board4+asic)7+4] = greg->vrdrive;
		1039	gregdata[(board4+asic)7+5] = greg->monitor;
		1040	gregdata[(board4+asic)7+6] = greg->id;
		1041
		1042	break;
		1043	}
		1044	break;
		1045	}
		1046	case 3: {
		1047	if ( sa02code) {
		1048	SetCtrlVal(p3h,P3_FPGAPAR,line);
		1049	break;
		1050	}
		1051	if (strcmp(cmd,"param_global")==0) {
		1052	gdata = 0;
		1053	break;
		1054	}
		1055	if (strcmp(cmd,"phasecmps")==0) {
		1056	greg->phasecmps = gval;
		1057	break;
		1058	}
		1059	if (strcmp(cmd,"gain") ==0) {
		1060	greg->gain = gval;
		1061	break;
		1062	}
		1063	if (strcmp(cmd,"shapingtime")==0) {
		1064	greg->shapingtime = gval;
		1065	break;
		1066	}
		1067	if (strcmp(cmd,"comparator")==0) {
		1068	greg->comparator = gval;
		1069	break;
		1070	}
		1071	if (strcmp(cmd,"vrdrive")==0) {
		1072	greg->vrdrive = gval;
		1073	break;
		1074	}
		1075	if (strcmp(cmd,"monitor")==0) {
		1076	greg->monitor = gval;
		1077	break;
		1078	}
		1079	if (strcmp(cmd,"load_ch")==0) {
		1080	row = board144+asic36+ch+1;
		1081	/*
		1082	SetTableCellVal (p3h, P3_CREG, MakePoint (1,row), asic);
		1083	SetTableCellVal (p3h, P3_CREG, MakePoint (2,row), ch);
		1084	SetTableCellVal (p3h, P3_CREG, MakePoint (3,row), creg->decaytime);
		1085	SetTableCellVal (p3h, P3_CREG, MakePoint (4,row), creg->offset);
		1086	SetTableCellVal (p3h, P3_CREG, MakePoint (5,row), creg->fineadj_unipol);
		1087	SetTableCellVal (p3h, P3_CREG, MakePoint (6,row), creg->fineadj_diff);
		1088	SetTableCellVal (p3h, P3_CREG, MakePoint (7,row), creg->tpenb);
		1089	SetTableCellVal (p3h, P3_CREG, MakePoint (8,row), creg->kill);
		1090	*/
		1091
		1092	cregdata[(row -1)*8] = (unsigned short) asic;
		1093	cregdata[(row -1)*8+1] = (unsigned short) ch;
		1094	cregdata[(row -1)*8+2] = creg->decaytime;
		1095	cregdata[(row -1)*8+3] = creg->offset;
		1096	cregdata[(row -1)*8+4] = creg->fineadj_unipol;
		1097	cregdata[(row -1)*8+5] = creg->fineadj_diff;
		1098	cregdata[(row -1)*8+6] = creg->tpenb;
		1099	cregdata[(row -1)*8+7] = creg->kill;
		1100	cdata=0;
		1101	break;
		1102	}
		1103	if (strcmp(cmd,"select")==0) {
		1104	sa02Printf ("%s not implemeted yet\n", cmd);
		1105	break;
		1106	}
		1107	break;
		1108	}
		1109	case 4: {
		1110	if (strcmp(cmd,"param_ch")==0) {
		1111	cdata = 0;
		1112	break;
		1113	}
		1114	if (strcmp(cmd,"decaytime")==0) {
		1115	creg->decaytime = cval;
		1116	break;
		1117	}
		1118	if (strcmp(cmd,"offset")==0) {
		1119	creg->offset = cval;
		1120	break;
		1121	}
		1122	if (strcmp(cmd,"fineadj_unipol")==0) {
		1123	creg->fineadj_unipol = cval;
		1124	break;
		1125	}
		1126	if (strcmp(cmd,"fineadj_diff")==0) {
		1127	creg->fineadj_diff = cval;
		1128	break;
		1129	}
		1130	if (strcmp(cmd,"tpenb")==0) {
		1131	creg->tpenb = cval;
		1132	break;
		1133	}
		1134	if (strcmp(cmd,"kill")==0) {
		1135	creg->kill = cval;
		1136	break;
		1137	}
		1138	break;
		1139	}
		1140	}
		1141
		1142	}
		1143	fclose(fp);
		1144	SetTableCellRangeVals (p3h, P3_CREG, MakeRect (1, 1, 144*4, 8), cregdata, VAL_ROW_MAJOR);
		1145	SetTableCellRangeVals (p3h, P3_GREG, MakeRect (1, 1, 4*4, 7) , gregdata, VAL_ROW_MAJOR);
		1146
		1147	sa02Printf("Parameters loaded from file %s to Parameter Panel \n", fname);
		1148	return 0;
		1149	}
		1150
		1151	void CVICALLBACK MenuCB(int menubar, int menuItem, void *callbackData, int panel) {
		1152	switch (menuItem) {
		1153	case MENU_OPERATIO_CAEN_V729:
		1154	DisplayPanel(p4h);
		1155	break;
		1156	case MENU_OPERATIO_SA02CFG :
		1157	DisplayPanel(p3h);
		1158	break;
		1159	case MENU_OPERATIO_2DSCAN:
		1160	DisplayPanel(p2h);
		1161	break;
		1162	case MENU_OPERATIO_LASER:
		1163	DisplayPanel(p5h);
		1164	break;
		1165	case MENU_MINIRICH:
		1166	DisplayPanel(p6h);
		1167	break;
		1168	case MENU_OPERATIO_EXIT :
		1169	quit(0,0,NULL,0,0);
		1170	exit(0);
		1171	//loop_on=0;
		1172	break;
		1173	case MENU_HELP :
		1174	sa02Help();
		1175	break;
		1176	}
		1177	}
		1178
		1179	int CVICALLBACK daq_readonly(void *functionData) {
		1180	int h2=0;
		1181	uint32_t trglen;
		1182	uint32_t data[10000];
		1183	uint16_t mask;
		1184	//int ison;
		1185	//int fdata= (int ) functionData;
		1186	int nbit,neve,nb,ch,i,j,sendswtrg;
		1187
		1188	time_t t,told, tstart;
		1189	//int gBoardNumber=0;
		1190	int ploteachevent =0;
		1191
		1192	GetCtrlVal(p1h,P1_PLOTEACHEVENT, &ploteachevent);
		1193	GetCtrlVal(p1h,P1_TOREAD , &neve);
		1194	GetCtrlVal(p1h,P1_NSLIX , &nbit);
		1195	if (nbit>7) {
		1196	nbit=7;
		1197	}
		1198	GetCtrlVal(p1h,P1_SENDSWTRIG,&sendswtrg);
		1199	GetCtrlVal(p1h,P1_INTTRGLEN, &trglen);
		1200
		1201	mask=GetConnectedFebMask();
		1202	Sa02SelectTriggerWithMaskAndLength (sendswtrg, mask, trglen);
		1203	Sa02SetNeve(2);
		1204
		1205	H2DInit(h2,"hbit","Bit Occupancy", 144*4, 0,1,8,0, 1);
		1206	H2DSetTitleX(h2,"channel");
		1207	H2DSetTitleY(h2,"Data bit");
		1208	time(&t);
		1209	tstart=t;
		1210	told=t;
		1211	for ( j=0; j< neve; j++) {
		1212	do {
		1213	if (sendswtrg==1) Sa02SoftwareTrigger();
		1214	nb = sa02Read(mask, data );
		1215	} while ( nb==0 && !ctrl_c);
		1216	if (nb==0) sa02Printf("nb==0 LINE=%d\n",__LINE__);
		1217
		1218	if (ctrl_c==1) break;
		1219
		1220	for (ch=0; ch<144*4; ch++) {
		1221	int board = ch/144;
		1222	int xch = (143 - ch%144) + board *144;
		1223	for (i=0; i<8; i++) if (data[ch] & (1<<i) ) H2DFillBin(h2,xch,i,1);
		1224	}
		1225	/*
		1226	for (ch=0; ch<144*4; ch++)
		1227	{
		1228	id=(35-ch/4)+gBoardNumber*36;
		1229	shft=(ch%4)*8;
		1230	for (i=0; i<8; i++)
		1231	{
		1232	if (data[id] & (1<<(i+shft)) )
		1233	{
		1234	H2DFillBin(h2,ch,i,1);
		1235	}
		1236	}
		1237	if (sa02Verbose>2)
		1238	{
		1239	sa02Printf("%02X ",(data[id]>> shft)& 0xFF );
		1240	}
		1241	}
		1242	*/
		1243
		1244	if (sa02Verbose>2) {
		1245	sa02Printf("\n" );
		1246	}
		1247
		1248	time(&t);
		1249	if (t!=told \|\| ploteachevent) {
		1250	sa02Printf("%d events in %2.2f min (%d s) %s",j, (double)(t-tstart)/60.,t-tstart, ctime(&t));
		1251	GetCtrlVal(p1h,P1_NSLIY,&nbit);
		1252	plot2d(h2, nbit);
		1253	GetCtrlVal(p1h,P1_PLOTEACHEVENT, &ploteachevent);
		1254	SetCtrlVal(p1h,P1_CUREVE, j);
		1255	ProcessSystemEvents ();
		1256	ProcessSystemEvents ();
		1257	}
		1258
		1259	told=t;
		1260
		1261	}
		1262
		1263	plot2d(h2, nbit);
		1264	SetCtrlVal(p1h,P1_CUREVE, j);
		1265
		1266	return 0;
		1267	}
		1268
		1269	int CVICALLBACK LoadParameters (int panel, int control, int event,
		1270	void *callbackData, int eventData1, int eventData2) {
		1271	char fname[0xFF];
		1272	uint16_t mask;
		1273	switch (event) {
		1274	case EVENT_COMMIT:
		1275	mask=GetConnectedFebMask();
		1276	sa02Printf("LoadParameters 0x%0x\n", mask);
		1277	GetCtrlVal(p3h, P3_INPUTFILE, fname);
		1278	GetCtrlVal(p1h,P1_BOARDTYPE,&sa02BoardType);
		1279	SetCtrlAttribute (panel, control, ATTR_DIMMED, 1);
		1280	sa02LoadParametersFromFile(fname, mask);
		1281	SetCtrlAttribute (panel, control, ATTR_DIMMED, 0);
		1282
		1283	break;
		1284	}
		1285	return 0;
		1286	}
		1287
		1288	int SlowControl(uint32_t board, FILE *fp) {
		1289	uint32_t data;//,step,cmd;//,response[2]= {0,0};
		1290	int chip,channel,i;
		1291	//double doubleval;
		1292	char saddress[0xFF];
		1293	double sdata[20];
		1294
		1295	chip=0;
		1296	channel=0;
		1297	data=0;
		1298
		1299	GetCtrlVal(p1h,P1_BOARDTYPE,&sa02BoardType);
		1300	sa02Status(board,saddress,sdata);
		1301	SetCtrlVal(p1h,fpga_serials[board],saddress);
		1302	if (fp) {
		1303	fprintf(fp,"<slowc>\n<id>%d</id>\n", board );
		1304	fprintf(fp,"<dna>%s</dna>\n",saddress );
		1305	for (i=0; i<12; i++) fprintf(fp,"<%s>%f</%s>\n",slowcname[i],sdata[i],slowcname[i] );
		1306	fprintf(fp,"</slowc>\n" );
		1307	}
		1308	PlotStripChart (p1h, chart_control[board], sdata, 12, 0, 0, VAL_DOUBLE);
		1309	return 0;
		1310	}
		1311
		1312
		1313	int WriteChannelParameters ( int offset, int fine_offset, int tpenb) {
		1314
		1315	uint32_t response[2]= {0,0};
		1316	uint32_t cdata;
		1317
		1318	sa02AsicChannelRegister creg = (sa02AsicChannelRegister ) &cdata ;
		1319	unsigned int i=0, j=0;
		1320	int row=0;
		1321	unsigned short val,asic,ch, board;
		1322	uint16_t mask=GetConnectedFebMask();
		1323	for (j=0; j<144*4; j++) {
		1324	i = j%144;
		1325	board = (unsigned short) j/144;
		1326	asic=(unsigned short )(i/36);
		1327	ch=(unsigned short )(i%36);
		1328	row=j+1;
		1329	GetTableCellVal (p3h, P3_CREG, MakePoint (1,row), &asic);
		1330	GetTableCellVal (p3h, P3_CREG, MakePoint (2,row), &ch);
		1331	GetTableCellVal (p3h, P3_CREG, MakePoint (3,row), &val);
		1332	creg->decaytime=val;
		1333	creg->offset = offset;
		1334	creg->fineadj_unipol = fine_offset;
		1335	GetTableCellVal (p3h, P3_CREG, MakePoint (6,row), &val);
		1336	creg->fineadj_diff = val;
		1337	creg->tpenb = tpenb;
		1338	//sa02Printf("===%d %d\n",i, tpenb);
		1339	GetTableCellVal (p3h, P3_CREG, MakePoint (8,row), &val);
		1340	creg->kill = val;
		1341	creg->unused=0;
		1342	if ( mask &(1<<board)) sa02Cmd(board,SA0x_ASIC0_CREG, cdata, asic, ch,1,response);
		1343
		1344	if (ctrl_c) {
		1345	break;
		1346	}
		1347	}
		1348	return 0;
		1349	}
		1350
		1351	int FebTestAna(void) {
		1352	int current_run;
		1353	char cmdCommand[0xFF];
		1354	current_run = GetRunNumberFromFile("current_run.txt");
		1355	sprintf(cmdCommand ,"C:/root/bin/root.exe \"../macros/febreport.cxx(\\\"data\\\", %d )\"", current_run);
		1356	sa02Printf("%s\n",cmdCommand);
		1357	LaunchExecutable(cmdCommand);
		1358	return 0;
		1359	}
		1360
		1361	int FebTest(void) {
		1362	int board=0, j=0, value, step;
		1363
		1364	FILE *fp;
		1365	int ndim=400;
		1366	char line[ndim];
		1367	int current_run=1;
		1368	time_t t;
		1369	int start;
		1370	int addheader=1;
		1371	char filename[0xFF];
		1372	char cmdCommand[0xFF];
		1373
		1374	uint32_t mask=GetConnectedFebMask();
		1375
		1376	LoadParameters(p3h, P3_LOADPAR,EVENT_COMMIT,NULL,0,0);
		1377
		1378
		1379	fp = fopen ("current_run.txt","r");
		1380	if (fp) {
		1381	if (fgets(line,ndim,fp)!=NULL) current_run=atoi(line)+1;
		1382	fclose(fp);
		1383	fp= NULL;
		1384	}
		1385
		1386	sprintf(line,"data\\febtest_%04d.dat",current_run );
		1387	SetCtrlVal(p1h,P1_OUTPUTFILE, line);
		1388
		1389	SetCtrlVal(p1h,P1_SENDSWTRIG,3 ); // set internal trigger
		1390	SendTriggerTypeCB(p1h,P1_TEST, EVENT_COMMIT,NULL, 0,0);
		1391
		1392	ThresholdLinearityCB (p1h, P1_THRVSADC, EVENT_COMMIT, NULL, 0, 0 );
		1393
		1394	GetCtrlVal(p1h,P1_OUTPUTFILE, filename);
		1395	fp = fopen(line, "ab");
		1396	if(fp) {
		1397	for (board=0; board<4; board++) if ( mask &(1<<board)) H1DWrite2File(board,fp);
		1398	fclose(fp);
		1399	}
		1400
		1401
		1402	sprintf(line,"data/febslowc_%04d.xml",current_run );
		1403	// SetCtrlVal(p1h, P1_RUNID, current_run);
		1404	fp = fopen (line,"w");
		1405	fprintf(fp,"<febtest>\n");
		1406	time(&t);
		1407	fprintf(fp,"<time>%s</time>\n", ctime(&t));
		1408
		1409
		1410
		1411	if (!ctrl_c) for (board=0; board<4; board++) {
		1412	if ( mask &(1<<board)) {
		1413	for (j=0; j<10; j++) {
		1414	SlowControl(board,fp);
		1415	ProcessSystemEvents ();
		1416	if (ctrl_c) break;
		1417	}
		1418	}
		1419	if (ctrl_c) break;
		1420	}
		1421
		1422
		1423	fprintf(fp,"</febtest>\n");
		1424	fclose(fp);
		1425
		1426
		1427	fp = fopen ("current_run.txt","w");
		1428	fprintf(fp,"%d\n", current_run);
		1429	fclose(fp);
		1430
		1431
		1432
		1433
		1434
		1435	WriteChannelParameters ( 0,0,0); // Test pulse on all channels
		1436	for (board=0; board<4; board++) if ( mask &(1<<board)) SlowControl(board,fp);
		1437	SetCtrlVal(p1h,P1_TPENB,1); // enable test pulse
		1438
		1439	SetCtrlVal(p1h,P1_DATA, 350);
		1440	SetCtrlVal(p1h,P1_NEVE, 150);
		1441
		1442	GetCtrlVal(p1h,P1_DATA, &start);
		1443
		1444	daq(NULL);
		1445	SetCtrlVal(p1h,P1_TPENB,0); // disable test pulse
		1446
		1447
		1448	// coarse offset
		1449	step=1;
		1450	if (!ctrl_c) for (value=0; value<16; value+=step) {
		1451	if (addheader) {
		1452	iteratorrec.id = ITERATORREC_ID;
		1453	iteratorrec.len = sizeof(iteratorrec);
		1454	iteratorrec.value = value;
		1455	iteratorrec.n = 16;
		1456	iteratorrec.step = step;
		1457	iteratorrec.level = 1;
		1458	GetCtrlVal(p1h,P1_OUTPUTFILE, filename);
		1459	fp = fopen(filename, "ab");
		1460	if(fp) {
		1461	fwrite (&iteratorrec, 1, iteratorrec.len, fp);
		1462	fclose(fp);
		1463	}
		1464	}
		1465
		1466	WriteChannelParameters ( value,0,1);
		1467
		1468	SetCtrlVal(p1h,P1_DATA,start - (value%8) * 13 + (value/8)138 );
		1469	sa02Printf("offset=>%d\n", value);
		1470	daq(NULL);
		1471	if (ctrl_c) break;
		1472	}
		1473
		1474	// fine offset
		1475	if (!ctrl_c) for (value=0; value<16; value+=step) {
		1476	if (addheader) {
		1477	iteratorrec.id = ITERATORREC_ID;
		1478	iteratorrec.len = sizeof(iteratorrec);
		1479	iteratorrec.value = value;
		1480	iteratorrec.n = 16;
		1481	iteratorrec.step = step;
		1482	iteratorrec.level = 1;
		1483	GetCtrlVal(p1h,P1_OUTPUTFILE, filename);
		1484	fp = fopen(filename, "ab");
		1485	if(fp) {
		1486	fwrite (&iteratorrec, 1, iteratorrec.len, fp);
		1487	fclose(fp);
		1488	}
		1489	}
		1490
		1491
		1492	WriteChannelParameters (0, value,1);
		1493
		1494	SetCtrlVal(p1h,P1_DATA, start - (value%8) + (value/8)*8 );
		1495	sa02Printf("offset=>%d\n", value);
		1496	daq(NULL);
		1497	if (ctrl_c) break;
		1498	}
		1499
		1500	SetCtrlVal(p1h,P1_DATA, start);
		1501
		1502	GetCtrlVal(p1h,P1_OUTPUTFILE, filename);
		1503
		1504	sprintf(cmdCommand,"..\\sa02read -i %s -o data\\febtest_%04d.root", filename, current_run);
		1505	sa02Printf("%s\n",cmdCommand);
		1506	LaunchExecutable(cmdCommand);
		1507
		1508	//sprintf(cmdCommand ,"C:/root/bin/root.exe ../macros/febreport.cxx(\\\"data/febtest_%04d.root\\\")", current_run);
		1509	sprintf(cmdCommand ,"C:/root/bin/root.exe \"../macros/febreport.cxx(\\\"data\\\", %d )\"", current_run);
		1510	sa02Printf("%s\n",cmdCommand);
		1511	LaunchExecutable(cmdCommand);
		1512
		1513	sprintf(line,"%s", "test.dat");
		1514	SetCtrlVal(p1h,P1_OUTPUTFILE, line);
		1515	//daq(NULL);
		1516	return 0;
		1517	}
		1518
		1519
		1520	int CVICALLBACK ThresholdLinearityCB (int panel, int control, int event,
		1521	void *callbackData, int eventData1, int eventData2) {
		1522	const int kmax= 1024;
		1523	const int boardmax= 4;
		1524
		1525	switch (event) {
		1526	case EVENT_COMMIT: {
		1527	uint32_t val,retval, board,data,response[2]= {0,0};
		1528	int k;
		1529	int chip,channel;
		1530	double doubleval;
		1531	time_t t,told;
		1532	char title[0xFF];
		1533	char name[0xFF];
		1534	int h1=0;
		1535	uint16_t mask=GetConnectedFebMask();
		1536	chip=0;
		1537	channel=0;
		1538	GetCtrlVal(p1h,P1_BOARDTYPE,&sa02BoardType);
		1539
		1540	for (board=0; board<boardmax; board++) if ( mask &(1<<board)) {
		1541	char serial[0xFF];
		1542	GetCtrlVal(p1h,hapd_serials[board],serial );
		1543	sprintf(title,"VTH1 linearity, position %d sn=%s", board, serial);
		1544	sprintf(name,"vth1_%d", board);
		1545	H1DInit(h1+board, name,title, kmax, 0 ,1);
		1546	H1DSetTitleX(h1+board,"VTH1");
		1547	H1DSetTitleY(h1+board,"ADC(VTH1)");
		1548	SetCtrlAttribute (p1h, P1_GRAPH, ATTR_XNAME, H1DGetTitleX(h1+board) );
		1549	SetCtrlAttribute (p1h, P1_GRAPH, ATTR_YNAME, H1DGetTitleY(h1+board) );
		1550	//SetCtrlAttribute (p1h, P1_GRAPH, ATTR_LABEL_TEXT , H1DGetTitle(h1+board) );
		1551	if (phandle[board]> 0 ) DeleteGraphPlot (p1h, P1_GRAPH, phandle[board], VAL_IMMEDIATE_DRAW);
		1552	phandle[board] = 0;
		1553	}
		1554	for (board=0; board<boardmax; board++) if ( mask &(1<<board)) {
		1555	val=sa02Cmd(board, FEB_MUX, data=0x20, chip, channel ,1,response); // set mux to VTH1
		1556	time(&t);
		1557	told=t;
		1558	if (ctrl_c) break;
		1559	for (k=0; k<kmax; k++) {
		1560	if (ctrl_c) break;
		1561	SetCtrlVal(p1h,P1_SETSINGLEVALUE,k);
		1562	SetCtrlVal(p1h,P1_CUREVE,k);
		1563	retval=sa02Cmd(board, FEB_VTH1 , k , chip, channel ,1, response);
		1564	val=sa02Cmd(board, FEB_ADC_READ, data, chip, channel ,1,response);
		1565	if (sa02BoardType>2)
		1566	doubleval = (2((val & 0xFFF) + 0.5)/0x1000 - 1.) 3.3;
		1567	else
		1568	doubleval = ((val & 0xFFF) + 0.5)/0x1000 * 3.3;
		1569
		1570
		1571	H1DFillBin(h1+board, k, doubleval);
		1572	if (t!=told \|\| k==kmax-1 \|\|k==0 ) {
		1573	H1DDraw(h1+board,p1h, P1_GRAPH, &phandle[board]);
		1574	sa02Printf("[%d] set VTH1=%d ADC(VTH1)= %6.3f V\n",board, k, doubleval);
		1575	SetCtrlVal(p1h,P1_CUREVE, k);
		1576	ProcessSystemEvents ();
		1577	}
		1578	told=t;
		1579	time(&t);
		1580	}
		1581	}
		1582	break;
		1583	}
		1584	}
		1585	return 0;
		1586	}
		1587
		1588
		1589	int CVICALLBACK MultiFpgaWrite (void *functionData) {
		1590	uint32_t val, board,data,step,cmd,response[2]= {0,0};
		1591	char scmd[0xFF],sdata[0xFF];
		1592	int chip, channel;
		1593	char filename[0xFF];
		1594	double delay, doubleval=0, x0, dx;
		1595	int neve,i,daqexe,addheader;
		1596	time_t t,told, tstart;
		1597	FILE *fp;
		1598	//int h2=0;
		1599	int fdata= (int ) functionData;
		1600
		1601	datrec.id = DATREC_ID;
		1602	datrec.len = sizeof(datrec);
		1603	GetCtrlVal(p1h,P1_MULTINEVE , &neve);
		1604	GetCtrlVal(p1h,P1_WAIT , &delay);
		1605	GetCtrlVal(p1h, P1_SINGLEWRITECMD, scmd);
		1606	cmd=sa02GetCmdCode(scmd);
		1607	GetCtrlVal(p1h,P1_BOARDNUMBER, &board);
		1608	GetCtrlVal(p1h,P1_BOARDTYPE,&sa02BoardType);
		1609	GetCtrlVal(p1h, P1_SINGLEDATA, sdata);
		1610	data = strtoul (sdata,NULL,0);
		1611	// if (strcmp(scmd,"MUXASIC")==0) {
		1612	// data = sa02MuxMap(data);
		1613	// sa02Printf("MUX %d\n",data);
		1614	// }
		1615	GetCtrlVal(p1h, P1_SINGLEDATA, sdata);
		1616	data = strtoul (sdata,NULL,0);
		1617	x0=(double)data;
		1618	GetCtrlVal(p1h, P1_DSTEP0, &step);
		1619	dx=(double)step;
		1620	GetCtrlVal(p1h,P1_SINGLECHIP,&chip);
		1621	GetCtrlVal(p1h,P1_SINGLECHANNEL,&channel);
		1622	if (fdata[0]==P1_FPGAWRITE) {
		1623	neve=1;
		1624	}
		1625	GetCtrlVal(p1h,P1_DAQEXE,&daqexe);
		1626	GetCtrlVal(p1h,P1_ADDHEADER,&addheader);
		1627	time(&t);
		1628	tstart=t;
		1629	told=t;
		1630	if (addheader) {
		1631	iteratorrec.id = ITERATORREC_ID;
		1632	iteratorrec.len = sizeof(iteratorrec);
		1633	iteratorrec.value = data;
		1634	iteratorrec.n = neve;
		1635	iteratorrec.step = step;
		1636	iteratorrec.level = 2;
		1637	GetCtrlVal(p1h,P1_OUTPUTFILE, filename);
		1638	fp = fopen(filename, "ab");
		1639	if(fp) {
		1640	fwrite (&iteratorrec, 1, iteratorrec.len, fp);
		1641	fclose(fp);
		1642	}
		1643	}
		1644	for (i=0; i<neve; i++) {
		1645	SetCtrlVal(p1h,P1_SETSINGLEVALUE,data);
		1646	SetCtrlVal(p1h,P1_CUREVE,i);
		1647	val=sa02Cmd(board, cmd, data, chip, channel ,1, response);
		1648	if (addheader) {
		1649	datrec.cmd =cmd;
		1650	datrec.data =data;
		1651	datrec.chip =chip;
		1652	datrec.channel=channel;
		1653	datrec.retval =val;
		1654	GetCtrlVal(p1h,P1_OUTPUTFILE, filename);
		1655	fp = fopen(filename, "ab");
		1656	if(fp) {
		1657	fwrite (&datrec, 1, datrec.len, fp);
		1658	fclose(fp);
		1659	}
		1660	}
		1661	switch (cmd & (~ FEB_RO)) {
		1662	case FEB_ADC_READ:
		1663	case FEB_ADC_RESET:
		1664	doubleval = ((val & 0xFFF) + 0.5)/0x1000 * 3.3;
		1665	sa02Printf("ADC %f, 0x%08x\n", doubleval, val ) ;
		1666	break;
		1667	case FEB_TMON1:
		1668	case FEB_TMON0:
		1669	doubleval = ( (val >>2 ) & 0xFFF ) * 0.0625;
		1670	if (val&0x4000) {
		1671	doubleval=-doubleval;
		1672	}
		1673	sa02Printf("TMON %f 0x%x\n",doubleval, val ) ;
		1674	break;
		1675	case FEB_VTH1:
		1676	case FEB_VTH2:
		1677	doubleval = (val & 0xFFFF );
		1678	if (cmd & 1)
		1679	val=0x20;
		1680	else
		1681	val=0x30;
		1682	val=sa02Cmd(board, FEB_MUX, val, 0, 0 ,1,response);
		1683	val=sa02Cmd(board, FEB_ADC_READ, 0, 0, 0, 1,response);
		1684	if (sa02BoardType>2)
		1685	doubleval = (2((val & 0xFFF) + 0.5)/0x1000 - 1.) 3.3;
		1686	else
		1687	doubleval = ((val & 0xFFF) + 0.5)/0x1000 * 3.3;
		1688	sa02Printf("%5d %6.3f\n",data, doubleval);
		1689	break;
		1690	case SA0x_ASIC0_GREG:
		1691	if (cmd & FEB_RO) {
		1692	sa02PrintGREG(&val,"Returned GREG data->");
		1693	}
		1694	break;
		1695	case SA0x_ASIC0_CREG:
		1696	if (cmd & FEB_RO) {
		1697	sa02PrintCREG(&val,"Returned CREG data->");
		1698	}
		1699	break;
		1700	default:
		1701	sa02Printf("0x%08X\n",val);
		1702	// break;
		1703	}
		1704	datay[i]=doubleval;
		1705	if (delay>0 && fdata[0]==P1_MULTIFPGAWRITE) {
		1706	Delay(delay);
		1707	}
		1708	if (daqexe) {
		1709	daq(NULL);
		1710	}
		1711	if (ctrl_c) {
		1712	break;
		1713	}
		1714	if (t!=told ) {
		1715	plot1d(i,x0,dx);
		1716	SetCtrlVal(p1h,P1_CUREVE, i);
		1717	ProcessSystemEvents ();
		1718	}
		1719	data+=step;
		1720	told=t;
		1721	time(&t);
		1722	}
		1723	plot1d(i,x0,dx);
		1724	SetCtrlVal(p1h,P1_CUREVE, i);
		1725	return 0;
		1726	}
		1727
		1728	int CVICALLBACK SendSEUTRigger (int panel, int control, int event,
		1729	void *callbackData, int eventData1, int eventData2) {
		1730
		1731	switch (event) {
		1732	case EVENT_COMMIT:
		1733	Sa02SEUTrigger();
		1734	break;
		1735	}
		1736	return 0;
		1737	}
		1738
		1739	int CVICALLBACK FSelect (int panel, int control, int event,
		1740	void *callbackData, int eventData1, int eventData2) {
		1741	int status,fcontrol = 0;
		1742	char pathName[MAX_PATHNAME_LEN];
		1743	char defName[MAX_PATHNAME_LEN];
		1744	char fileMessage[100] = "";
		1745	switch (event) {
		1746	case EVENT_COMMIT:
		1747	switch (control) {
		1748	case P3_FSELECT:
		1749	fcontrol=P3_INPUTFILE;
		1750	strcpy(fileMessage,"Select Parameter file");
		1751	break;
		1752	case P3_PTSFSELECT:
		1753	fcontrol=P3_PTSFIRMWARE;
		1754	strcpy(fileMessage,"Select PTS Firmware file");
		1755	break;
		1756	}
		1757	sa02Printf("MAX_PATHNAME_LEN %d\n",MAX_PATHNAME_LEN);
		1758	GetCtrlVal(panel,fcontrol,defName);
		1759	status = FileSelectPopup ("",defName,"",
		1760	fileMessage, VAL_LOAD_BUTTON, 0,
		1761	0, 1, 0, pathName);
		1762	if (status>0)
		1763	SetCtrlVal(panel,fcontrol,pathName);
		1764	break;
		1765	}
		1766	return 0;
		1767	}
		1768
		1769	int CVICALLBACK Verbose (int panel, int control, int event,
		1770	void *callbackData, int eventData1, int eventData2) {
		1771	//int * data;
		1772	switch (event) {
		1773	case EVENT_COMMIT:
		1774	GetCtrlVal(panel,control,&sa02Verbose);
		1775	break;
		1776	}
		1777	return 0;
		1778	}
		1779
		1780	int CVICALLBACK Print (int panel, int control, int event,
		1781	void *callbackData, int eventData1, int eventData2) {
		1782	char dfile[MAX_PATHNAME_LEN];
		1783	char name[MAX_PATHNAME_LEN];
		1784	int h2=0;
		1785	switch (event) {
		1786	case EVENT_COMMIT: {
		1787	int hours, minutes, seconds;
		1788	int month, day, year;
		1789	int id=-1;
		1790	//int bitmap = 0;
		1791	if (panel == p1h) {
		1792	switch (control) {
		1793	case P1_PRINT:
		1794	id= P1_GRAPH;
		1795	sprintf(name,"G");
		1796	break;
		1797	case P1_PRINT2D:
		1798	id= P1_GRAPH2D;
		1799	sprintf(name,"2D");
		1800	break;
		1801	case P1_PRINTX:
		1802	id= P1_GRAPHX;
		1803	sprintf(name,"X");
		1804	break;
		1805	case P1_PRINTY:
		1806	id= P1_GRAPHY;
		1807	sprintf(name,"Y");
		1808	break;
		1809	}
		1810	h2=0;
		1811	} else {
		1812	switch (control) {
		1813	case P2_PRINTXY:
		1814	id= P2_GRAPH_1;
		1815	sprintf(name,"XY");
		1816	break;
		1817	}
		1818	h2=1;
		1819	}
		1820	GetSystemDate (&month,&day ,&year );
		1821	GetSystemTime(&hours, &minutes, &seconds);
		1822	if (id>=0) {
		1823	if( ( (panel == p1h)&&(control == P1_PRINT2D) ) \|\| ((panel == p2h)&&(control == P2_GRAPH_1))) {
		1824	sprintf(dfile ,"data/%d_%d_%d_%d_%d_%s.th2d",year,month,day,hours,minutes, name );
		1825	H2DWrite(h2,dfile,"wb");
		1826	sa02Printf("sizeof H2D %d \n",sizeof(H2D));
		1827	sa02Printf("H2D image saved as %s\n", dfile);
		1828	sprintf(name ,"C:\\root\\bin\\root.exe ..\\macros\\H2Dload.cxx(\\\"%s\\\")", dfile);
		1829	LaunchExecutable(name);
		1830	} else {
		1831	sprintf(dfile ,"data/%d_%d_%d_%d_%d_%s.bmp",year,month,day,hours,minutes, name );
		1832	SaveCtrlDisplayToFile (panel,id, 0, -1, -1, dfile);
		1833	sa02Printf("bmp image saved as %s\n", dfile);
		1834	}
		1835	}
		1836	//PrintCtrl (p1h, P1_GRAPH2D, "sa02_CVI", 1, 1);
		1837	}
		1838	break;
		1839	}
		1840	return 0;
		1841	}
		1842
		1843	int CVICALLBACK CursorCB (int panel, int control, int event,
		1844	void *callbackData, int eventData1, int eventData2) {
		1845	double x=0,y=0;
		1846	int ix=0,iy=0;
		1847	int h2=(int) callbackData;
		1848
		1849	switch (event) {
		1850	case EVENT_COMMIT:
		1851	GetGraphCursor (p1h, P1_GRAPH2D, 1, &x, &y);
		1852	if(H2DGetStepX(h2)>0) {
		1853	ix=(int)((x-H2DGetMinX(h2))/H2DGetStepX(h2));
		1854	}
		1855	if(H2DGetStepY(h2)>0) {
		1856	iy=(int)((y-H2DGetMinY(h2))/H2DGetStepY(h2));
		1857	}
		1858	SetCtrlVal(panel,P1_NSLIX,ix);
		1859	SetCtrlVal(panel,P1_NSLIY,iy);
		1860	sa02Printf("Cursor %f %f h2=%d val=%f min=%f max=%f\n",
		1861	x,y,h2,H2DGetBinContent(h2,ix,iy),H2DGetMin(h2),
		1862	H2DGetMax(h2) );
		1863	break;
		1864	}
		1865	return 0;
		1866	}
		1867
		1868
		1869	int CVICALLBACK HistoInfoCB (int panel, int control, int event,
		1870	void *callbackData, int eventData1, int eventData2) {
		1871	double x=0,y=0;
		1872	int ix=0,iy=0;
		1873	int h2=(int) callbackData;
		1874	int b=0;
		1875	switch (event) {
		1876	case EVENT_COMMIT:
		1877
		1878	GetGraphCursor (panel, control, 1, &x, &y);
		1879	if (panel == p2h ) {
		1880	for (b=0; b<4; b++) {
		1881	if (control==p2graph[b]) break;
		1882	}
		1883	h2=100+b;
		1884	if(H2DGetStepX(h2)>0) {
		1885	ix=(int)((x-H2DGetMinX(h2))/H2DGetStepX(h2));
		1886	}
		1887	if(H2DGetStepY(h2)>0) {
		1888	iy=(int)((y-H2DGetMinY(h2))/H2DGetStepY(h2));
		1889	}
		1890
		1891	sa02Printf("Cursor %f %f h2=%d val=%f min=%f max=%f\n",
		1892	x,y,h2,H2DGetBinContent(h2,ix,iy),H2DGetMin(h2),
		1893	H2DGetMax(h2) );
		1894	}
		1895	break;
		1896	}
		1897	return 0;
		1898	}
		1899
		1900
		1901	int GetElectronicChannel(int x, int y, int chip, int ch) {
		1902	int i=0;
		1903	for (i=0; i<144; i++) {
		1904	if (eid2hapdxy[i].chx == x && eid2hapdxy[i].chy == y) {
		1905	*chip = eid2hapdxy[i].chip;
		1906	*ch = eid2hapdxy[i].ch ;
		1907	return 0;
		1908	}
		1909	}
		1910	return -1;
		1911	}
		1912
		1913	int SetCMon(int chx,int chy) {
		1914	int chip,ch,asic;
		1915	uint32_t response[2]= {0,0};
		1916	uint32_t board;
		1917	uint16_t mask=GetConnectedFebMask();
		1918
		1919	// GetCtrlVal(p1h,P1_BOARDNUMBER, &board);
		1920	GetCtrlVal(p1h,P1_BOARDTYPE,&sa02BoardType);
		1921	GetElectronicChannel(chx,chy,&chip,&ch);
		1922	asic = sa02MuxMap(chip);
		1923	sa02Printf("CHX %d CHY %d ",chx, chy);
		1924	sa02Printf("MUX %d ",asic);
		1925	sa02Printf("CMON ASIC: %d ch: %d\n",chip, ch);
		1926	for (board=0; board<4; board++) {
		1927	if (mask & (1<<board)) {
		1928	sa02Cmd(board,FEB_MUX , asic, 0, 0 ,2,response);
		1929	sa02Cmd(board,SA0x_ASIC0_CMON,0,chip,ch,2,response);
		1930	}
		1931	}
		1932
		1933	return 0;
		1934	}
		1935
		1936	int CVICALLBACK HDraw2DCB (int panel, int control, int event,
		1937	void *callbackData, int eventData1, int eventData2) {
		1938	int ch=0;
		1939	int ctrlID=0;
		1940	int *plot=0;
		1941	int graph=0;
		1942	int board=0;
		1943	switch (event) {
		1944
		1945	case EVENT_COMMIT:
		1946	for (board=0; board<4; board++) {
		1947	// if (panel == p1h){ rID = P1_CH; graph = P1_GRAPH; plot =&p1plothandle;}
		1948	if (panel == p2h) {
		1949	ctrlID = P2_CH;
		1950	graph = p2graph[board];
		1951	plot =&p2plothandle[board];
		1952	}
		1953	// if (panel == p3h){ rID = P3_CH; graph = P3_GRAPH; plot =&p3plothandle;}
		1954	// if (panel == p4h){ rID = P4_CH; graph = P4_GRAPH; plot =&p4plothandle;}
		1955
		1956
		1957	GetCtrlVal(panel,ctrlID, &ch);
		1958	if (ch) {
		1959	H3DDrawSliceXY(100+board,ch-1,panel,graph, plot);
		1960	} else {
		1961	H2DDraw(100+board,panel,graph, plot);
		1962	}
		1963	}
		1964	break;
		1965	}
		1966	return 0;
		1967	}
		1968
		1969	int GetHvMonitor( void ) {
		1970	int N470mid = 4;
		1971	int SYS403mid = 2;
		1972	unsigned short buf[256]= {0};
		1973	int retval;
		1974	int ii;
		1975	// G0,A0,B0,C0,D0,H0,G1,A1,B1,C1,D1,H1,G2,A2,B2,C2,D2,H2,G3,A3,B3,C3,D3,H3
		1976	int channels[]= {24, 0, 1, 2, 3, 0,25, 4, 5, 6, 7, 1,26, 8, 9,10,11, 2,27,12,13,14,15, 3}; //channel for SYS403 , then for N470
		1977	// int channels[]= {0,1,2,3,4,0,5,6,7,8,9,1,10,11,12,13,14,2,15,16,17,18,19,3}; //channel for SYS403 , then for N470
		1978
		1979	for (ii=0; ii<256; ii++) buf[ii]=0;
		1980	monrec.time = (uint32_t) time(NULL);
		1981	for (ii=0; ii<=23; ii++) {
		1982	if ((ii+1)%6==0 && ii!=0) {
		1983	buf[0]=(unsigned short) (channels[ii]<<8) \| ReadOperationalParam;
		1984	if (gCAEN_V288) {
		1985	V288_Send(0,N470mid,1,buf);
		1986	retval=V288_Receive(0,255, buf);
		1987	}
		1988	monrec.status[ii] = buf[0]; //status
		1989	monrec.vmon[ii] = buf[1]*1000;//zapisano v mV
		1990	monrec.imon[ii] = buf[2]*1000;//zapisano v nA
		1991	monrec.vset[ii] = buf[3]*1000;//zapisano v mV
		1992	monrec.iset[ii] = buf[4]*1000;//zapisano v nA
		1993	} else {
		1994	buf[0]=(unsigned short) (channels[ii]<<8) \| ReadStatus;
		1995	if (gCAEN_V288) {
		1996	V288_Send(0,SYS403mid,1,buf);
		1997	retval=V288_Receive(0,255,buf);
		1998	}
		1999	monrec.vmon[ii] = buf[1]*10;//zapisano v mV
		2000	monrec.imon[ii] = buf[2]*10;//zapisano v nA
		2001	monrec.status[ii] = buf[3]; //status
		2002
		2003	if (!hvmonFirst) {
		2004	buf[0]=(unsigned short) (channels[ii]<<8) \| ReadParameters;
		2005	if (gCAEN_V288) {
		2006	V288_Send(0,SYS403mid,1,buf);
		2007	retval=V288_Receive(0,255,buf);
		2008	}
		2009	vset[ii] = monrec.vset[ii] = buf[7]*10;//zapisano v mV
		2010	iset[ii] = monrec.iset[ii] = buf[10]*10;//zapisano v nA
		2011	}
		2012	monrec.vset[ii] = vset[ii];//zapisano v mV
		2013	monrec.iset[ii] = iset[ii];//zapisano v nA
		2014	}
		2015	//sa02Printf("%04x \t %d \t %d \t %d \t %d *\n",monrec.status[ii],monrec.vmon[ii],monrec.vset[ii],monrec.imon[ii],monrec.iset[ii]);
		2016	}
		2017	hvmonFirst=1;
		2018	return 0;
		2019	}
		2020
		2021	int CVICALLBACK daq_scan(void *functionData) {
		2022	int ich,count=0, xyval[4]= {0,0,0,0};
		2023	//int c[4]= {0,0,0,0};
		2024	//int e[4]= {0,0,0,0};
		2025	uint32_t daqmode=1;
		2026	uint32_t trglen;
		2027	int nb,dsave,fcount=0,fmax=0,status,ch;
		2028	unsigned int i;
		2029	int hxy=100;
		2030	//int h2=0;
		2031	time_t t,told, tstart, t0;
		2032
		2033	uint32_t board;
		2034	uint32_t tpenb =0;
		2035	uint32_t response[2]= {0,0};
		2036	char title[0xFF];
		2037	char dfile[MAX_PATHNAME_LEN],dfile0[MAX_PATHNAME_LEN];
		2038	#define MAXSIZE 10000
		2039	int maxsize = MAXSIZE;
		2040	uint32_t sendswtrg=0;
		2041	int ncount=0;
		2042	uint32_t *rdata;
		2043	float dx,dy,gapx,gapy,addgap;
		2044	int ix,iy,nx,ny;
		2045	int scanunitsx=0,scanunitsy=0;
		2046	int x0,y0;
		2047	const float fx= (float)(1000 / 0.3595); // 4M scaling factor steps/mm
		2048	int daqexe;
		2049	int writeevents=0;
		2050	double fraction=0;
		2051	uint32_t *data;
		2052	char serial[4][0xFF];
		2053	char hname[0xFF];
		2054	time_t cas;
		2055
		2056	uint16_t mask=GetConnectedFebMask();
		2057	runrec.id = RUNREC_ID;
		2058	runrec.len = sizeof(runrec);
		2059	endrec.id = ENDREC_ID;
		2060	endrec.len = sizeof(endrec);
		2061	posrec.id = POSREC_ID;
		2062	posrec.len = sizeof(posrec);
		2063	evtrec.id = EVTREC_ID;
		2064	evtrec.len = sizeof(evtrec);
		2065	datrec.id = DATREC_ID;
		2066	datrec.len = sizeof(datrec);
		2067	monrec.id = MONREC_ID;
		2068	monrec.len = sizeof(monrec);
		2069
		2070	SetCtrlAttribute (p2h, P2_DAQ, ATTR_DIMMED, 1);
		2071	ctrl_c=0;
		2072
		2073	GetCtrlVal(p1h,P1_BOARDTYPE,&sa02BoardType);
		2074
		2075	GetCtrlVal (p1h, P1_SERIAL_1, serial[0]);
		2076	GetCtrlVal (p1h, P1_SERIAL_2, serial[1]);
		2077	GetCtrlVal (p1h, P1_SERIAL_3, serial[2]);
		2078	GetCtrlVal (p1h, P1_SERIAL_4, serial[3]);
		2079
		2080	sprintf(runrec.serial,"HAPD=%s,%s,%s,%s", serial[0],serial[1],serial[2],serial[3]);
		2081
		2082	GetCtrlVal (p2h, P2_NEVE, &runrec.nev);
		2083	GetCtrlVal (p2h, P2_PEDESTAL, &runrec.ped);
		2084	GetCtrlVal (p2h, P2_NX, &runrec.nx);
		2085	GetCtrlVal (p2h, P2_XSTEP, &runrec.dx);
		2086	GetCtrlVal (p2h, P2_XMIN, &runrec.x0);
		2087	GetCtrlVal (p2h, P2_NY, &runrec.ny);
		2088	GetCtrlVal (p2h, P2_YSTEP, &runrec.dy);
		2089	GetCtrlVal (p2h, P2_YMIN, &runrec.y0);
		2090	GetCtrlVal ( p1h, P2_TPENB,&tpenb);
		2091	GetCtrlVal ( p2h,P2_DAQEXE,&daqexe);
		2092	GetCtrlVal(p2h,P2_FRACTION, &fraction);
		2093	GetCtrlVal (p2h, P2_SCANUNITSX, &scanunitsx);
		2094	GetCtrlVal (p2h, P2_SCANUNITSY, &scanunitsy);
		2095	GetCtrlVal (p2h, P2_GAPX, &gapx);
		2096	GetCtrlVal (p2h, P2_GAPX, &gapy);
		2097	GetCtrlVal (p2h, P2_DX, &dx);
		2098	GetCtrlVal (p2h, P2_DX, &dy);
		2099
		2100	GetCtrlVal (p2h, P2_XC, &x0);
		2101	GetCtrlVal (p2h, P2_YC, &y0);
		2102
		2103	GetCtrlVal (p2h, P2_DIRECTION, &runrec.direction);
		2104
		2105
		2106	SetCtrlAttribute(p1h,P1_TRGHVMON,ATTR_ENABLED,1);
		2107	hvmonFirst = 0;
		2108
		2109
		2110	GetCtrlVal(p1h,P1_SENDSWTRIG,&sendswtrg);
		2111	GetCtrlVal(p1h,P1_INTTRGLEN, &trglen);
		2112	GetCtrlVal(p1h,P1_DAQMODE, &daqmode);
		2113
		2114
		2115
		2116
		2117	runrec.fver = scanunitsx + scanunitsy*2 ;
		2118	if (scanunitsx) {
		2119	x0 = (int)(x0 - 5.5 * fx * dx - gapx * fx * 0.5);
		2120	}
		2121	if (scanunitsy) {
		2122	y0 = (int)(y0 - 5.5 * fx * dy - gapy * fx * 0.5);
		2123	}
		2124
		2125	GetCtrlVal(p2h, P2_DSAVE, &dsave);
		2126	if (dsave) {
		2127	GetCtrlVal (p2h, P2_DFILE, dfile0);
		2128	fcount=1;
		2129	GetCtrlVal (p2h, P2_NEWF, &fmax);
		2130	fmax*=1000000;//fmax in Mega Bytes
		2131	}
		2132	time (&t0);
		2133	sa02Printf("---->daq_scan\n");
		2134
		2135	if (dsave) {
		2136	sprintf(dfile,"%s_file%02d.dat",dfile0,fcount);
		2137	//gFp = fopen (dfile, "ab");
		2138	gFp = fopen (dfile, "ab");
		2139	if (gFp==NULL) sa02Printf("----> !!! gFp==NULL !!!\n");
		2140	if (ferror (gFp)) sa02Printf("----> !!! ferror (gFp) after fopen !!!\n");
		2141	//time ((time_t *) &runrec.time);
		2142	time (&cas);
		2143	runrec.time = (uint32_t) cas;
		2144	status = (int) fwrite (&runrec, 1, runrec.len, gFp);
		2145	if(status != runrec.len) sa02Printf("----> !!! status != runrec.len (= %d) !!!\n", status);
		2146	if (ferror (gFp)) sa02Printf("----> !!! ferror (gFp) = %d !!!\n", ferror (gFp));
		2147
		2148	}
		2149
		2150
		2151	for (i=0; i<4; i++) {
		2152	sprintf(title,"HAPD%d Surface Scan single channels", i);
		2153	sprintf(hname,"hxy%d", i);
		2154	H3DInit(hxy+i,hname,title, runrec.nx,runrec.x0, runrec.dx,runrec.ny,runrec.y0, runrec.dy, 144, -0.5, 1);
		2155	H3DSetTitleZ(hxy+i,"channel");
		2156	sprintf(hname,"hxy%d_sum", i);
		2157	H2DInit(hxy+i,hname,runrec.serial, runrec.nx,runrec.x0, runrec.dx,runrec.ny,runrec.y0, runrec.dy);
		2158	if (scanunitsx) {
		2159	H2DSetTitleX(hxy+i,"x (channels)");
		2160	H3DSetTitleX(hxy+i,"x (channels)");
		2161	} else {
		2162	H2DSetTitleX(hxy+i,"x (stage steps)");
		2163	H3DSetTitleX(hxy+i,"x (stage steps)");
		2164	}
		2165	if (scanunitsy) {
		2166	H2DSetTitleY(hxy+i,"y (channels)");
		2167	H3DSetTitleY(hxy+i,"y (channels)");
		2168	} else {
		2169	H2DSetTitleY(hxy+i,"y (stage steps)");
		2170	H3DSetTitleY(hxy+i,"y (stage steps)");
		2171	}
		2172
		2173	}
		2174	if (runrec.direction) {
		2175	ny = runrec.ny;
		2176	nx = runrec.nx;
		2177	} else {
		2178	ny = runrec.nx;
		2179	nx = runrec.ny;
		2180	}
		2181	rdata = malloc(sizeof(uint32_t)*maxsize);
		2182
		2183	time(&t);
		2184	tstart=t;
		2185	told=t-1;
		2186
		2187	for (iy=0; iy<ny; iy++) {
		2188
		2189	if (ctrl_c) break;
		2190
		2191	if (runrec.direction) {
		2192	posrec.iy = iy;
		2193	posrec.yset=runrec.y0+posrec.iy*runrec.dy;
		2194	if (scanunitsy) {
		2195	if (posrec.yset>5) {
		2196	addgap=gapy * fx;
		2197	} else {
		2198	addgap=0;
		2199	}
		2200	posrec.yset = (int32_t)(y0+dy fx posrec.yset + addgap);
		2201	}
		2202	if (gMIKRO_Y) {
		2203	//sa02Printf("MIKRO_MoveTo (2, y);%d\n",y);
		2204	MIKRO_MoveTo (MIKRO_Y, posrec.yset);
		2205	sa02Printf("->MIKRO_MoveTo (2, y);%d\n",posrec.yset);
		2206	}
		2207
		2208	SetCtrlVal (p2h, P2_Y, posrec.yset);
		2209	SetCtrlVal (p2h, P2_IY, posrec.iy);
		2210	} else {
		2211	posrec.ix = iy;
		2212	posrec.xset=runrec.x0+posrec.ix*runrec.dx;
		2213	if (scanunitsx) {
		2214	if (posrec.xset>5) {
		2215	addgap=gapx * fx;
		2216	} else {
		2217	addgap=0;
		2218	}
		2219	posrec.xset = (int32_t)(x0+dx fx posrec.xset + addgap);
		2220	}
		2221	if (gMIKRO_Y) {
		2222	//sa02Printf("MIKRO_MoveTo (2, y);%d\n",y);
		2223	MIKRO_MoveTo (MIKRO_X, posrec.xset);
		2224	sa02Printf("->MIKRO_MoveTo (1, x);%d\n",posrec.xset);
		2225	}
		2226	SetCtrlVal (p2h, P2_X, posrec.xset);
		2227	SetCtrlVal (p2h, P2_IX, posrec.ix);
		2228	}
		2229	for (ix=0; ix<nx; ix++) {
		2230	if (ctrl_c) break;
		2231
		2232	if (runrec.direction) {
		2233	posrec.ix = ix;
		2234	posrec.xset=runrec.x0+posrec.ix*runrec.dx;
		2235	if (scanunitsx) {
		2236	if (posrec.xset>5) {
		2237	addgap=gapx * fx;
		2238	} else {
		2239	addgap=0;
		2240	}
		2241	posrec.xset = (int32_t)(x0+dx fx posrec.xset + addgap);
		2242	}
		2243	if (gMIKRO_X) {
		2244	//sa02Printf("MIKRO_MoveTo (1, x);%d\n",posrec.x);
		2245	MIKRO_MoveTo (MIKRO_X, posrec.xset);
		2246	sa02Printf("->MIKRO_MoveTo (1, x);%d\n",posrec.xset);
		2247	}
		2248	SetCtrlVal (p2h, P2_X, posrec.xset);
		2249	SetCtrlVal (p2h, P2_IX, posrec.ix);
		2250	} else {
		2251	posrec.iy = ix;
		2252	posrec.yset=runrec.y0+posrec.iy*runrec.dy;
		2253	if (scanunitsy) {
		2254	if (posrec.yset>5) {
		2255	addgap=gapy * fx;
		2256	} else {
		2257	addgap=0;
		2258	}
		2259	posrec.yset = (int32_t)(y0+dy fx posrec.yset + addgap);
		2260	}
		2261	if (gMIKRO_X) {
		2262	//sa02Printf("MIKRO_MoveTo (1, x);%d\n",posrec.y);
		2263	MIKRO_MoveTo (MIKRO_Y, posrec.yset);
		2264	sa02Printf("->MIKRO_MoveTo (2, y);%d\n",posrec.yset);
		2265	}
		2266	SetCtrlVal (p2h, P2_Y, posrec.yset);
		2267	SetCtrlVal (p2h, P2_IY, posrec.iy);
		2268	}
		2269	if (scanunitsx && scanunitsy) {
		2270	SetCMon(runrec.x0+posrec.ixrunrec.dx,runrec.y0+posrec.iyrunrec.dy);
		2271	}
		2272	if (dsave) {
		2273	if (fmax && (ftell(gFp) > fmax)) {
		2274	fcount+=1;
		2275	sprintf(dfile,"%s_file%02d.dat",dfile0,fcount);
		2276	fclose(gFp);
		2277	gFp = fopen (dfile, "ab");
		2278	}
		2279	time (&cas);
		2280	posrec.time = (uint32_t) cas;
		2281	status = (int) fwrite (&posrec, 1, posrec.len, gFp);
		2282	}
		2283
		2284	Sa02DaqMode (daqmode);
		2285	Sa02SelectTriggerWithMaskAndLength (sendswtrg, mask, trglen);
		2286
		2287	for (board=0; board<4; board++) {
		2288	if (mask & (1<<board)) {
		2289	sa02Cmd( board, FEB_VTH1, runrec.ped, 0,0,1,response);
		2290	Sa02TestPulseEnable(board,tpenb); // Enable/disable test pulse
		2291	}
		2292	}
		2293
		2294	Sa02SetNeve(runrec.nev);
		2295
		2296	evtrec.nev=1;
		2297
		2298
		2299	sa02Reset();
		2300
		2301	if (ctrl_c) break;
		2302
		2303	if ( (count+2+dsize) >= maxsize) {
		2304	maxsize*=2;
		2305	sa02Printf("Increasing data buffer to %d elements\n", maxsize);
		2306	rdata=realloc(rdata ,sizeof(uint32_t)*maxsize);
		2307	}
		2308
		2309	data = &rdata[count+2];
		2310	do {
		2311	//int k;
		2312	//uint32_t inputtriggers;
		2313	if (sendswtrg == 1) Sa02SoftwareTrigger();
		2314	nb = sa02Read(mask, &rdata[count+2] );
		2315	/*
		2316	for (k=0; k<4; k++) c[k] = Sa02GetCounter ( k ,&e[k]);
		2317	for (k=0; k<4; k++) sa02Printf(" CNTR%d=%d (ERR=%d)\t",k,c[k],e[k]);
		2318	sa02Printf("\nsa02Read bytes = %d mask=%d neve=%d (%d # %d)\n", nb, mask, runrec.nev, Sa02GetNeve( &inputtriggers ) , inputtriggers);
		2319	*/
		2320	} while ( nb==0 && !ctrl_c);
		2321
		2322
		2323
		2324	if (sa02TimerOut \|\| nb==0) sa02Printf("sa02TimerOut \|\| nb==0\n");
		2325
		2326	for (ich=0; ich<144*4; ich++) {
		2327	int brd = ich/144;
		2328	int xch = 143 - ich%144;
		2329	//sa02Printf("[%d] = %d \n", ich, data[ich]);
		2330	if (data[ich]> xyval[brd]) xyval[brd] = data[ich];
		2331	if (mask & (1<<brd)) {
		2332	H3DFillBin(hxy+ brd, posrec.ix,posrec.iy,xch,data[ich]);
		2333	H2DFillBin(hxy+ brd, posrec.ix,posrec.iy,data[ich]);
		2334	}
		2335	}
		2336	sa02Printf("max couts = %d %d %d %d\n", xyval[0],xyval[1],xyval[2],xyval[3]);
		2337	if (nb>=0) {
		2338	count+=module_header(0x3,&rdata[count],nb/sizeof(uint32_t));
		2339	}
		2340
		2341
		2342	/*
		2343	for (ich=0; ich<144; ich++) {
		2344
		2345	// uint32_t mask=0xFF;
		2346	// id=(35-ich/4);
		2347	// shft=(ich%4)*8;
		2348	uint32_t mask=0xF;
		2349	id=(17-ich/8)+board*18;
		2350	shft=(ich%8)*4;
		2351	if ( data[id] & (mask <<shft) ) {
		2352	H3DFillBin(hxy, posrec.ix,posrec.iy,ich,1);
		2353	H2DFillBin(hxy, posrec.ix,posrec.iy,1);
		2354	}
		2355	}
		2356	*/
		2357	if (dsave) {
		2358	if (Random(0,1)<fraction) {
		2359	writeevents=1;
		2360	} else {
		2361	writeevents=0;
		2362	}
		2363	if (writeevents) {
		2364	evtrec.id = EVTREC_ID;
		2365	evtrec.len=count*sizeof(uint32_t)+ sizeof(evtrec);
		2366
		2367	evtrec.time= (uint32_t) time(NULL);
		2368	evtrec.nev=i;
		2369	status = (int) fwrite( &evtrec, 1, sizeof(evtrec),gFp);
		2370	if (count) {
		2371	status = (int) fwrite(rdata,1,count*sizeof(uint32_t),gFp); //gzip
		2372	}
		2373	}
		2374	if (hvmon) {
		2375	time_t thv0,thv1;
		2376	time(&thv0);
		2377	GetHvMonitor();
		2378	time(&thv1);
		2379	status = (int) fwrite( &monrec, 1, sizeof(monrec),gFp);
		2380	sa02Printf("HvMonitor dt= %d s\n", thv1-thv0 );
		2381	hvmon =0;
		2382	}
		2383
		2384	ncount++;
		2385	}
		2386
		2387	time(&t);
		2388	if (t!=told ) {
		2389	double done= (double) (posrec.ix+posrec.iyrunrec.nx)/(runrec.nxrunrec.ny);
		2390	EstimatedFinish(p2h, P2_PROGRESS, P2_ETA, t0, done);
		2391	GetCtrlVal(p2h,P2_CH, &ch);
		2392	for (board=0; board<4; board++) {
		2393	if (ch) {
		2394	H3DDrawSliceXY(hxy+board,ch,p2h, p2graph[board], &p2plothandle[board]);
		2395	} else {
		2396	H2DDraw(hxy+board,p2h, p2graph[board], &p2plothandle[board]);
		2397	}
		2398	}
		2399	ProcessSystemEvents ();
		2400	SetCtrlVal(p2h,P2_CEVE, i);
		2401	sa02Printf("%d events in %2.2f min (%d s) %s",ncount, (double)(t-tstart)/60.,t-tstart, ctime(&t));
		2402
		2403	}
		2404	told=t;
		2405
		2406
		2407
		2408	if (ctrl_c) break;
		2409
		2410	if (daqexe &0x1) {
		2411	daq(NULL);
		2412	sa02Cmd( board, FEB_VTH1, runrec.ped, 0,0,1,response);
		2413	}
		2414	if (daqexe &0x2) {
		2415	V729_SetFilePointer(gFp);
		2416	V729_daq(NULL);
		2417	}
		2418
		2419	}
		2420	}
		2421
		2422	if (gFp) {
		2423	int ii=0, ison=0;
		2424	for (ii=0; ii<4; ii++) {
		2425	GetCtrlVal(p1h,hapd_onoff[ii], &ison);
		2426	if (ison ) {
		2427	H3DWrite2File(hxy+ii, gFp);
		2428	H2DWrite2File(hxy+ii, gFp);
		2429	}
		2430	}
		2431	fclose(gFp);
		2432	}
		2433	gFp=NULL;
		2434	free(rdata);
		2435
		2436	SetCtrlAttribute(p1h,P1_TRGHVMON,ATTR_ENABLED,0);
		2437
		2438	return 0;
		2439	}
		2440
		2441	int CVICALLBACK Testing(void *functionData) {
		2442	int i;
		2443	int N470mid = 4;
		2444	int SYS403mid = 2;
		2445	unsigned short buf[256]= {0};
		2446	int odg;
		2447	int channels[]= {0,1,2,3,4,0,5,6,7,8,9,1,10,11,12,13,14,2,15,16,17,18,19,3}; //channel for SYS403 , then for N470
		2448	time_t t0,t1;
		2449	time(&t0);
		2450
		2451	hvmonFirst=0;
		2452
		2453	for (i=0; i<256; i++) buf[i]=0;
		2454	for (i=0; i<=23; i++) {
		2455	if (((i+1)%6)==0&&i!=0) {
		2456	buf[0]=(unsigned short) (channels[i]<<8) \| ReadOperationalParam;
		2457	if (gCAEN_V288) {
		2458	V288_Send(0,N470mid,1,buf);
		2459	odg=V288_Receive(0,255,buf);
		2460	}
		2461	monrec.status[i] = buf[0]; //status
		2462	monrec.vmon[i] = buf[1]*1000;//zapisano v mV
		2463	monrec.imon[i] = buf[2]*1000;//zapisano v nA
		2464	monrec.vset[i] = buf[3]*1000;//zapisano v mV
		2465	monrec.iset[i] = buf[4]*1000;//zapisano v nA
		2466	} else {
		2467	buf[0]=(unsigned short) (channels[i]<<8) \| ReadStatus;
		2468	if (gCAEN_V288) {
		2469	V288_Send(0,SYS403mid,1,buf);
		2470	odg=V288_Receive(0,255,buf);
		2471	}
		2472	monrec.vmon[i] = buf[1]*10;//zapisano v mV
		2473	monrec.imon[i] = buf[2]*10;//zapisano v nA
		2474	monrec.status[i] = buf[3]; //status
		2475	if(!hvmonFirst) {
		2476	buf[0]=(unsigned short) (channels[i]<<8) \| ReadParameters;
		2477	if (gCAEN_V288) {
		2478	V288_Send(0,SYS403mid,1,buf);
		2479	odg=V288_Receive(0,255,buf);
		2480	}
		2481	vset[i] = monrec.vset[i] = buf[7]*10;//zapisano v mV
		2482	iset[i] = monrec.iset[i] = buf[10]*10;//zapisano v nA
		2483	}
		2484	monrec.vset[i] = vset[i];//zapisano v mV
		2485	monrec.iset[i] = iset[i];//zapisano v nA
		2486	}
		2487	sa02Printf("%04x \t %.02f V \t %d V \t\t %.02f muA \t %d muA *\n",monrec.status[i],(float)monrec.vmon[i]/1000,monrec.vset[i]/1000,(float)monrec.imon[i]/1000,monrec.iset[i]/1000);
		2488	}
		2489	time (&t1);
		2490	sa02Printf("Cas izvedbe:%g s.\n",difftime(t1,t0));
		2491
		2492	return 0;
		2493	}
		2494
		2495	int CVICALLBACK set_dac(int OnOff) {
		2496	int val;
		2497	char name[MAX_PATHNAME_LEN];
		2498	if (OnOff) {
		2499	GetCtrlVal (p5h, P5_DAC_ON, &val);
		2500	sprintf(name ,"%s -p %d",palaser, val);
		2501	sa02Printf("%s\n", name);
		2502	system(name);
		2503	GetCtrlVal (p5h, P5_FREQUENCY_ON, &val);
		2504	sprintf(name ,"%s -f %d",palaser, val);
		2505	sa02Printf("%s\n", name);
		2506	system(name);
		2507	} else {
		2508	GetCtrlVal (p5h, P5_DAC_OFF, &val);
		2509	sprintf(name ,"%s -p %d",palaser, val);
		2510	sa02Printf("%s\n", name);
		2511	system(name);
		2512	GetCtrlVal (p5h, P5_FREQUENCY_OFF, &val);
		2513	sprintf(name ,"%s -f %d",palaser, val);
		2514	sa02Printf("%s\n", name);
		2515	system(name);
		2516	}
		2517	return 0;
		2518	}
		2519
		2520	int CVICALLBACK set_hv(int OnOff) {
		2521	int N470mid = 4;
		2522	int channel = 0;
		2523	int ret;
		2524
		2525	unsigned short buf[256];
		2526
		2527	buf[0]=(unsigned short) (channel<<8) \| TurnChanelOff;
		2528	if (OnOff) buf[0]=(unsigned short) (channel<<8) \| TurnChanelOn;
		2529	V288_Send(0,N470mid,1,buf);
		2530	ret=V288_Receive(0,255,buf);
		2531
		2532	buf[0]=(unsigned short) (channel<<8) \| ReadOperationalParam;
		2533	V288_Send(0,N470mid,1,buf);
		2534	ret=V288_Receive(0,255,buf);
		2535
		2536	while (((buf[0]&0x20)&&(buf[0]&0x1))\|\|(buf[0]&0x40)) {
		2537	if((buf[0]&0x20)&&(buf[0]&0x20)) sa02Printf("Channel is ramping up \t Vmon: %d V \t Vset: %d \t status: 0x%x\n",buf[1],buf[3],buf[0]);
		2538	else if(buf[0]&0x40) sa02Printf("Channel is ramping down \t Vmon: %d V \t Vset: %d \t status: 0x%x\n",buf[1],buf[3],buf[0]);
		2539	else if(buf[0]&0x1E) {
		2540	sa02Printf("status: 0x%x\n",buf[0]);
		2541	return -1;
		2542	} else sa02Printf("status: 0x%x\n",buf[0]);
		2543	Delay(2);
		2544	buf[0]=(unsigned short) (channel<<8) \| ReadOperationalParam;
		2545	V288_Send(0,N470mid,1,buf);
		2546	ret=V288_Receive(0,255,buf);
		2547	}
		2548
		2549	buf[0]=(unsigned short) (channel<<8) \| ReadOperationalParam;
		2550	V288_Send(0,N470mid,1,buf);
		2551	ret=V288_Receive(0,255,buf);
		2552	if(buf[0]&0x1) sa02Printf("HV is ON \t status: 0x%x\n",buf[0]);
		2553	else sa02Printf("HV is OFF \t status: 0x%x\n",buf[0]);
		2554
		2555	return 0;
		2556	}
		2557
		2558	int CVICALLBACK changeGlobalParam(int paramID, int paramValue) {
		2559	int state;
		2560	int cid = P3_GREG;
		2561	int scanpar = paramID; //ID of the parameter you are about to change
		2562	int nch = 4; //4 ASIC chips
		2563	int spar = scanpar-10;
		2564	Rect save_range,trange;
		2565	const int maxrange[20]= {0,0,8,16,16,16,2,2,2,0,4,4,4,2,256,4,512};
		2566
		2567	trange.top=0;
		2568	trange.left=0;
		2569
		2570	state = GetTableSelection (p3h, cid, &save_range);
		2571	trange = MakeRect (1, spar, nch, 1);
		2572	state = SetTableSelection (p3h, cid, trange);
		2573	if ((trange.top!=0)&&(trange.left!=0)) {
		2574	if (scanpar!=1) {
		2575	state = FillTableCellRange (p3h, cid, MakeRect (1, spar, nch, 1), paramValue%maxrange[scanpar-1]);
		2576	if (maxrange[scanpar-1] && paramValue/maxrange[scanpar-1]) {
		2577	state = FillTableCellRange (p3h, cid, MakeRect (1, spar-1, nch, 1), paramValue/maxrange[scanpar-1]);
		2578	}
		2579	}
		2580	UploadGlobalParameters (p3h,cid,EVENT_COMMIT,NULL,0,0);
		2581	}
		2582	state = SetTableSelection (p3h, cid, save_range);
		2583
		2584	return 0;
		2585	}
		2586
		2587	int CreateParamFile(char *filename) {
		2588	int n,i,row,asic,ch;
		2589	unsigned short val;
		2590	time_t t;
		2591	char buf[MAX_PATHNAME_LEN];
		2592	FILE *fp;
		2593
		2594	sprintf(buf,"..//parameters//%s",filename);
		2595	fp = fopen(buf, "w");
		2596	if (fp) {
		2597	//--------------------------------------------------- Parameters header
		2598	time(&t);
		2599	fprintf(fp, "#Parameter exported from CVI %s\n",ctime(&t) );
		2600	//--------------------------------------------------- FPGA parameters
		2601	GetNumTextBoxLines(p3h, P3_FPGAPAR,&n);
		2602	for (i=0; i<n; i++) {
		2603	GetTextBoxLine(p3h, P3_FPGAPAR, i, buf);
		2604	fprintf(fp, "%s\n",buf);
		2605	}
		2606	//--------------------------------------------------- Global parameters
		2607	for (row=1; row<1+16; row++) {
		2608	int irow = (row-1)%4;
		2609	int iboard = (row-1)/4;
		2610	fprintf(fp, "param_board %d\n",iboard);
		2611	fprintf(fp, "## global parameter for chip %d\n",(row-1)%4);
		2612	fprintf(fp, "param_global %d 0x1ffff\n",irow);
		2613	GetTableCellVal (p3h, P3_GREG, MakePoint (1,row), &val);
		2614	fprintf(fp, "phasecmps %d 0x%x\n",irow,val);
		2615	GetTableCellVal (p3h, P3_GREG, MakePoint (2,row), &val);
		2616	fprintf(fp, "gain %d 0x%x\n",irow,val);
		2617	GetTableCellVal (p3h, P3_GREG, MakePoint (3,row), &val);
		2618	fprintf(fp, "shapingtime %d 0x%x\n",irow,val);
		2619	GetTableCellVal (p3h, P3_GREG, MakePoint (4,row), &val);
		2620	fprintf(fp, "comparator %d 0x%x\n",irow,val);
		2621	GetTableCellVal (p3h, P3_GREG, MakePoint (5,row), &val);
		2622	fprintf(fp, "vrdrive %d 0x%x\n",irow,val);
		2623	GetTableCellVal (p3h, P3_GREG, MakePoint (6,row), &val);
		2624	fprintf(fp, "monitor %d 0x%x\n",irow,val);
		2625	GetTableCellVal (p3h, P3_GREG, MakePoint (7,row), &val);
		2626	fprintf(fp, "id %d 0x%x\n",irow,val);
		2627
		2628	fprintf(fp, "load_global %d\n\n\n",irow);
		2629	}
		2630
		2631	//--------------------------------------------------- Channel parameters
		2632	for (i=0; i<144*4; i++) {
		2633	int board = i/144;
		2634	int j= i%144;
		2635	asic=(j/36);
		2636	ch=j%36;
		2637	row=(i+1);
		2638	if (i%36==0) {
		2639	fprintf(fp, "# channel parameter for chip %d\n\n",asic);
		2640	}
		2641
		2642	fprintf(fp, "param_board %d\n",board);
		2643	fprintf(fp, "param_ch %d %d 0x0000\n",asic,ch);
		2644
		2645	GetTableCellVal (p3h, P3_CREG, MakePoint (3,row), &val);
		2646	fprintf(fp, "decaytime %d %d 0x%x\n",asic,ch,val);
		2647	GetTableCellVal (p3h, P3_CREG, MakePoint (4,row), &val);
		2648	fprintf(fp, "offset %d %d 0x%x\n",asic,ch,val);
		2649	GetTableCellVal (p3h, P3_CREG, MakePoint (5,row), &val);
		2650	fprintf(fp, "fineadj_unipol %d %d 0x%x\n",asic,ch,val);
		2651	GetTableCellVal (p3h, P3_CREG, MakePoint (6,row), &val);
		2652	fprintf(fp, "fineadj_diff %d %d 0x%x\n",asic,ch,val);
		2653	GetTableCellVal (p3h, P3_CREG, MakePoint (7,row), &val);
		2654	fprintf(fp, "tpenb %d %d 0x%x\n",asic,ch,val);
		2655	GetTableCellVal (p3h, P3_CREG, MakePoint (8,row), &val);
		2656	fprintf(fp, "kill %d %d 0x%x\n",asic,ch,val);
		2657	fprintf(fp, "load_ch %d %d\n\n\n",asic,ch);
		2658	}
		2659	fclose(fp);
		2660	}
		2661	sprintf(buf,"Created file '..//parameters//%s'\n",filename);
		2662	sa02Printf("%s",buf);
		2663	return 0;
		2664	}
		2665
		2666
		2667	int StepOne(void) {
		2668	char defaulParamFile[0xFF] = "..\\parameters\\default.param"; // path to default.param file
		2669
		2670	char HAPDnum[0xFF];
		2671	int HAPDnumberOnOff;
		2672	int ActiveHAPDNo=0;
		2673	int HAPDid[]= {P1_SERIAL_1,P1_SERIAL_2,P1_SERIAL_3,P1_SERIAL_4};
		2674	int HAPDstatus[]= {P1_ONOFF_1,P1_ONOFF_2,P1_ONOFF_3,P1_ONOFF_4};
		2675	char HAPDnumber[4][0xFF];
		2676
		2677	FILE *fp;
		2678	int ndim=400;
		2679	char line[ndim];
		2680	time_t t;
		2681	uint32_t mask = GetConnectedFebMask();
		2682	int current_run=1;
		2683
		2684	char cmdCommand[ndim];
		2685
		2686	int numberOfIterations = 1; //change this when everything will be working...
		2687
		2688	/**** Check if Serial numbers are filled in ****/
		2689	for (int i=0; i<4; i++) {
		2690	GetCtrlVal(p1h, HAPDid[i], HAPDnum);
		2691	GetCtrlVal(p1h, HAPDstatus[i], &HAPDnumberOnOff);
		2692	if(!strcmp(HAPDnum, "noserial") && HAPDnumberOnOff) {
		2693	printf("Fill in 'HAPD%d number' or disable 'HAPD%d'\n",i,i);
		2694	return -1;
		2695	}
		2696	strcpy(HAPDnumber[i],HAPDnum);
		2697	ActiveHAPDNo+=HAPDnumberOnOff;
		2698	}
		2699	if(!ActiveHAPDNo) {
		2700	sa02Printf("Turn on at least 1 HAPD.");
		2701	return -1;
		2702	}
		2703	sa02Printf("HAPD0 serial: %s \nHAPD1 serial: %s \nHAPD2 serial: %s \nHAPD3 serial: %s \n",HAPDnumber[0],HAPDnumber[1],HAPDnumber[2],HAPDnumber[3]);
		2704
		2705	/**** Loads param file and uploads it to FEB ****/
		2706	SetCtrlVal(p3h, P3_INPUTFILE, defaulParamFile); // write path to P3_INPUTFILE
		2707	SetParametersFromFile(defaulParamFile); // write default.param to P3_CREG table
		2708
		2709	LoadParameters(p3h, P3_LOADPAR, EVENT_COMMIT, NULL, 0, 0); // load parameters from defaul.param to FEB
		2710	ProcessSystemEvents ();
		2711	LoadParameters(p3h, P3_LOADPAR, EVENT_COMMIT, NULL, 0, 0); // load parameters from defaul.param to FEB
		2712	ProcessSystemEvents ();
		2713	LoadParameters(p3h, P3_LOADPAR, EVENT_COMMIT, NULL, 0, 0); // load parameters from defaul.param to FEB
		2714	ProcessSystemEvents ();
		2715
		2716	/**** MicroMini calibration ****/
		2717	sa02Printf("Calibration *\n\n");
		2718	SetHome(p2h, P2_HO,EVENT_COMMIT,NULL, 0, 0);
		2719	SetCtrlVal(p2h,P2_XC,gCENTER_X);
		2720	SetCtrlVal(p2h,P2_YC,gCENTER_Y);
		2721
		2722	/**** Reads run number ****/
		2723	fp = fopen ("CompleteScan_RunNumber.txt","r");
		2724	if (fp) {
		2725	if (fgets(line,ndim,fp)!= NULL) current_run = atoi(line)+1;
		2726	fclose(fp);
		2727	fp = NULL;
		2728	}
		2729	ProcessSystemEvents ();
		2730
		2731	/**** Slow Control ****/
		2732	sprintf(line,"%04d_SlowControl.xml",current_run);
		2733	fp = fopen (line,"w");
		2734	fprintf(fp,"<febtest>\n");
		2735	time(&t);
		2736	fprintf(fp,"<time>%s</time>\n", ctime(&t));
		2737
		2738	for (int board=0; board<4; board++) {
		2739	if (mask &(1<<board)) {
		2740	for (int k=0; k<10; k++) {
		2741	Delay(0.1);
		2742	SlowControl(board,fp);
		2743	ProcessSystemEvents ();
		2744	if (ctrl_c) break;
		2745	}
		2746	}
		2747	if (ctrl_c) break;
		2748	}
		2749
		2750	fprintf(fp,"</febtest>\n");
		2751	fclose(fp);
		2752	fp = NULL;
		2753
		2754	/**** Treshold scan, Calibration & Channel Param Upload (iterations) ****/
		2755	for(int j=0; j<=numberOfIterations; j++) {
		2756	if(!j) {
		2757	//Treshold settings
		2758	SetCtrlVal(p1h,P1_DATA, 400);
		2759	SetCtrlVal(p1h,P1_DSTEP, 1);
		2760	SetCtrlVal(p1h,P1_NEVE, 300);
		2761	SetCtrlVal(p1h,P1_TOREAD, 1000);
		2762	//Calibration settings
		2763	SetCtrlVal (p3h, P3_FITMODE, 2);
		2764	SetCtrlVal (p3h, P3_TARGETOFFSET, 550.);
		2765	SetCtrlVal (p3h, P3_TARGETRMS, 3.);
		2766	}
		2767	sprintf(line,"%04d_0_Treshold_%d.dat", current_run, j);
		2768	SetCtrlVal(p1h,P1_OUTPUTFILE, line);
		2769	if(j==numberOfIterations) continue; //when everything will be working remove this one and uncoment the next one
		2770
		2771	daq(NULL);
		2772
		2773	sprintf(cmdCommand,"cmd.exe /c ..\\sa02read -i .\\%s -o .\\%04d_0_Treshold_%d.root", line, current_run, j);
		2774	LaunchExecutable(cmdCommand);
		2775
		2776
		2777	ProcessSystemEvents ();
		2778
		2779	//if(j==numberOfIterations) continue;
		2780
		2781	sprintf(line,"Coarse fit parameters, iteration %d *\n\n", j);
		2782	sa02Printf(line);
		2783
		2784	FitH2DCoarse(p3h, P3_CALIBRATION_2,EVENT_COMMIT,NULL,0,0);
		2785	ProcessSystemEvents ();
		2786
		2787	sprintf(line,"%04d_Iteration_%d.param", current_run, j);
		2788	CreateParamFile(line);
		2789
		2790	sa02Printf("Loading channel parameters *\n\n");
		2791
		2792	sprintf(defaulParamFile,"..\\parameters\\%s",line);
		2793	SetCtrlVal(p3h, P3_INPUTFILE, defaulParamFile); // write path to P3_INPUTFILE
		2794	SetParametersFromFile(defaulParamFile); // write default.param to P3_CREG table
		2795
		2796	LoadParameters(p3h, P3_LOADPAR, EVENT_COMMIT, NULL, 0, 0); // load parameters to FEB
		2797	ProcessSystemEvents ();
		2798	LoadParameters(p3h, P3_LOADPAR, EVENT_COMMIT, NULL, 0, 0); // load parameters to FEB
		2799	ProcessSystemEvents ();
		2800	LoadParameters(p3h, P3_LOADPAR, EVENT_COMMIT, NULL, 0, 0); // load parameters to FEB
		2801	ProcessSystemEvents ();
		2802
		2803
		2804	}
		2805
		2806	/**** Increases run number in file for 1 ****/
		2807	/* fp = fopen ("CompleteScan_RunNumber.txt","w");
		2808	fprintf(fp,"%d\n", current_run);
		2809	fclose(fp);
		2810	*/
		2811
		2812	return 0;
		2813	}
		2814
		2815	int ModuleTest(void) {
		2816	int HAPDnumberOnOff;
		2817	int ActiveHAPDNo=0;
		2818	int HAPDid[]= {P1_SERIAL_1,P1_SERIAL_2,P1_SERIAL_3,P1_SERIAL_4};
		2819	int HAPDstatus[]= {P1_ONOFF_1,P1_ONOFF_2,P1_ONOFF_3,P1_ONOFF_4};
		2820	int ndim=400;
		2821	int current_run=1;
		2822	int ithr;
		2823	double targetoffset;
		2824	char line[ndim];
		2825	char buf[0xFF];
		2826	char cmdCommand[ndim];
		2827	char HAPDnumber[4][0xFF];
		2828	char HAPDnum[0xFF];
		2829
		2830	FILE *fp;
		2831
		2832
		2833	/**** Check if Serial numbers are filled in ****/
		2834	for (int i=0; i<4; i++) {
		2835	GetCtrlVal(p1h, HAPDid[i], HAPDnum);
		2836	GetCtrlVal(p1h, HAPDstatus[i], &HAPDnumberOnOff);
		2837	if(!strcmp(HAPDnum, "noserial") && HAPDnumberOnOff) {
		2838	printf("Fill in 'HAPD%d number' or disable 'HAPD%d'\n",i,i);
		2839	return -1;
		2840	}
		2841	strcpy(HAPDnumber[i],HAPDnum);
		2842	ActiveHAPDNo+=HAPDnumberOnOff;
		2843	}
		2844	if(!ActiveHAPDNo) {
		2845	sa02Printf("Turn on at least 1 HAPD.");
		2846	return -1;
		2847	}
		2848	sa02Printf("HAPD0 serial: %s \nHAPD1 serial: %s \nHAPD2 serial: %s \nHAPD3 serial: %s \n",HAPDnumber[0],HAPDnumber[1],HAPDnumber[2],HAPDnumber[3]);
		2849
		2850	/**** MicroMini calibration ****/
		2851	sa02Printf("Calibration *\n\n");
		2852	SetHome(p2h, P2_HO,EVENT_COMMIT,NULL, 0, 0);
		2853	SetCtrlVal(p2h,P2_XC,gCENTER_X);
		2854	SetCtrlVal(p2h,P2_YC,gCENTER_Y);
		2855
		2856	/**** Reads run number ****/
		2857	fp = fopen ("CompleteScan_RunNumber.txt","r");
		2858	if (fp) {
		2859	if (fgets(line,ndim,fp)!= NULL) current_run = atoi(line)+1;
		2860	fclose(fp);
		2861	fp = NULL;
		2862	}
		2863	ProcessSystemEvents ();
		2864
		2865	fp = fopen ("CompleteScan_RunNumber.txt","w");
		2866	fprintf(fp,"%d\n", current_run);
		2867	fclose(fp);
		2868
		2869	GetCtrlVal (p3h, P3_TARGETOFFSET, &targetoffset); // Treshold
		2870	ithr=(int)targetoffset+20;
		2871	/**** Treshold + Waveform scan over 144x center ****/
		2872	SetCtrlVal (p2h, P2_ZSET, 0);
		2873	SetCtrlVal (p2h, P2_XC, (uint32_t)(gCENTER_KX*0+gCENTER_X));
		2874	SetCtrlVal (p2h, P2_YC, (uint32_t)(gCENTER_KY*0+gCENTER_Y));
		2875	Zset(p2h,P2_ZSET,EVENT_COMMIT,NULL,0,0);
		2876	// Panel 1 setting
		2877	SetCtrlVal (p1h, P1_TPENB, 0); // disable test pulz
		2878	SetCtrlVal (p1h, P1_SENDSWTRIG, 2); // set external trigger
		2879	SendTriggerTypeCB (p1h, P1_SENDSWTRIG, EVENT_COMMIT,NULL,0,0); // commit external trigger
		2880
		2881	SetCtrlVal(p1h,P1_DATA, 500); // Inital value
		2882	SetCtrlVal(p1h,P1_DSTEP, 2); // Step size
		2883	SetCtrlVal(p1h,P1_NEVE, 101); // Number of steps
		2884	SetCtrlVal(p1h,P1_TOREAD, 1000); // Number of events
		2885
		2886	// Panel 4 setting
		2887	//SetCtrlVal(p4h,P4_FRACTION, 0.); // Fraction of waveforms to store (If you want to create charge accumulation graphs with sa02read set to 1.)
		2888	SetCtrlVal(p4h,P4_NEVE, 4000); // Number of events
		2889
		2890	// Panel 2 settings
		2891	SetCtrlVal (p2h, P2_SCANUNITSX, 1); // Only over the channel centers (1 Ch, 0 Step)
		2892	SetCtrlVal (p2h, P2_NX, 12); // Noumber of steps = 12
		2893	SetCtrlVal (p2h, P2_XSTEP, 1); // Step size = 1
		2894	SetCtrlVal (p2h, P2_XMIN, 0); // Start position = 0
		2895	SetCtrlVal (p2h, P2_SCANUNITSY, 1); // Only over the channel centers (1 Ch, 0 Step)
		2896	SetCtrlVal (p2h, P2_NY, 12); // Noumber of steps = 12
		2897	SetCtrlVal (p2h, P2_YSTEP, 1); // Step size = 1
		2898	SetCtrlVal (p2h, P2_YMIN, 0); // Start position = 0
		2899	SetCtrlVal (p2h, P2_DIRECTION, 1); // Set Y then scan X = 1 (0 = Set X then scan X)
		2900
		2901	SetCtrlVal (p2h, P2_NEVE, 100); // Number of events for position scan (keep low so the scan is faster ... this is not the point of interest for this scan)
		2902	SetCtrlVal (p2h, P2_PEDESTAL, ithr); // Treshold
		2903
		2904	SetCtrlVal (p2h, P2_DAQEXE, 3); // Execute at each position: SA02 scan and CAEN V729a
		2905
		2906	sprintf(buf,"%04d_1_Treshold_Waveform",current_run);
		2907	sprintf(line,"..\\modules\\%s",buf);
		2908	SetCtrlVal (p2h, P2_DFILE, line);
		2909
		2910
		2911	daq_scan(NULL);
		2912
		2913	sprintf(cmdCommand,"cmd.exe /c mkdir ..\\modules\\%04d & ..\\sa02read -i %s_file01.dat -o ..\\modules\\%04d\\%s.root",
		2914	current_run, line, current_run, buf);
		2915	LaunchExecutable(cmdCommand);
		2916
		2917
		2918
		2919	/**** 2D v X ****/
		2920	// Panel 2 settings
		2921	SetCtrlVal (p2h, P2_SCANUNITSX, 0); // Continuous scan over X (1 Ch, 0 Step)
		2922	SetCtrlVal (p2h, P2_NX, 380/2); // Noumber of steps = 380
		2923	SetCtrlVal (p2h, P2_XSTEP, 2*500); // Step size = 500
		2924	SetCtrlVal (p2h, P2_XMIN, 83000); // Start position = 8500
		2925	SetCtrlVal (p2h, P2_SCANUNITSY, 1); // Only over the channel centers (1 Ch, 0 Step)
		2926	SetCtrlVal (p2h, P2_NY, 12); // Noumber of steps = 12
		2927	SetCtrlVal (p2h, P2_YSTEP, 1); // Step size = 1
		2928	SetCtrlVal (p2h, P2_YMIN, 0); // Start position = 0
		2929	SetCtrlVal (p2h, P2_DIRECTION, 1); // Set Y then scan X = 1
		2930
		2931	SetCtrlVal (p2h, P2_NEVE, 1000); // Number of events for position scan
		2932	SetCtrlVal (p2h, P2_PEDESTAL, ithr); // Treshold
		2933
		2934	SetCtrlVal (p2h, P2_DAQEXE, 0); // Execute at each position: nothing
		2935
		2936	sprintf(buf,"%04d_2_2DX",current_run);
		2937	sprintf(line,"..\\modules\\%s", buf);
		2938	SetCtrlVal (p2h, P2_DFILE, line);
		2939
		2940
		2941	daq_scan(NULL);
		2942
		2943	sprintf(cmdCommand,"cmd.exe /c mkdir ..\\modules\\%04d & ..\\sa02read -i %s_file01.dat -o ..\\modules\\%04d\\%s.root ", current_run, line, current_run, buf);
		2944	LaunchExecutable(cmdCommand);
		2945
		2946
		2947	/**** 2D v Y ****/
		2948	// Panel 2 settings
		2949	SetCtrlVal (p2h, P2_SCANUNITSX, 1); // Only over the channel centers (1 Ch, 0 Step)
		2950	SetCtrlVal (p2h, P2_NX, 12); // Noumber of steps = 12
		2951	SetCtrlVal (p2h, P2_XSTEP, 1); // Step size = 1
		2952	SetCtrlVal (p2h, P2_XMIN, 0); // Start position = 0
		2953	SetCtrlVal (p2h, P2_SCANUNITSY, 0); // Continuous scan over Y (1 Ch, 0 Step)
		2954	SetCtrlVal (p2h, P2_NY, 380/2); // Noumber of steps = 380
		2955	SetCtrlVal (p2h, P2_YSTEP, 2*500); // Step size = 500
		2956	SetCtrlVal (p2h, P2_YMIN, 75000); // Start position = 7500
		2957	SetCtrlVal (p2h, P2_DIRECTION, 0); // Set X then scan Y = 0
		2958
		2959	SetCtrlVal (p2h, P2_NEVE, 1000); // Number of events for position scan
		2960	SetCtrlVal (p2h, P2_PEDESTAL, ithr); // Treshold
		2961
		2962	SetCtrlVal (p2h, P2_DAQEXE, 0); // Execute at each position: nothing
		2963
		2964	sprintf(buf,"%04d_3_2DY",current_run);
		2965	sprintf(line,"..\\modules\\%s", buf);
		2966	SetCtrlVal (p2h, P2_DFILE, line);
		2967
		2968
		2969	daq_scan(NULL);
		2970
		2971	sprintf(cmdCommand,"cmd.exe /c mkdir ..\\modules\\%04d & ..\\sa02read -i %s_file01.dat -o ..\\modules\\%04d\\%s.root ", current_run, line, current_run, buf);
		2972	system(cmdCommand); // wait here to finish to proceed to next step
		2973
		2974	sprintf(cmdCommand,"cmd.exe /c ..\\thisroot.bat & cd analysis & root script.c(%d)",current_run);
		2975	LaunchExecutable(cmdCommand);
		2976
		2977	SetCtrlVal (p2h, P2_ZSET, 300000);
		2978	SetCtrlVal (p2h, P2_XC, (uint32_t)(gCENTER_KX*0+gCENTER_X));
		2979	SetCtrlVal (p2h, P2_YC, (uint32_t)(gCENTER_KY*0+gCENTER_Y));
		2980	Zset(p2h,P2_ZSET,EVENT_COMMIT,NULL,0,0);
		2981
		2982	return 0;
		2983	}
		2984
		2985	int StepThree(void) {
		2986	//char cmdCommand[0xFF];
		2987	//char line[0xFF];
		2988	//char buf[0xFF];
		2989	//int current_run = 11;
		2990
		2991	return 0;
		2992	}
		2993
		2994
		2995	// map uir controls ....
		2996	#define MAX_UIRCTRLMAP_SIZE 1000
		2997	typedef struct {
		2998	char name[32];
		2999	int id;
		3000	int handle;
		3001	} UirCtrlMap;
		3002	UirCtrlMap gUirCtrlMap[MAX_UIRCTRLMAP_SIZE];
		3003	int gNUirCtrlMap=0;
		3004
		3005	int GetControlID(const char *ctrl) {
		3006	for (int i=0; i<gNUirCtrlMap; i++) {
		3007	if (strcmp(ctrl,gUirCtrlMap[i].name)==0) return ctrl,gUirCtrlMap[i].id;
		3008	}
		3009	return -1;
		3010	}
		3011	int GetPanelHandle(const char *ctrl) {
		3012
		3013	if ( strstr(ctrl, "P1_")!= NULL ) return p1h;
		3014	if ( strstr(ctrl, "P2_")!= NULL ) return p2h;
		3015	if ( strstr(ctrl, "P3_")!= NULL ) return p3h;
		3016	if ( strstr(ctrl, "P4_")!= NULL ) return p4h;
		3017	if ( strstr(ctrl, "P5_")!= NULL ) return p5h;
		3018
		3019	return -1;
		3020	}
		3021
		3022	int LoadUirHeader(const char *fname) {
		3023	int ndim=MAX_PATHNAME_LEN;
		3024	char line[MAX_PATHNAME_LEN];
		3025	char cmd[MAX_PATHNAME_LEN];
		3026	FILE *fp = NULL;
		3027	ssize_t size;
		3028	int n0= gNUirCtrlMap;
		3029	if ( GetFileInfo(fname,&size) ) fp = fopen(fname,"r");
		3030	if (!fp) {
		3031	sa02Printf("Error! Cannot open header file %s\n",fname);
		3032	return -1;
		3033	}
		3034
		3035	while (fgets(line,ndim,fp)!=NULL ) {
		3036	char ctrl[32];
		3037	int ctrlid;
		3038	int nb = sscanf(line,"%s%s%d",cmd, ctrl, &ctrlid);
		3039	if (strstr(cmd,"#define")!=NULL && nb==3) {
		3040	strcpy(gUirCtrlMap[gNUirCtrlMap].name, ctrl );
		3041	if (gNUirCtrlMap<MAX_UIRCTRLMAP_SIZE) {
		3042	gUirCtrlMap[gNUirCtrlMap].id = ctrlid;
		3043	gUirCtrlMap[gNUirCtrlMap].handle = GetPanelHandle(ctrl);
		3044	gNUirCtrlMap++;
		3045	} else {
		3046	sa02Printf("ERROR: Increase gNUirCtrlMap\n");
		3047	}
		3048	}
		3049	}
		3050	fclose(fp);
		3051	sa02Printf("Number of Controls loaded from File %s = %d \n", fname,gNUirCtrlMap-n0);
		3052	return 0;
		3053	}
		3054
		3055
		3056	char str_replace(const char str, const char old, const char new) {
		3057
		3058	/* Adjust each of the below values to suit your needs. */
		3059
		3060	/* Increment positions cache size initially by this number. */
		3061	size_t cache_sz_inc = 16;
		3062	/* Thereafter, each time capacity needs to be increased,
		3063	* multiply the increment by this factor. */
		3064	const size_t cache_sz_inc_factor = 3;
		3065	/* But never increment capacity by more than this number. */
		3066	const size_t cache_sz_inc_max = 1048576;
		3067
		3068	char pret, ret = NULL;
		3069	const char pstr2, pstr = str;
		3070	size_t i, count = 0;
		3071	ptrdiff_t *pos_cache = NULL;
		3072	size_t cache_sz = 0;
		3073	size_t cpylen, orglen, retlen, newlen =0, oldlen = strlen(old);
		3074
		3075	/* Find all matches and cache their positions. */
		3076	while ((pstr2 = strstr(pstr, old)) != NULL) {
		3077	count++;
		3078
		3079	/* Increase the cache size when necessary. */
		3080	if (cache_sz < count) {
		3081	cache_sz += cache_sz_inc;
		3082	pos_cache = realloc(pos_cache, sizeof(pos_cache) cache_sz);
		3083	if (pos_cache == NULL) {
		3084	goto end_repl_str;
		3085	}
		3086	cache_sz_inc *= cache_sz_inc_factor;
		3087	if (cache_sz_inc > cache_sz_inc_max) {
		3088	cache_sz_inc = cache_sz_inc_max;
		3089	}
		3090	}
		3091
		3092	pos_cache[count-1] = pstr2 - str;
		3093	pstr = pstr2 + oldlen;
		3094	}
		3095
		3096	orglen = pstr - str + strlen(pstr);
		3097
		3098	/* Allocate memory for the post-replacement string. */
		3099	if (count > 0) {
		3100	newlen = strlen(new);
		3101	retlen = orglen + (newlen - oldlen) * count;
		3102	} else retlen = orglen;
		3103	ret = malloc(retlen + 1);
		3104	if (ret == NULL) {
		3105	goto end_repl_str;
		3106	}
		3107
		3108	if (count == 0) {
		3109	/* If no matches, then just duplicate the string. */
		3110	strcpy(ret, str);
		3111	} else {
		3112	/* Otherwise, duplicate the string whilst performing
		3113	* the replacements using the position cache. */
		3114	pret = ret;
		3115	memcpy(pret, str, pos_cache[0]);
		3116	pret += pos_cache[0];
		3117	for (i = 0; i < count; i++) {
		3118	memcpy(pret, new, newlen);
		3119	pret += newlen;
		3120	pstr = str + pos_cache[i] + oldlen;
		3121	cpylen = (i == count-1 ? orglen : (size_t)pos_cache[i+1]) - pos_cache[i] - oldlen;
		3122	memcpy(pret, pstr, cpylen);
		3123	pret += cpylen;
		3124	}
		3125	ret[retlen] = '\0';
		3126	}
		3127
		3128	end_repl_str:
		3129	/* Free the cache and return the post-replacement string,
		3130	* which will be NULL in the event of an error. */
		3131	free(pos_cache);
		3132	return ret;
		3133	}
		3134
		3135
		3136	int CVICALLBACK run_script(void *functionData) {
		3137	FILE *fp = NULL;
		3138	FILE *fpout =NULL;
		3139
		3140
		3141	char *line;
		3142	char buf[MAX_PATHNAME_LEN];
		3143	int status;
		3144	char type[MAX_PATHNAME_LEN];
		3145	char param[MAX_PATHNAME_LEN];
		3146	char paramValue[MAX_PATHNAME_LEN];
		3147	int scx,nx,xstep,xmin,scy,ny,ystep,ymin,direction,nevents,tresh;
		3148	char test[256];
		3149	char outputFileSuffix[128];
		3150	char outputFile[MAX_PATHNAME_LEN];
		3151	char HAPDserialNumber[128];
		3152	ssize_t size;
		3153	int data[2];
		3154	int runno=0;
		3155
		3156	char scriptname[MAX_PATHNAME_LEN];
		3157	GetCtrlVal(p1h,P1_SCRIPTNAME, scriptname);
		3158
		3159
		3160	if ( GetFileInfo(scriptname,&size) ) fp = fopen(scriptname,"r");
		3161	if (!fp) {
		3162	sa02Printf("Error! Cannot open script file %s\n",scriptname);
		3163	return -1;
		3164	}
		3165	while (fgets(buf,MAX_PATHNAME_LEN,fp)!=NULL ) {
		3166
		3167	if (buf[0]!='#' && strlen(buf)>2) {
		3168	if (strstr(buf, "%RUN%")!=NULL) {
		3169	char srun[16];
		3170	sprintf(srun,"%04d",runno);
		3171	line = str_replace(buf,"%RUN%", srun);
		3172	} else {
		3173	line = buf;
		3174	}
		3175	sa02Printf("#[%d] %s",strlen(buf),buf);
		3176
		3177	sscanf(line,"%s",type);
		3178
		3179	if (strstr(type,"SetCtrlVal")!=NULL) {
		3180	int pID;
		3181	int rID;
		3182	int datatype;
		3183	sscanf(line,"%*s%s%s",param,paramValue);
		3184
		3185	pID= GetPanelHandle(param);
		3186	rID= GetControlID(param);
		3187	if (rID>0 && pID>0) {
		3188	GetCtrlAttribute (pID, rID, ATTR_DATA_TYPE, &datatype);
		3189
		3190	switch (datatype){
		3191	case VAL_INTEGER: SetCtrlVal (pID, rID, atoi(paramValue)); break;
		3192	case VAL_UNSIGNED_INTEGER: SetCtrlVal (pID, rID, strtoul(paramValue,NULL,0)); break;
		3193	case VAL_SHORT_INTEGER: SetCtrlVal (pID, rID, atoi(paramValue)); break;
		3194	case VAL_UNSIGNED_SHORT_INTEGER: SetCtrlVal (pID, rID, strtoul(paramValue,NULL,0)); break;
		3195	case VAL_DOUBLE : SetCtrlVal (pID, rID, atof(paramValue)); break;
		3196	case VAL_STRING : SetCtrlVal (pID, rID, paramValue ); break;
		3197	default: sa02Printf("[%s] ATTR_DATA_TYPE of the %s not supported datatype %d p4h=%d\n\n", type, param, datatype, p4h);
		3198	}
		3199	//sa02Printf("[%s] SetCtrlVal %s %s panel=%d control=%d\n",type,param, paramValue,pID,rID);
		3200	} else {
		3201	sa02Printf("[%s] Invalid Ctrl %s %s panel=%d control=%d\n",type,param, paramValue,pID,rID);
		3202	}
		3203
		3204	} else if (strstr(type,"2D")!=NULL) {
		3205	sscanf(line,"%*s%d%d%d%d%d%d%d%d%d%d%d%s",&scx,&nx,&xstep,&xmin,&scy,&ny,&ystep,&ymin,&direction,&nevents,&tresh,outputFileSuffix);
		3206	sprintf(test,"%d %d %d %d %d %d %d %d %d %d %d %s *\n",scx,nx,xstep,xmin,scy,ny,ystep,ymin,direction,nevents,tresh,outputFileSuffix);
		3207	sa02Printf("%s *\n\n",test);
		3208	SetCtrlVal (p2h, P2_SCANUNITSX, scx);
		3209	SetCtrlVal (p2h, P2_NX, nx);
		3210	SetCtrlVal (p2h, P2_XSTEP, xstep);
		3211	SetCtrlVal (p2h, P2_XMIN, xmin);
		3212	SetCtrlVal (p2h, P2_SCANUNITSY, scy);
		3213	SetCtrlVal (p2h, P2_NY, ny);
		3214	SetCtrlVal (p2h, P2_YSTEP, ystep);
		3215	SetCtrlVal (p2h, P2_YMIN, ymin);
		3216	SetCtrlVal (p2h, P2_DIRECTION, direction);
		3217
		3218	SetCtrlVal (p2h, P2_NEVE, nevents);
		3219	SetCtrlVal (p2h, P2_PEDESTAL, tresh);
		3220
		3221	GetCtrlVal (p1h, P1_SERIAL_1, HAPDserialNumber);
		3222	sprintf(outputFile,"%s_%s", HAPDserialNumber, outputFileSuffix);
		3223	SetCtrlVal (p2h, P2_DFILE, outputFile);
		3224
		3225
		3226	daq_scan(NULL);
		3227
		3228	} else if (strstr(type,"Delay")!=NULL) {
		3229	int idelay=0;
		3230	sscanf(line,"%*s%s",paramValue);
		3231	for (idelay=atoi(paramValue) ; idelay>0; idelay--) {
		3232	Delay(1);
		3233	SetCtrlVal(p1h, P1_DELAY, idelay);
		3234	ProcessSystemEvents();
		3235	if (ctrl_c) break;
		3236	}
		3237	} else if (strstr(type,"ThresholdLinearity")!=NULL) {
		3238	char *fname;
		3239	uint16_t mask = GetConnectedFebMask();
		3240
		3241	sscanf(line,"%*s%s",paramValue);
		3242	fname = paramValue;
		3243
		3244
		3245	ThresholdLinearityCB (p1h, P1_THRVSADC, EVENT_COMMIT, NULL, 0, 0 );
		3246	fpout = fopen(fname,"ab");
		3247	if(fpout) {
		3248	for (int board=0; board<4; board++) if ( mask &(1<<board)) H1DWrite2File(board,fpout);
		3249	fclose(fpout);
		3250	}
		3251
		3252	} else if (strstr(type,"LaunchExecutable")!=NULL) {
		3253	int index = FindPattern (line, 0, -1, "LaunchExecutable", 0, 0) + 17;
		3254
		3255	char *cmd = &line[index];
		3256	sa02Printf("cmd %d=%s\n",index, cmd);
		3257	if (strlen(cmd)>0) LaunchExecutable( cmd );
		3258	} else if (strstr(type,"CAEN_V729")!=NULL) {
		3259	char *fname;
		3260	//FILE *fpmon=NULL;
		3261
		3262	sscanf(line,"%*s%s",paramValue);
		3263	fname=paramValue;
		3264
		3265	fpout = fopen(fname,"ab");
		3266	if (fpout) {
		3267
		3268	V729_SetFilePointer(fpout);
		3269	V729_daq(NULL);
		3270	fclose(fpout);
		3271	}
		3272	} else if (strstr(type,"HvMonitor")!=NULL) {
		3273	int nrepetitions;
		3274	int delaytime;
		3275	int k=0;
		3276	FILE *fpmon=NULL;
		3277	sscanf(line,"%*s%s%d%d",paramValue, &delaytime, &nrepetitions );
		3278	fpmon = fopen(paramValue,"ab");
		3279
		3280	if ( fpmon ) {
		3281	hvmonFirst = 0;
		3282	for (k=0; k<nrepetitions; k++) {
		3283	double thv0,thv1;
		3284	thv0 = Timer();
		3285	GetHvMonitor();
		3286	for (int board=0;board<4;board++){
		3287	double sdata[12];
		3288	for (int k=0;k<6;k++){
		3289	sdata[k] = monrec.imon[k+4*board];
		3290	sdata[k+6] = 0;
		3291	}
		3292
		3293	SetAxisScalingMode (p1h, chart_control[board], VAL_LEFT_YAXIS, VAL_AUTOSCALE, 0, 1);
		3294	SetAxisScalingMode (p1h, chart_control[board], VAL_RIGHT_YAXIS, VAL_AUTOSCALE, 0, 1);
		3295	PlotStripChart (p1h, chart_control[board], sdata, 12, 0, 0, VAL_DOUBLE);
		3296	}
		3297	monrec.id = MONREC_ID;
		3298	monrec.len = sizeof(monrec);
		3299	thv1=Timer();
		3300	status = (int) fwrite( &monrec, 1, sizeof(monrec),fpmon);
		3301	sa02Printf("[%04d] HvMonitor dt= %f s status=%d\n", runno, thv1-thv0, status );
		3302	for (int idelay=delaytime ; idelay>0; idelay--) {
		3303	Delay(1);
		3304	SetCtrlVal(p1h, P1_DELAY, idelay);
		3305	ProcessSystemEvents();
		3306	if (ctrl_c) break;
		3307	}
		3308	if (ctrl_c) break;
		3309	}
		3310	fclose(fpmon);
		3311	} else {
		3312	sa02Printf("%s cannot open file %s\n",param, paramValue );
		3313	}
		3314
		3315	} else if (strstr(type,"GetRunNumberFromFile")!=NULL) {
		3316	sscanf(line,"%*s%s",paramValue);
		3317	runno = GetRunNumberFromFile(paramValue);
		3318	SetCtrlVal(p1h, P1_RUNNO, runno);
		3319	sa02Printf("%s %s run=>%d\n",type, paramValue, runno );
		3320	} else if (strstr(type,"IncreaseNumberInFile")!=NULL) {
		3321	sscanf(line,"%*s%s",paramValue);
		3322	runno = IncreaseRunNumberInFile(paramValue);
		3323	sa02Printf("%s %s run=>%d\n",type, paramValue, runno );
		3324	SetCtrlVal(p1h, P1_RUNNO, runno);
		3325	} else if (strstr(type,"LoadParameters")!=NULL) {
		3326	LoadParameters(p3h, P3_LOADPAR,EVENT_COMMIT,NULL,0,0);
		3327	sa02Printf("Loading parameters *\n\n");
		3328	} else if (strstr(type,"QueueUserEvent")!=NULL \|\| strstr(type,"ProcessUserEvent")!=NULL) {
		3329	char scontrol[0xFF];
		3330	int panelHandle=0;
		3331	int controlID;
		3332	sscanf(line,"%*s%s",scontrol);
		3333	panelHandle = GetPanelHandle(scontrol);
		3334	controlID = GetControlID(scontrol);
		3335	sa02Printf("UserEvent %s panelHandle %d controlID %d\n",scontrol, panelHandle, controlID );
		3336	if (panelHandle>=0 && controlID >=0 ) {
		3337	if (strstr(type,"ProcessUserEvent")!=NULL) {
		3338	ProcessUserEvent(panelHandle, controlID,0);
		3339	} else {
		3340	data[1] = controlID;
		3341	data[0] = panelHandle;
		3342
		3343	status = CmtWriteTSQData (pTSQ, data, 1, TSQ_INFINITE_TIMEOUT, NULL);
		3344	}
		3345	}
		3346
		3347	} else if (strstr(type,"SetPositionAndMux")!=NULL) {
		3348	int ix,iy;
		3349	sscanf(line,"%*s%d%d",&ix,&iy);
		3350	sa02Printf("SetPositionAndMux %d %d \n", ix,iy);
		3351
		3352	SetCtrlVal (p2h, P2_CHX, ix);
		3353	SetCtrlVal (p2h, P2_CHY, iy);
		3354	SetPositionAndMux( p2h,0, EVENT_COMMIT , NULL,0,0);
		3355
		3356	} else if (strstr(type,"Treshold")!=NULL) {
		3357	sscanf(line,"%*s%s",outputFileSuffix);
		3358
		3359	GetCtrlVal (p1h, P1_SERIAL_1, HAPDserialNumber);
		3360	sprintf(outputFile,"%s_%s.dat", HAPDserialNumber, outputFileSuffix);
		3361	SetCtrlVal (p1h, P1_OUTPUTFILE, outputFile);
		3362
		3363	sprintf(test,"Treshold scan to file %s",outputFile);
		3364	sa02Printf("%s *\n\n", test);
		3365
		3366	daq(NULL);
		3367	} else if (strstr(type,"Fitanje")!=NULL) {
		3368	FitH2DCoarse(p3h, P3_CALIBRATION_2,EVENT_COMMIT,NULL,0,0);
		3369	sa02Printf("Coarse fit parameters *\n\n");
		3370	} else if (strstr(type,"UploadChannelParameters")!=NULL) {
		3371	UploadChannelParameters(p3h, P3_CPARLOAD,EVENT_COMMIT,NULL,0,0);
		3372	sa02Printf("Loading channel parameters *\n\n");
		3373	} else if (strstr(type,"KalibracijaMizice")!=NULL) {
		3374	SetHome(p2h, P2_HO,EVENT_COMMIT,NULL,0,0);
		3375	SetCtrlVal(p2h,P2_XC,gCENTER_X);
		3376	SetCtrlVal(p2h,P2_YC,gCENTER_Y);
		3377	sa02Printf("Calibration *\n\n");
		3378	} else if (strstr(type,"LaserHVOn")!=NULL) {
		3379	set_dac(1);
		3380	sa02Printf("Low intensity laser *\n\n");
		3381	} else if (strstr(type,"LaserHVOff")!=NULL) {
		3382	set_dac(0);
		3383	sa02Printf("High intensity laser *\n\n");
		3384	} else if (strstr(type,"Gain")!=NULL) {
		3385	sscanf(line,"%*s%d",paramValue);
		3386	sprintf(test," %d", atoi(paramValue));
		3387	sa02Printf("%s *\n\n", test);
		3388	changeGlobalParam(12, atoi(paramValue)); // Global parameter Gain has ID 12
		3389	} else if (strstr(type,"ShapingTime")!=NULL) {
		3390	sscanf(line,"%*s%s",paramValue);
		3391	sprintf(test," %d", atoi(paramValue));
		3392	sa02Printf("%s *\n\n", test);
		3393	changeGlobalParam(13, atoi(paramValue)); // Global parameter ShapingTime has ID 13
		3394	}
		3395	}
		3396	if (ctrl_c) {
		3397	break;
		3398	}
		3399	}
		3400	fclose(fp);
		3401	return 0;
		3402	}
		3403
		3404	/*
		3405	int CVICALLBACK StartPositionScan (int panel, int control, int event,
		3406	void *callbackData, int eventData1, int eventData2)
		3407	{
		3408	switch (event)
		3409	{
		3410	case EVENT_COMMIT:
		3411	daq_scan(NULL);
		3412	break;
		3413	}
		3414	return 0;
		3415	}
		3416	*/
		3417
		3418	int CVICALLBACK SetHome (int panel, int control, int event,
		3419	void *callbackData, int eventData1, int eventData2) {
		3420	switch (event) {
		3421	case EVENT_COMMIT:
		3422	SetWaitCursor (1);
		3423	if (gMIKRO_X) MIKRO_ReferenceMove (MIKRO_X);
		3424	if (gMIKRO_Y) MIKRO_ReferenceMove (MIKRO_Y);
		3425	if (gMIKRO_Z) MIKRO_ReferenceMove (MIKRO_Z);
		3426	SetWaitCursor (0);
		3427	break;
		3428	}
		3429	return 0;
		3430	}
		3431
		3432	int CVICALLBACK CBTimer (int panel, int control, int event,
		3433	void *callbackData, int eventData1, int eventData2) {
		3434	switch (event) {
		3435	case EVENT_TIMER_TICK:
		3436	// ProcessSystemEvents();
		3437	break;
		3438	}
		3439	return 0;
		3440	}
		3441
		3442	int CVICALLBACK GetPosition (int panel, int control, int event,
		3443	void *callbackData, int eventData1, int eventData2) {
		3444	int xpos=0,ypos=0,zpos=0;
		3445	switch (event) {
		3446
		3447	case EVENT_COMMIT:
		3448
		3449	if (gMIKRO_X) {
		3450	MIKRO_GetPosition(MIKRO_X,&xpos);
		3451	Delay(0.01);
		3452	SetCtrlVal (p2h, P2_X, xpos);
		3453	}
		3454
		3455	if (gMIKRO_Y) {
		3456	MIKRO_GetPosition(MIKRO_Y,&ypos);
		3457	Delay(0.01);
		3458	SetCtrlVal (p2h, P2_Y, ypos);
		3459	}
		3460	if (gMIKRO_X) {
		3461	MIKRO_GetPosition(MIKRO_Z,&zpos);
		3462	Delay(0.01);
		3463	SetCtrlVal (p2h, P2_Z, zpos);
		3464	sa02Printf("x=%d y=%d z=%d\n",xpos,ypos,zpos);
		3465	}
		3466
		3467
		3468	break;
		3469	}
		3470	return 0;
		3471	}
		3472
		3473	int CVICALLBACK ReRead (int panel, int control, int event,
		3474	void *callbackData, int eventData1, int eventData2) {
		3475	switch (event) {
		3476	case EVENT_COMMIT: {
		3477	int status;
		3478	char dfile[MAX_PATHNAME_LEN];
		3479	FILE *fp;
		3480
		3481	status = FileSelectPopup ("", "*.dat", ".dat",
		3482	"Izberi datoteko s podatki",
		3483	VAL_LOAD_BUTTON, 0, 0, 1, 0, dfile);
		3484	if (status==1) {
		3485	fp = fopen (dfile, "rb");
		3486	status = (int) fread (&runrec, 1, sizeof(runrec), fp);
		3487	fclose(fp);
		3488	if (runrec.id==RUNREC_ID) {
		3489	SetCtrlVal (p2h, P2_NX, runrec.nx);
		3490	SetCtrlVal (p2h, P2_XSTEP, runrec.dx);
		3491	SetCtrlVal (p2h, P2_XMIN, runrec.x0);
		3492	SetCtrlVal (p2h, P2_NY, runrec.ny);
		3493	SetCtrlVal (p2h, P2_YSTEP, runrec.dy);
		3494	SetCtrlVal (p2h, P2_YMIN, runrec.y0);
		3495	SetCtrlVal (p2h, P2_NEVE, runrec.nev);
		3496	SetCtrlVal (p2h, P2_SCANUNITSX, runrec.fver%2);
		3497	SetCtrlVal (p2h, P2_SCANUNITSY, runrec.fver/2);
		3498	SetCtrlVal (p2h, P2_DIRECTION, runrec.direction);
		3499	}
		3500	}
		3501	}
		3502	break;
		3503	}
		3504	return 0;
		3505	}
		3506
		3507	int CVICALLBACK Zset (int panel, int control, int event,
		3508	void *callbackData, int eventData1, int eventData2) {
		3509	switch (event) {
		3510	case EVENT_COMMIT: {
		3511	int zpos;
		3512	GetCtrlVal (p2h, P2_ZSET, &zpos);
		3513	if (gMIKRO_Z) MIKRO_MoveTo (MIKRO_Z, zpos);
		3514
		3515	}
		3516	break;
		3517	}
		3518	return 0;
		3519	}
		3520
		3521	int CVICALLBACK HidePanelCB (int panel, int control, int event,
		3522	void *callbackData, int eventData1, int eventData2) {
		3523	switch (event) {
		3524	case EVENT_COMMIT:
		3525	HidePanel (panel);
		3526	break;
		3527	}
		3528	return 0;
		3529	}
		3530
		3531	int GetChannelPosition(int chip, int ch, int chx, int chy) {
		3532
		3533	int i=0;
		3534
		3535	for (i=0; i<144; i++) {
		3536
		3537	if (eid2hapdxy[i].chip == chip && eid2hapdxy[i].ch == ch) {
		3538	*chx = eid2hapdxy[i].chx;
		3539	*chy = eid2hapdxy[i].chy ;
		3540	return 0;
		3541	}
		3542	}
		3543	return -1;
		3544
		3545	}
		3546
		3547	int LoadElectronicMap(const char *fname) {
		3548
		3549	FILE *fp = fopen(fname,"r");
		3550	int chip,ch,chx,chy,chxr,chyr;
		3551	int nread=0;
		3552	int ndim=400;
		3553	char line[400];
		3554	int nr=0;
		3555
		3556	while (fgets(line,ndim,fp)!=NULL) {
		3557
		3558	nr = sscanf(line,"%d%d%d%d",&chip,&ch,&chxr,&chyr);
		3559	if (nr) {
		3560	// Orientation of HAPD in xy system - position of APD A:LR,UR,UL,LL and view:B,F
		3561	//LRB
		3562	// chx=11-chxr;
		3563	// chy=11-chyr;
		3564	//URB
		3565	chx=chyr;
		3566	chy=11-chxr;
		3567	//ULB
		3568	// chx=chxr;
		3569	// chy=chyr;
		3570	//LLB
		3571	// chx=11-chyr;
		3572	// chy=chxr;
		3573	eid2hapdxy[nread].chip = chip;
		3574	eid2hapdxy[nread].ch = ch ;
		3575	eid2hapdxy[nread].chx = chx ;
		3576	eid2hapdxy[nread].chy = chy ;
		3577	}
		3578	nread++;
		3579	}
		3580	sa02Printf("eid2hapdxy %d records read.\n",nread);
		3581	fclose(fp);
		3582	return 0;
		3583
		3584	}
		3585
		3586	int CVICALLBACK SetParameters (int panel, int control, int event,
		3587	void *callbackData, int eventData1, int eventData2) {
		3588	//uint32_t address;
		3589	//char saddress[0xFF],
		3590	char fname[0xFF];
		3591
		3592	switch (event) {
		3593	case EVENT_COMMIT:
		3594	GetCtrlVal(p3h, P3_INPUTFILE, fname);
		3595	SetParametersFromFile(fname);
		3596
		3597	break;
		3598	}
		3599	return 0;
		3600	}
		3601
		3602	int CVICALLBACK UploadGlobalParameters (int panel, int control, int event,
		3603	void *callbackData, int eventData1, int eventData2) {
		3604	uint32_t response[2]= {0,0};
		3605	switch (event) {
		3606	case EVENT_COMMIT:
		3607	SetCtrlAttribute (panel, control, ATTR_DIMMED, 1);
		3608	{
		3609	uint32_t gdata;
		3610
		3611	int board,asic;
		3612	int i=0,imin=0,imax=0;
		3613	Rect trange;
		3614	Point cell;
		3615	int row=0;
		3616	unsigned short val;
		3617	sa02AsicGlobalRegister greg = (sa02AsicGlobalRegister ) &gdata ;
		3618	uint16_t mask=GetConnectedFebMask();
		3619	// GetCtrlVal(p1h,P1_BOARDNUMBER,&board);
		3620	GetCtrlVal(p1h,P1_BOARDTYPE,&sa02BoardType);
		3621
		3622	if (control== P3_SELGPARLOAD) {
		3623	GetTableSelection (p3h, P3_GREG, &trange);
		3624	if ((trange.top!=0)&&(trange.left!=0)) {
		3625	imin= trange.top - 1;
		3626	imax= imin + trange.height;
		3627
		3628	} else {
		3629	if (!GetActiveTableCell(p3h, P3_GREG, &cell)) {
		3630	imin = cell.y-1;
		3631	imax = imin;
		3632	} else return 0;
		3633	}
		3634	} else {
		3635	imin=0;
		3636	imax=4*4;
		3637	}
		3638
		3639	for (i=imin; i<imax; i++) {
		3640	row=i+1;
		3641	GetTableCellVal (p3h, P3_GREG, MakePoint (1,row), &val);
		3642	greg->phasecmps = val;
		3643	GetTableCellVal (p3h, P3_GREG, MakePoint (2,row), &val);
		3644	greg->gain = val;
		3645	GetTableCellVal (p3h, P3_GREG, MakePoint (3,row), &val);
		3646	greg->shapingtime = val;
		3647	GetTableCellVal (p3h, P3_GREG, MakePoint (4,row), &val);
		3648	greg->comparator = val;
		3649	GetTableCellVal (p3h, P3_GREG, MakePoint (5,row), &val);
		3650	greg->vrdrive = val;
		3651	GetTableCellVal (p3h, P3_GREG, MakePoint (6,row), &val);
		3652	greg->monitor = val;
		3653	//GetTableCellVal (p3h, P3_GREG, MakePoint (7,row), &val); greg->id = val;
		3654	greg->id = 0;
		3655	greg->unused=0;
		3656	board=i/4;
		3657	asic=i%4;
		3658
		3659	if (mask & (1<<board) ) sa02Cmd(board,SA0x_ASIC0_GREG, gdata, asic, 0,1,response);
		3660	if (ctrl_c) {
		3661	break;
		3662	}
		3663	}
		3664	}
		3665	SetCtrlAttribute (panel, control, ATTR_DIMMED, 0);
		3666	sa02Printf("Global Parameters Uploaded to the ASICs\n");
		3667	break;
		3668	}
		3669	return 0;
		3670	}
		3671
		3672	int CVICALLBACK UploadChannelParameters (int panel, int control, int event,
		3673	void *callbackData, int eventData1, int eventData2) {
		3674	uint32_t response[2]= {0,0};
		3675	switch (event) {
		3676	case EVENT_COMMIT:
		3677	SetCtrlAttribute (panel, control, ATTR_DIMMED, 1);
		3678	{
		3679	uint32_t cdata;
		3680	int state;
		3681	Rect trange;
		3682	Point cell;
		3683
		3684	sa02AsicChannelRegister creg = (sa02AsicChannelRegister ) &cdata ;
		3685
		3686	unsigned int i=0,imin=0,imax=0;
		3687	int row=0;
		3688	uint32_t board;
		3689	uint16_t mask=GetConnectedFebMask();
		3690
		3691	unsigned short val,asic,ch;
		3692
		3693	// GetCtrlVal(p1h,P1_BOARDNUMBER, &board);
		3694	GetCtrlVal(p1h,P1_BOARDTYPE,&sa02BoardType);
		3695
		3696	if ((panel==p3h)&&(control==P3_SELCPARLOAD)) {
		3697	state = GetTableSelection (p3h, P3_CREG, &trange);
		3698	if ((trange.top!=0)&&(trange.left!=0)) {
		3699	imin= trange.top-1;
		3700	imax= imin + trange.height;
		3701
		3702	} else {
		3703	if (!GetActiveTableCell(p3h, P3_CREG, &cell)) {
		3704	imin = cell.y-1;
		3705	imax = imin+1;
		3706	} else return 0;
		3707	}
		3708	} else if ((panel==p1h)&&(control==P1_CHPARLOAD)) {
		3709	GetCtrlVal(p1h,P1_NSLIX,&imin);
		3710	imax=imin+1;
		3711	} else {
		3712	imin=0;
		3713	imax=144*4;
		3714	}
		3715
		3716	for (i=imin; i<imax; i++) {
		3717	// asic=(unsigned short )(i/36);
		3718	// ch=(unsigned short )(i%36);
		3719	int err = 0;
		3720	row=i+1;
		3721	if (GetTableCellVal (p3h, P3_CREG, MakePoint (1,row), &asic)) err=1;
		3722	if (GetTableCellVal (p3h, P3_CREG, MakePoint (2,row), &ch)) err=1;
		3723	if (GetTableCellVal (p3h, P3_CREG, MakePoint (3,row), &val)) err=1;
		3724	creg->decaytime=val;
		3725	if (GetTableCellVal (p3h, P3_CREG, MakePoint (4,row), &val)) err=1;
		3726	creg->offset = val;
		3727	if (GetTableCellVal (p3h, P3_CREG, MakePoint (5,row), &val)) err=1;
		3728	creg->fineadj_unipol = val;
		3729	if (GetTableCellVal (p3h, P3_CREG, MakePoint (6,row), &val)) err=1;
		3730	creg->fineadj_diff = val;
		3731	if (GetTableCellVal (p3h, P3_CREG, MakePoint (7,row), &val)) err=1;
		3732	creg->tpenb = val;
		3733	//sa02Printf("===%d %d\n",i, val);
		3734	if (GetTableCellVal (p3h, P3_CREG, MakePoint (8,row), &val)) err=1;
		3735	creg->kill = val;
		3736	creg->unused=0;
		3737	board=i/144;
		3738	if (mask & (1<<board) ) sa02Cmd(board,SA0x_ASIC0_CREG, cdata, asic, ch,1,response);
		3739	if (sa02Verbose >0) {
		3740	sa02Printf("===%d\n",i);
		3741	}
		3742	if (err) sa02Printf("* Table read error at row %d *\n",row);
		3743	if (ctrl_c) {
		3744	break;
		3745	}
		3746	}
		3747	sa02Printf("Channel Parameters Uploaded to the ASICs\n");
		3748
		3749	}
		3750	SetCtrlAttribute (panel, control, ATTR_DIMMED, 0);
		3751	break;
		3752	}
		3753	return 0;
		3754	}
		3755
		3756	int CVICALLBACK UploadFPGAParameters (int panel, int control, int event,
		3757	void *callbackData, int eventData1, int eventData2) {
		3758
		3759	int n=0;
		3760	int i=0;
		3761	int nb=0;
		3762	#define NDIM 400
		3763	int asic=0;
		3764	char buf[NDIM];
		3765	char cmd[NDIM];
		3766	char sasic[NDIM];
		3767	uint32_t sa02code;
		3768	uint32_t board;
		3769	uint32_t response[2]= {0,0};
		3770
		3771	switch (event) {
		3772	case EVENT_COMMIT: {
		3773	uint16_t mask=GetConnectedFebMask();
		3774	SetCtrlAttribute (panel, control, ATTR_DIMMED, 1);
		3775
		3776	GetNumTextBoxLines(p3h, P3_FPGAPAR,&n);
		3777	for (i=0; i<n; i++) {
		3778	GetTextBoxLine(p3h, P3_FPGAPAR, i, buf);
		3779	nb = sscanf(buf,"%s%s",cmd,sasic);
		3780	asic = strtoul (sasic,NULL,0);
		3781	sa02code = sa02GetCmdCode(cmd);
		3782	if (strcmp(cmd,"MUXASIC")==0) {
		3783	asic = sa02MuxMap(asic);
		3784	}
		3785	for (board = 0; board < 4; board ++) if ( mask & (1 << board) ) sa02Cmd(board,sa02code, asic, 0, 0, 2,response);
		3786	sa02Printf("%s\n",buf);
		3787	}
		3788	sa02Printf("FPGA Parameters Uploaded to FEBS\n");
		3789	SetCtrlAttribute (panel, control, ATTR_DIMMED, 0);
		3790	break;
		3791	}
		3792	}
		3793	return 0;
		3794	}
		3795
		3796	int CVICALLBACK SetSelectionToVal (int panel, int control, int event,
		3797	void *callbackData, int eventData1, int eventData2) {
		3798	int state, input_cid=-1,output_cid=-1;
		3799	Rect trange;
		3800	unsigned short value;
		3801	switch (event) {
		3802	case EVENT_COMMIT:
		3803	switch (control) {
		3804	case P3_SETSELCPAR:
		3805	input_cid=P3_SETCPAR;
		3806	output_cid=P3_CREG;
		3807	break;
		3808	case P3_SETSELGPAR:
		3809	input_cid=P3_SETGPAR;
		3810	output_cid=P3_GREG;
		3811	break;
		3812
		3813	}
		3814	state = GetTableSelection (p3h, output_cid, &trange);
		3815	if ((trange.top!=0)&&(trange.left!=0)) {
		3816	GetCtrlVal(p3h,input_cid, &value);
		3817	state = FillTableCellRange (p3h, output_cid, trange, value);
		3818	}
		3819	break;
		3820	}
		3821	return 0;
		3822	}
		3823
		3824	int CVICALLBACK SelectMux (int panel, int control, int event,
		3825	void *callbackData, int eventData1, int eventData2) {
		3826	int cid[4]= {P3_MUX0,P3_MUX1,P3_MUX2,P3_MUX3};
		3827	int id=0,i;
		3828	uint32_t sa02code;
		3829	uint32_t board;
		3830	uint32_t response[2]= {0,0};
		3831
		3832	switch (event) {
		3833	case EVENT_COMMIT:
		3834
		3835	switch (control) {
		3836	case P3_MUX0:
		3837	id=0;
		3838	break;
		3839	case P3_MUX1:
		3840	id=1;
		3841	break;
		3842	case P3_MUX2:
		3843	id=2;
		3844	break;
		3845	case P3_MUX3:
		3846	id=3;
		3847	break;
		3848	default:
		3849	id=0;
		3850	}
		3851	SetCtrlVal(panel,control,1);
		3852	sa02code = sa02GetCmdCode("MUX");
		3853	GetCtrlVal(p1h,P1_BOARDNUMBER,&board);
		3854	sa02Cmd(board,sa02code, id, 0, 0, 2,response);
		3855
		3856
		3857	for (i=0; i<4; i++) {
		3858	if (id!= i) {
		3859	SetCtrlVal(panel,cid[i],0);
		3860	}
		3861	}
		3862	sa02Printf("MUX %d\n",id);
		3863	break;
		3864	}
		3865	return 0;
		3866	}
		3867
		3868	int CVICALLBACK UploadFromPanels (int panel, int control, int event,
		3869	void *callbackData, int eventData1, int eventData2) {
		3870	switch (event) {
		3871	case EVENT_COMMIT:
		3872	UploadFPGAParameters(panel,control,event,callbackData,eventData1,eventData2);
		3873	UploadChannelParameters(panel,control,event,callbackData,eventData1,eventData2);
		3874	UploadGlobalParameters(panel,control,event,callbackData,eventData1,eventData2);
		3875	break;
		3876	}
		3877	return 0;
		3878	}
		3879
		3880	double erf(double x, double par[], int npar) {
		3881	double y=0;
		3882	double x0= (x-par[0])*par[1];
		3883	Erf(x0,&y);
		3884	return (y);
		3885	}
		3886
		3887	int CVICALLBACK FitH2D (int panel, int control, int event,
		3888	void *callbackData, int eventData1, int eventData2) {
		3889	char name[MAX_PATHNAME_LEN];
		3890
		3891	switch (event) {
		3892	case EVENT_COMMIT: {
		3893	//sprintf(name ,"C:\\root\\bin\\root.exe");
		3894	int status;
		3895	char dfile[MAX_PATHNAME_LEN];
		3896	char efile[MAX_PATHNAME_LEN];
		3897
		3898	status = FileSelectPopup ("data", "*.th2d", ".th2d",
		3899	"Izberi datoteko s histogramom",
		3900	VAL_LOAD_BUTTON, 0, 0, 1, 0, efile);
		3901	EscapeString(efile,dfile);
		3902	sprintf(name ,"C:/root/bin/root.exe ../macros/sa02fit.cxx(\\\"%s\\\")", dfile);
		3903
		3904
		3905
		3906	sa02Printf("%s\n",name);
		3907
		3908	LaunchExecutable(name);
		3909
		3910
		3911	}
		3912	break;
		3913	}
		3914	return 0;
		3915	}
		3916
		3917	double Round(double x) {
		3918
		3919	int ix= (int)x;
		3920	if (x>0) {
		3921	if (x - ix > 0.5 ) {
		3922	return ix+1;
		3923	} else {
		3924	return ix;
		3925	}
		3926	} else {
		3927	if (x - ix < -0.5 ) {
		3928	return ix-1;
		3929	} else {
		3930	return ix;
		3931	}
		3932	}
		3933
		3934
		3935	}
		3936
		3937	//const double ffine = -1.45; // dac steps/offset unit (fine)
		3938	const double foffset = -13.; // dac steps/offset unit (coarse)
		3939	const double ffine = foffset/16.; // dac steps/offset unit (fine)
		3940
		3941	double sa02getshift(int offset, int fineadj_unipol ) {
		3942
		3943	int c=offset;
		3944	int f=fineadj_unipol;
		3945	if (c>7) {
		3946	c-=16;
		3947	}
		3948	if (f>7) {
		3949	f-=16;
		3950	}
		3951	return foffsetc+ffinef;
		3952	}
		3953
		3954	double sa02getoffset(double x, double fx, int *dx) {
		3955
		3956	*dx = (int) Round(x/ fx) ;
		3957	if (*dx>7) {
		3958	*dx=7;
		3959	}
		3960	if (*dx<-8) {
		3961	*dx=-8;
		3962	}
		3963	x=x-(dx)fx;
		3964	if (*dx<0) {
		3965	*dx+=16;
		3966	}
		3967	return x;
		3968	}
		3969
		3970	//______________________________________________________________________________
		3971	double GetMean(int fNpoints, double fX, double fY) {
		3972	// Return mean value of X
		3973	int i;
		3974	double sumw = 0;
		3975	double sumwx = 0;
		3976	if (fNpoints <= 0) {
		3977	return 0;
		3978	}
		3979
		3980	for (i=0; i<fNpoints; i++) {
		3981	sumw += fY[i];
		3982	sumwx += fX[i]* fY[i];
		3983	}
		3984	return sumwx/sumw;
		3985	}
		3986
		3987	//______________________________________________________________________________
		3988	double GetRMS(int fNpoints, double fX, double fY) {
		3989	// Return RMS of X
		3990
		3991	int i;
		3992	double sumw = 0, sumwx = 0,mean,rms2;
		3993	double sumwx2 = 0;
		3994	if (fNpoints <= 0) {
		3995	return 0;
		3996	}
		3997
		3998	for (i=0; i<fNpoints; i++) {
		3999	sumwx += fX[i]* fY[i];
		4000	sumw += fY[i];
		4001	sumwx2 += fX[i]* fX[i]* fY[i];
		4002
		4003	}
		4004	if (sumw <= 0) {
		4005	return 0;
		4006	}
		4007	mean = sumwx/sumw;
		4008	rms2 = fabs(sumwx2/sumw -mean*mean);
		4009	return sqrt(rms2);
		4010	}
		4011
		4012
		4013	int FitGraph(int mode, int n, double x, double y, double *par) {
		4014	const double threshold=0.5;
		4015	ssize_t i,imax,imin;
		4016	double dmax,dmin;
		4017	// double rms=0;
		4018	// double sum=0;
		4019
		4020	MaxMin1D(y,n,&dmax,&imax,&dmin,&imin);
		4021	switch (mode) {
		4022	case 0:
		4023	par[0]=x[imax];
		4024	par[1]=0;
		4025	break;
		4026	case 1:
		4027	for (i=0; i<n; i++)
		4028	if (y[i]>threshold) {
		4029	par[0]=x[i];
		4030	}
		4031	par[1]=0;
		4032	break;
		4033	case 2:
		4034	par[0]=GetMean(n,x,y);
		4035	par[1]=GetRMS(n,x,y);
		4036	break;
		4037	case 3:
		4038	break;
		4039	case 4: {
		4040	int npar=2;
		4041	double fitpar[2];
		4042	double rms;
		4043	NonLinearFit (y, x, datayfit,n, erf, fitpar, npar, &rms);
		4044	par[0]=0;
		4045	par[1]=0;
		4046	break;
		4047	}
		4048	default:
		4049	break;
		4050	}
		4051	return 0;
		4052	}
		4053
		4054	int CVICALLBACK FitH2DCoarse (int panel, int control, int event,
		4055	void *callbackData, int eventData1, int eventData2) {
		4056	double mean[14424];
		4057	double rms[14424];
		4058	int ix,iy;
		4059
		4060	double fpar[3]= {0,0,0};
		4061	int h2=0;
		4062	switch (event) {
		4063	case EVENT_COMMIT: {
		4064	unsigned short offsets[14424];
		4065	double x;
		4066	int offset=0, fineadj_unipol=0;
		4067	//unsigned short val;
		4068	double mean0,rms0;
		4069	uint16_t mask=GetConnectedFebMask();
		4070	int nch = H2DGetNbinsX(h2);
		4071	int npt = H2DGetNbinsY(h2);
		4072	int fitmode =0;
		4073	double minx = H2DGetMinX(h2);
		4074	double stepx = H2DGetStepX(h2);
		4075	GetCtrlVal(p3h,P3_FITMODE,&fitmode);
		4076	GetCtrlVal(p3h,P3_TARGETOFFSET,&mean0);
		4077	GetCtrlVal(p3h,P3_TARGETRMS,&rms0);
		4078	for (iy=0; iy < npt; iy++ ) {
		4079	datax[iy] = H2DGetYBinCenter(h2,iy);
		4080	}
		4081	GetTableCellRangeVals (p3h, P3_CREG, MakeRect (1, 4, 144*4, 2), offsets, VAL_ROW_MAJOR);
		4082	for (ix=0; ix < nch; ix++ ) {
		4083	if (!(mask & (1<<(ix/144)) )) {
		4084	mean[ix] = datax[0];
		4085	rms[ix] = 0;
		4086	continue;
		4087	}
		4088	for (iy=0; iy < npt; iy++ ) {
		4089	datay[iy] = H2DGetBinContent(h2,ix,iy); // /H2DGetMax(h2);
		4090	}
		4091	FitGraph(fitmode, npt, datax , datay, fpar);
		4092	mean[ix]=fpar[0];
		4093	rms[ix] =fpar[1];
		4094	offset = offsets[ix*2];
		4095	fineadj_unipol = offsets[ix*2+1];
		4096
		4097	x = sa02getshift(offset, fineadj_unipol);
		4098	x += (mean0-(mean[ix]+rms0*rms[ix]));
		4099	/*if (x<0) {
		4100	sa02Printf(" ch. %d mean+%fsigma %g above threshold %f \n",ix, rms0,mean[ix]+rms0rms[ix],mean0);
		4101	}*/
		4102	x = sa02getoffset(x, foffset, &offset);
		4103	x = sa02getoffset(x, ffine , &fineadj_unipol);
		4104	//sa02Printf("offsets ch. %d mean=%f rms %f shift=%f calcshift=%f offset %d fineadj %d\n",ix, mean[ix],rms[ix], x, sa02getshift(offset, fineadj_unipol),offset, fineadj_unipol);
		4105	offsets[ix*2]=(unsigned short) offset;
		4106	offsets[ix*2+1]=(unsigned short) fineadj_unipol;
		4107	ProcessSystemEvents();
		4108	}
		4109
		4110	SetTableCellRangeVals (p3h, P3_CREG, MakeRect (1, 4, 144*4, 2), offsets, VAL_ROW_MAJOR);
		4111
		4112
		4113	if (nch>0) {
		4114	if (plothandle2dfit) {
		4115	DeleteGraphPlot (p1h, P1_GRAPH2D, plothandle2dfit, VAL_IMMEDIATE_DRAW);
		4116	}
		4117	plothandle2dfit = PlotWaveform (p1h, P1_GRAPH2D, mean, nch,
		4118	VAL_DOUBLE, 1.0, 0.0, minx,
		4119	stepx, VAL_FAT_LINE,
		4120	VAL_EMPTY_SQUARE, VAL_SOLID, 1,
		4121	VAL_YELLOW);
		4122	if (plothandleslix) {
		4123	DeleteGraphPlot (p1h, P1_GRAPHY, plothandleslix, VAL_IMMEDIATE_DRAW);
		4124	}
		4125
		4126	plothandleslix = PlotWaveform (p1h, P1_GRAPHY, rms, nch,
		4127	VAL_DOUBLE, 1.0, 0.0, minx,
		4128	stepx, VAL_FAT_LINE,
		4129	VAL_EMPTY_SQUARE, VAL_SOLID, 1,
		4130	VAL_BLUE);
		4131	sa02Printf("offset calculated:\n");
		4132	}
		4133	}
		4134	break;
		4135	}
		4136	return 0;
		4137	}
		4138
		4139	int CVICALLBACK LedCB (int panel, int control, int event,
		4140	void *callbackData, int eventData1, int eventData2) {
		4141
		4142	if (!gBELLEPTS)return 0;
		4143
		4144	switch (event) {
		4145
		4146	case EVENT_COMMIT: {
		4147	char saddress[0xFF];
		4148	uint32_t address;
		4149	uint32_t value=0;
		4150	GetCtrlVal(p3h,P3_ADDRESS, saddress);
		4151	address = strtoul (saddress,NULL,0);
		4152	VME_A32D32_R(address+FEB_DEADBEEF, &value);
		4153	sa02Printf("READ at FEB_DEADBEEF 0x%08x\n", value);
		4154
		4155
		4156	GetCtrlVal(p1h,P1_PTSLED,&value);
		4157	value++;
		4158	sa02Printf("LedCB ADDR 0x%08x VAL %d\n",address, value);
		4159	//VME_A24D32_W(address,&value);
		4160
		4161	VME_A32D32_W(address,value);
		4162	/*
		4163	NIM standard level ports.
		4164
		4165	You should write 0x7600 to address : baseaddress + 4 .
		4166
		4167	0x7600 means the connection
		4168	CLKOUT1 -> 7 -> CLK_VOUT1 (VOUT1 pin of FPGA)
		4169	CLKOUT0 -> 6 -> CLK_VOUT0 (VOUT1 pin of FPGA)
		4170	SCLK -> 0 -> CLK_IN (internal clock)
		4171	PCLK -> 0 -> CLK_IN (internal clock)
		4172	*/
		4173
		4174	if (value==2) {
		4175	value=0x7600;
		4176	} else {
		4177	value=0;
		4178	}
		4179	VME_A32D32_W(address+4,value); // enable outputs
		4180	}
		4181	sa02Printf("SizeOf(Double)=%d\n",sizeof(double));
		4182	break;
		4183	}
		4184	return 0;
		4185	}
		4186
		4187	int CVICALLBACK SetPositionAndMux (int panel, int control, int event,
		4188	void *callbackData, int eventData1, int eventData2) {
		4189	const float fx= (float)(1000./0.3595); // 4M scaling factor steps/mm
		4190	int chx,x0,chy,y0;
		4191	float gapx,gapy, dx , dy;
		4192
		4193	switch (event) {
		4194	case EVENT_COMMIT:
		4195	GetCtrlVal (p2h, P2_CHX, &chx);
		4196	GetCtrlVal (p2h, P2_CHY, &chy);
		4197	GetCtrlVal (p2h, P2_GAPX, &gapx);
		4198	GetCtrlVal (p2h, P2_GAPX, &gapy);
		4199	GetCtrlVal (p2h, P2_DX, &dx);
		4200	GetCtrlVal (p2h, P2_DX, &dy);
		4201	GetCtrlVal (p2h, P2_XC, &x0);
		4202	GetCtrlVal (p2h, P2_YC, &y0);
		4203	y0 = (int)(y0 - 5.5* fx * dy - gapy * fx * 0.5);
		4204	x0 = (int)(x0 - 5.5* fx * dx - gapx * fx * 0.5);
		4205	if (gMIKRO_Y) {
		4206	posrec.yset = (int32_t)(y0+dy fx chy);
		4207	if (chy>5) {
		4208	posrec.yset +=gapy * fx;
		4209	}
		4210	MIKRO_MoveTo (MIKRO_Y, posrec.yset);
		4211	sa02Printf("->MIKRO_MoveTo (2, y);%d\n",posrec.yset);
		4212	}
		4213	if (gMIKRO_X) {
		4214	posrec.xset=(int32_t)(x0+dxfxchx);
		4215	if (chx>5) {
		4216	posrec.xset +=gapx * fx;
		4217	}
		4218	MIKRO_MoveTo (MIKRO_X, posrec.xset);
		4219	sa02Printf("->MIKRO_MoveTo (1, x);%d\n",posrec.xset);
		4220	}
		4221	// GetCtrlVal(p1h,P1_BOARDTYPE,&sa02BoardType);
		4222	SetCMon(chx,chy);
		4223	break;
		4224	}
		4225	return 0;
		4226	}
		4227
		4228	int CVICALLBACK SetCenter (int panel, int control, int event,
		4229	void *callbackData, int eventData1, int eventData2) {
		4230	int x0,y0;
		4231	switch (event) {
		4232	case EVENT_COMMIT:
		4233	GetCtrlVal (p2h, P2_XC, &x0);
		4234	GetCtrlVal (p2h, P2_YC, &y0);
		4235	if (gMIKRO_X) MIKRO_MoveTo (MIKRO_X, x0);
		4236	if (gMIKRO_Y) MIKRO_MoveTo (MIKRO_Y, y0);
		4237	break;
		4238	}
		4239	return 0;
		4240	}
		4241
		4242	void CVICALLBACK EndOfThread ( CmtThreadPoolHandle poolhandle,
		4243	CmtThreadFunctionID functionID, unsigned int event,
		4244	int value, void *callbackData ) {
		4245
		4246	daq_on=0;
		4247	SetDimming(0);
		4248	sa02Printf("End of Thread \n");
		4249	return ;
		4250
		4251	}
		4252
		4253	int Asic_TENB_Shift( void ) {
		4254
		4255	int i,stanje;
		4256	unsigned short inmask[144], outmask[144], tmp;
		4257	for (int board = 0; board<4; board++) {
		4258	stanje = GetTableCellRangeVals (p3h, P3_CREG, MakeRect (1+board*144, 7, 144, 1),
		4259	inmask, VAL_COLUMN_MAJOR);
		4260	tmp = inmask[143];
		4261	for (i=0; i<143; i++) {
		4262	outmask[i+1]=inmask[i];
		4263	}
		4264	outmask[0]=tmp;
		4265
		4266	stanje = SetTableCellRangeVals (p3h, P3_CREG, MakeRect (1+board*144, 7, 144, 1),
		4267	outmask, VAL_COLUMN_MAJOR);
		4268
		4269	}
		4270	return 0;
		4271	}
		4272
		4273	int CVICALLBACK daq_scanpar (void *functionData) {
		4274
		4275
		4276	char filename[0xFF];
		4277	int scanpar=0;
		4278	int ix, x0,dx,nx;
		4279	int value,state;
		4280	Rect save_range,trange;
		4281	int cid=0;
		4282	int daqexe;
		4283	time_t t,told=0, tstart;
		4284	FILE *fp;
		4285	int spar;
		4286	int nch;
		4287	const int maxrange[20]= {0,0,8,16,16,16,2,2,2,0, 4,4,4,2,256,4,512};
		4288
		4289	trange.top=0;
		4290	trange.left=0;
		4291
		4292	GetCtrlVal(p3h,P3_SCANPAR, &scanpar);
		4293	sa02Printf("%d\n",scanpar);
		4294	GetCtrlVal(p3h,P3_X0, &x0);
		4295	GetCtrlVal(p3h,P3_DX, &dx);
		4296	GetCtrlVal(p3h,P3_NX, &nx);
		4297	GetCtrlVal(p3h,P3_DAQEXE,&daqexe);
		4298	GetCtrlVal(p1h,P1_OUTPUTFILE, filename);
		4299
		4300
		4301	if (!scanpar) {
		4302	return 0;
		4303	}
		4304	if (scanpar>10) {
		4305	cid=P3_GREG;
		4306	spar=scanpar-10;
		4307	nch=4*4;
		4308
		4309	} else {
		4310	cid=P3_CREG;
		4311	spar=scanpar;
		4312	nch=144*4;
		4313
		4314	}
		4315	if (spar==1) {
		4316	spar=7;
		4317	}
		4318	sa02Printf("Range:%d\n",maxrange[scanpar-1]);
		4319	state = GetTableSelection (p3h, cid, &save_range);
		4320
		4321	trange = MakeRect (1, spar, nch, 1);
		4322	state = SetTableSelection (p3h, cid, trange);
		4323	if ((trange.top!=0)&&(trange.left!=0)) {
		4324
		4325
		4326
		4327	time(&t);
		4328	tstart=t;
		4329	if (daqexe) {
		4330	iteratorrec.id = ITERATORREC_ID;
		4331	iteratorrec.len = sizeof(iteratorrec);
		4332	iteratorrec.value = x0;
		4333	iteratorrec.n = nx;
		4334	iteratorrec.step = dx;
		4335	iteratorrec.level = 2;
		4336	fp = fopen(filename, "ab");
		4337	if(fp) {
		4338	fwrite (&datrec, 1, datrec.len, fp);
		4339	fclose(fp);
		4340	}
		4341	sa02Printf("new ITERATORREC recid=0x%x\n", iteratorrec.id);
		4342	}
		4343
		4344
		4345	for (ix=0; ix<nx; ix++) {
		4346	value = ix*dx + x0;
		4347	if (scanpar!=1) {
		4348	state = FillTableCellRange (p3h, cid, MakeRect (1, spar, nch, 1), value%maxrange[scanpar-1]);
		4349	if (maxrange[scanpar-1] && value/maxrange[scanpar-1]) {
		4350	state = FillTableCellRange (p3h, cid, MakeRect (1, spar-1, nch, 1), value/maxrange[scanpar-1]);
		4351	}
		4352	}
		4353	switch (cid) {
		4354	case P3_CREG:
		4355	UploadChannelParameters(p3h,cid,EVENT_COMMIT,functionData,0,0);
		4356	break;
		4357	case P3_GREG:
		4358	UploadGlobalParameters (p3h,cid,EVENT_COMMIT,functionData,0,0);
		4359	break;
		4360	}
		4361	if (scanpar==1) {
		4362	Asic_TENB_Shift();
		4363	}
		4364	if (t!=told ) {
		4365	ProcessSystemEvents ();
		4366	}
		4367	if (ctrl_c) {
		4368	break;
		4369	}
		4370
		4371	if (daqexe) {
		4372	datrec.id = DATREC_ID;
		4373	datrec.len = sizeof(datrec);
		4374	datrec.cmd =0xBEEF0000+ scanpar;
		4375	datrec.data =value;
		4376	datrec.chip =-1;
		4377	datrec.channel=-1;
		4378	datrec.retval =value;
		4379
		4380	fp = fopen(filename, "ab");
		4381	if(fp) {
		4382	fwrite (&datrec, 1, datrec.len, fp);
		4383	fclose(fp);
		4384	}
		4385	sa02Printf("new DATREC recid=0x%x datrec->cmd=0x%x\n", datrec.id , datrec.cmd);
		4386	daq(NULL);
		4387	sa02Printf("H2D image saved as %s\n", filename);
		4388
		4389	}
		4390	if (ctrl_c) {
		4391	break;
		4392	}
		4393
		4394	if (t!=told ) {
		4395	ProcessSystemEvents ();
		4396	}
		4397	told=t;
		4398	time(&t);
		4399
		4400	}
		4401	}
		4402	state = SetTableSelection (p3h, cid, save_range);
		4403
		4404
		4405
		4406
		4407
		4408	return 0;
		4409	}
		4410
		4411
		4412	int CVICALLBACK ExportParameters (int panel, int control, int event,
		4413	void *callbackData, int eventData1, int eventData2) {
		4414	int status;
		4415	char filename[MAX_PATHNAME_LEN];
		4416	switch (event) {
		4417	case EVENT_COMMIT:
		4418
		4419	status = FileSelectPopup ("./parameters/", ".param", ".param",
		4420	"Export Parameters to file", VAL_SAVE_BUTTON, 0,
		4421	0, 1, 1, filename);
		4422	sa02Printf("ExportParameters to %d\n",MAX_PATHNAME_LEN);
		4423	switch (status) {
		4424	case 1:
		4425	MessagePopup ("Warning", "File exist. Remove it first or choose another file");
		4426	break;
		4427	case 2: {
		4428	int n,i,row,asic,ch;
		4429	unsigned short val;
		4430	time_t t;
		4431	char buf[MAX_PATHNAME_LEN];
		4432	FILE *fp = fopen(filename, "w");
		4433	if (fp) {
		4434	//--------------------------------------------------- Parameters header
		4435	time(&t);
		4436	fprintf(fp, "#Parameter exported from CVI %s\n",ctime(&t) );
		4437	//--------------------------------------------------- FPGA parameters
		4438	GetNumTextBoxLines(p3h, P3_FPGAPAR,&n);
		4439	for (i=0; i<n; i++) {
		4440	GetTextBoxLine(p3h, P3_FPGAPAR, i, buf);
		4441	fprintf(fp, "%s\n",buf);
		4442	}
		4443	//--------------------------------------------------- Global parameters
		4444	for (row=1; row<1+16; row++) {
		4445	int irow = (row-1)%4;
		4446	int iboard = (row-1)/4;
		4447	if ( (row-1)%4 == 0 ) fprintf(fp, "param_board %d\n",iboard);
		4448	fprintf(fp, "## global parameter for chip %d\n",(row-1)%4);
		4449	fprintf(fp, "param_global %d 0x1ffff\n",irow);
		4450	GetTableCellVal (p3h, P3_GREG, MakePoint (1,row), &val);
		4451	fprintf(fp, "phasecmps %d 0x%x\n",irow,val);
		4452	GetTableCellVal (p3h, P3_GREG, MakePoint (2,row), &val);
		4453	fprintf(fp, "gain %d 0x%x\n",irow,val);
		4454	GetTableCellVal (p3h, P3_GREG, MakePoint (3,row), &val);
		4455	fprintf(fp, "shapingtime %d 0x%x\n",irow,val);
		4456	GetTableCellVal (p3h, P3_GREG, MakePoint (4,row), &val);
		4457	fprintf(fp, "comparator %d 0x%x\n",irow,val);
		4458	GetTableCellVal (p3h, P3_GREG, MakePoint (5,row), &val);
		4459	fprintf(fp, "vrdrive %d 0x%x\n",irow,val);
		4460	GetTableCellVal (p3h, P3_GREG, MakePoint (6,row), &val);
		4461	fprintf(fp, "monitor %d 0x%x\n",irow,val);
		4462	GetTableCellVal (p3h, P3_GREG, MakePoint (7,row), &val);
		4463	fprintf(fp, "id %d 0x%x\n",irow,val);
		4464
		4465	fprintf(fp, "load_global %d\n\n\n",irow);
		4466	}
		4467
		4468	//--------------------------------------------------- Channel parameters
		4469	for (i=0; i<144*4; i++) {
		4470	int board = i/144;
		4471	int j= i%144;
		4472	asic=(j/36);
		4473	ch=j%36;
		4474	row=(i+1);
		4475	if (i%36==0) {
		4476	fprintf(fp, "# channel parameter for chip %d\n\n",asic);
		4477	}
		4478
		4479	if (i%144 == 0) fprintf(fp, "param_board %d\n",board);
		4480	fprintf(fp, "param_ch %d %d 0x0000\n",asic,ch);
		4481
		4482	GetTableCellVal (p3h, P3_CREG, MakePoint (3,row), &val);
		4483	fprintf(fp, "decaytime %d %d 0x%x\n",asic,ch,val);
		4484	GetTableCellVal (p3h, P3_CREG, MakePoint (4,row), &val);
		4485	fprintf(fp, "offset %d %d 0x%x\n",asic,ch,val);
		4486	GetTableCellVal (p3h, P3_CREG, MakePoint (5,row), &val);
		4487	fprintf(fp, "fineadj_unipol %d %d 0x%x\n",asic,ch,val);
		4488	GetTableCellVal (p3h, P3_CREG, MakePoint (6,row), &val);
		4489	fprintf(fp, "fineadj_diff %d %d 0x%x\n",asic,ch,val);
		4490	GetTableCellVal (p3h, P3_CREG, MakePoint (7,row), &val);
		4491	fprintf(fp, "tpenb %d %d 0x%x\n",asic,ch,val);
		4492	GetTableCellVal (p3h, P3_CREG, MakePoint (8,row), &val);
		4493	fprintf(fp, "kill %d %d 0x%x\n",asic,ch,val);
		4494	fprintf(fp, "load_ch %d %d\n\n\n",asic,ch);
		4495	}
		4496
		4497	fclose(fp);
		4498
		4499	}
		4500	break;
		4501	}
		4502	}
		4503
		4504	break;
		4505	}
		4506	return 0;
		4507	}
		4508
		4509
		4510
		4511	int ProcessUserEvent(int pID, int rID,int mode){
		4512	ThreadFunctionPtr mythread = NULL;
		4513	if (pID ==p1h && rID == P1_DAQ ) mythread=daq;
		4514	if (pID ==p1h && rID == P1_READOUT ) mythread=daq_readonly;
		4515	if (pID ==p1h && rID == P1_FPGAWRITE ) mythread=MultiFpgaWrite;
		4516	if (pID ==p1h && rID == P1_MULTIFPGAWRITE ) mythread=MultiFpgaWrite;
		4517	if (pID ==p1h && rID == P1_TESTING ) mythread=Testing;
		4518	if (pID ==p2h && rID == P2_DAQ ) mythread=daq_scan;
		4519	if (pID ==p6h && rID == MINIRICH_START ) mythread=daq;
		4520	if (pID ==p2h && rID == P2_RUNSCRIPT ) {
		4521	char scriptname[MAX_PATHNAME_LEN] ;
		4522
		4523	int status = FileSelectPopup ("./scripts/", ".txt", ".txt",
		4524	"Select Script file", VAL_LOAD_BUTTON, 0, 0,
		4525	1, 0, scriptname);
		4526	if (status) {
		4527	SetCtrlVal(p1h, P1_SCRIPTNAME, scriptname );
		4528	mythread=run_script;
		4529	}
		4530	}
		4531	if (pID ==p1h && rID == P1_RUNSCRIPT ) mythread=run_script;
		4532	if (pID ==p3h && rID == P3_DAQ ) mythread=daq_scanpar;
		4533	if (pID ==p4h && rID == P4_DAQ ) mythread=V729_daq;
		4534	if (mythread!=NULL) {
		4535	sa02Printf("New Thread panel=%d button=%d\n", pID, rID);
		4536	ctrl_c=0;
		4537	daq_on = 1;
		4538	SetDimming(1);
		4539	if (mode){
		4540	CmtScheduleThreadPoolFunctionAdv (poolHandle, mythread, &rID,
		4541	DEFAULT_THREAD_PRIORITY,
		4542	EndOfThread,
		4543	EVENT_TP_THREAD_FUNCTION_END,
		4544	NULL, RUN_IN_SCHEDULED_THREAD,
		4545	&tfID);
		4546	} else {
		4547	mythread(NULL);
		4548	}
		4549	}
		4550
		4551	if ( pID==p1h && rID == P1_SLOWC ) {
		4552	uint32_t board;
		4553	GetCtrlVal(p1h,P1_BOARDNUMBER, &board);
		4554	SlowControl(board, NULL);
		4555	}
		4556	// if ( pID==p1h && rID == P1_STEPONE ) StepOne();
		4557	if ( pID==p1h && rID == P1_FEBTESTANA ) FebTestAna();
		4558	if ( pID==p1h && rID == P1_TEST ) FebTest();
		4559	if ( pID==p1h && rID == P1_MODULETEST ) ModuleTest();
		4560
		4561	if ( pID==p1h && rID == P1_GET_FPGA_SERIAL ) {
		4562	int ison=0;
		4563	GetCtrlVal(p1h,P1_BOARDTYPE,&sa02BoardType);
		4564	for (int board=0; board<4; board++) {
		4565	char saddress[0xff]="";
		4566	GetCtrlVal(p1h, hapd_onoff[board], &ison);
		4567	sa02GetSerial(board, saddress);
		4568	sa02Printf("SERIAL FPGA = %s \n", saddress);
		4569	SetCtrlVal(p1h,fpga_serials[board],saddress);
		4570	}
		4571	};
		4572
		4573	if ( ( pID==p1h && rID == P1_STOP )
		4574	\|\| ( pID==p2h && rID == P2_STOP )
		4575	\|\| ( pID==p3h && rID == P3_STOP )
		4576	\|\| ( pID==p6h && rID == MINIRICH_STOP )
		4577	\|\| ( pID==p4h && rID == P4_STOP ) ) {
		4578	sa02Printf("Stopping the Thread %d\n", tfID);
		4579	ctrl_c=1;
		4580	}
		4581	if (pID ==p5h) {
		4582	if (rID == P5_SET_DAC_HV_ON) set_dac(1);
		4583	if (rID == P5_SET_DAC_HV_OFF) set_dac(0);
		4584	if (rID == P5_SET_HV_ON) set_hv(1);
		4585	if (rID == P5_SET_HV_OFF) set_hv(0);
		4586	}
		4587	return 0;
		4588	}
		4589
		4590
		4591
		4592	void CVICALLBACK QueueUserEventCallback (CmtTSQHandle queueHandle, unsigned int event, int value, void *callbackData) {
		4593	//int data= (int ) callbackData;
		4594	int mdata[2];
		4595	CmtReadTSQData (queueHandle, mdata, 1, 0, 0);
		4596	sa02Printf("QueueUserEvent --->TSQ %d %d\n", mdata[0],mdata[1]);
		4597	QueueUserEvent (1001, mdata[0], mdata[1]);
		4598	}
		4599
		4600	/************************* MAIN *************************/
		4601
		4602	int __stdcall WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
		4603	LPSTR lpszCmdLine, int nCmdShow) {
		4604
		4605	char title[0xFF];
		4606	char saddress[0xff]="";
		4607	//uint32_t board;
		4608	int i;
		4609	int status=0;
		4610
		4611	if (InitCVIRTE (hInstance, 0, 0) == 0) {
		4612	return -1; /* out of memory */
		4613	}
		4614
		4615	SetSleepPolicy(VAL_SLEEP_MORE);
		4616	CmtNewThreadPool (MAX_THREADS, &poolHandle);
		4617
		4618	if ( (status = CmtNewTSQ (1, 2*sizeof(int), OPT_TSQ_AUTO_FLUSH_ALL, &pTSQ)) <0)
		4619	printf("CmtNewTSQ cannot be installed\n");
		4620	if ( (status = CmtInstallTSQCallback (pTSQ, EVENT_TSQ_ITEMS_IN_QUEUE, EVENT_TSQ_QUEUE_SIZE,
		4621	QueueUserEventCallback, pTSQData, CmtGetCurrentThreadID(), NULL)) <0)
		4622	printf("CmtInstallTSQCallback cannot be installed\n"); ;
		4623
		4624	SetStdioPort (CVI_STDIO_WINDOW );
		4625
		4626	readIni("febdaq.ini");
		4627
		4628	VME_START(gVME_CONTROLLER);
		4629	if ( gCAEN_V288 ) {
		4630	V288_Map(0,gCAEN_V288);
		4631	V288_Init(0);
		4632	}
		4633
		4634	if (gMIKRO_PORT) {
		4635	MIKRO_Open (gMIKRO_PORT);
		4636	if (gMIKRO_X) MIKRO_Init (gMIKRO_X,0);
		4637	if (gMIKRO_Y) MIKRO_Init (gMIKRO_Y,0);
		4638	if (gMIKRO_Z) MIKRO_Init (gMIKRO_Z,0);
		4639	}
		4640
		4641	if ((p1h = LoadPanel (0, "sa02_CVI.uir", P1)) < 0) return -1;
		4642	if ((p2h = LoadPanel (0, "sa02_CVI.uir", P2)) < 0) return -1;
		4643	if ((p3h = LoadPanel (0, "sa02_CVI.uir", P3)) < 0) return -1;
		4644	if ((p4h = V729_LoadPanel (0, "CAEN_V729\\CAEN_V729_CVI.uir", P4)) < 0) return -1;
		4645	if ((p5h = LoadPanel (0, "sa02_CVI.uir", P5)) < 0) return -1;
		4646	if ((p6h = LoadPanel (0, "ICFA\\minirich.uir", MINIRICH)) < 0) return -1;
		4647	if ((pm1 = LoadMenuBar (p1h, "sa02_CVI.uir", MENU)) < 0) return -1;
		4648
		4649	SetPanelMenuBar(p1h, pm1);
		4650	DisplayPanel (p1h);
		4651
		4652	LoadUirHeader("sa02_CVI.h");
		4653	LoadUirHeader("CAEN_V729\\CAEN_V729_CVI.h");
		4654
		4655	SetCtrlVal(p2h,P2_XC,gCENTER_X);
		4656	SetCtrlVal(p2h,P2_YC,gCENTER_Y);
		4657
		4658	SetCtrlVal(p3h, P3_INPUTFILE,gFEBParam);
		4659	SetParametersFromFile(gFEBParam);
		4660
		4661	SetCtrlAttribute (p1h, P1_GRAPH2D, ATTR_CALLBACK_DATA, (void *)integer_val);
		4662	SetCtrlAttribute (p1h, P1_SLIY, ATTR_CALLBACK_DATA, (void *)integer_val);
		4663	SetCtrlAttribute (p1h, P1_SLIX, ATTR_CALLBACK_DATA, (void *)integer_val);
		4664	SetCtrlAttribute (p1h, P1_NSLIY, ATTR_CALLBACK_DATA, (void *)integer_val);
		4665	SetCtrlAttribute (p1h, P1_NSLIX, ATTR_CALLBACK_DATA, (void *)integer_val);
		4666
		4667	for (i=0; i<12; i++) {
		4668	SetTraceAttributeEx (p1h, chart_control[0], i+1, ATTR_TRACE_LG_TEXT, (char *) slowcname[i]);
		4669	}
		4670
		4671	GetPanelAttribute (p1h, ATTR_TITLE, title );
		4672	if (gVME_CONTROLLER == WIENER_VMEMM) sprintf( title, "%s + WIENER_VMEMM", title );
		4673	if (gVME_CONTROLLER == WIENER_VMUSB) sprintf( title, "%s + WIENER_VMUSB", title );
		4674	if (gVME_CONTROLLER == CAEN_V1718) sprintf( title, "%s + CAEN_V1718", title );
		4675	if (gCAEN_V1495) sprintf( title, "%s + CAEN_V1495", title );
		4676	if (gCAEN_V288 ) sprintf( title, "%s + CAEN_V288", title );
		4677
		4678	if (gBELLEPTS) {
		4679	sprintf( title, "%s + BELLEPTS", title );
		4680	sprintf(saddress,"0x%08x", gBELLEPTS );
		4681	SetCtrlVal(p3h,P3_ADDRESS,saddress );
		4682	}
		4683	if (gMIKRO_PORT)
		4684	sprintf( title, "%s + USE_MIKRO", title );
		4685	else
		4686	sprintf( title, "%s + MIKRO not used", title );
		4687	SetPanelAttribute (p1h, ATTR_TITLE, title );
		4688
		4689	for (i=0; i<4; i++)
		4690	SetCtrlVal(p1h,hapd_onoff[i],gFEBMask&(1<<i));
		4691	SetCtrlVal(p1h,P1_SENDSWTRIG,gTriggerType);
		4692	SetCtrlVal(p1h,P1_TPENB,CHECK_BIT(uInterf,0));
		4693
		4694	sa02SetAddress(strtoul (saddress,NULL,0));
		4695
		4696	LedCB(p1h,P1_PTSLED,EVENT_COMMIT, NULL,0,0);
		4697
		4698
		4699	StdIo2FileCB (p1h, P1_STDIOLOG, EVENT_COMMIT, NULL,0,0);
		4700	InitColors();
		4701	sa02Printf("Panels=%d %d %d %d\n", p1h, p2h,p3h,p4h);
		4702	GetCtrlVal(p1h,P1_VERBOSE,&sa02Verbose);
		4703
		4704	LoadElectronicMap("eid2hapdxy.map");
		4705	icfa_Init();
		4706
		4707
		4708	loop_on=1;
		4709	do {
		4710	GetUserEvent (1, &pID, &rID);
		4711	ProcessUserEvent(pID,rID,1);
		4712	} while (loop_on);
		4713
		4714	CmtDiscardThreadPool (poolHandle);
		4715	DiscardPanel (p4h);
		4716	DiscardPanel (p3h);
		4717	DiscardPanel (p2h);
		4718	DiscardPanel (p1h);
		4719
		4720	if (gMIKRO_PORT) MIKRO_Close ();
		4721
		4722
		4723	VME_STOP();
		4724	return 0;
		4725	}
		4726
		4727	int CVICALLBACK ResetStdOut (int panel, int control, int event,
		4728	void *callbackData, int eventData1, int eventData2) {
		4729	switch (event) {
		4730	case EVENT_COMMIT:
		4731	ResetTextBox (p1h,P1_STDIO,"");
		4732	break;
		4733	}
		4734	return 0;
		4735	}
		4736
		4737	int CVICALLBACK TrgHvMon (int panel, int control, int event,
		4738	void *callbackData, int eventData1, int eventData2) {
		4739	switch (event) {
		4740	case EVENT_TIMER_TICK:
		4741	hvmon=1;
		4742	break;
		4743	}
		4744	return 0;
		4745	}
		4746
		4747
		4748	//---------------------------------------------------------------------
		4749
		4750	int Pts_write(uint32_t addr, uint32_t data ) {
		4751	VME_A32D32_W(addr,data);
		4752	return 0;
		4753	}
		4754
		4755	int Pts_Mwrite(uint32_t addr, uint32_t data ) {
		4756	VME_MW(VME_A32, VME_D32, addr,data);
		4757	return 0;
		4758	}
		4759
		4760	int Pts_read(uint32_t addr, uint32_t *data ) {
		4761	VME_A32D32_R(addr,data);
		4762	return 0;
		4763	}
		4764
		4765	int Pts_Mread(uint32_t addr, uint32_t *data ) {
		4766	VME_MRRST();
		4767	VME_MR(VME_A32, VME_D32,addr, data);
		4768	VME_MREXEC(data);
		4769	return 0;
		4770	}
		4771
		4772
		4773	int Pts_erase( uint32_t addr, int verbose ) {
		4774	uint32_t dum;
		4775
		4776	Pts_write( addr + ADR_CSR1, 0 );
		4777	Delay(0.1);
		4778	Pts_read( addr +ADR_CSR1, &dum);
		4779	if( verbose ) {
		4780	sa02Printf( "CSR1(0x%02x) = 0x%04x\n", ADR_CSR1,dum & 0xffff );
		4781
		4782	}
		4783	Pts_write( addr +ADR_CSR1, CSR1_PROGRAM_ );
		4784	Delay(0.1);
		4785	Pts_read( addr +ADR_CSR1, &dum);
		4786	if( verbose ) {
		4787	sa02Printf( "CSR1(0x%02x) = 0x%04x\n", ADR_CSR1, dum & 0xffff );
		4788
		4789	}
		4790	return 1;
		4791	}
		4792
		4793	int Pts_configure_bit(uint32_t addr, const char *filename, int mode, int verbose ) {
		4794	int c,j;
		4795	int dummyword;
		4796	FILE *fp;
		4797	const long byte_per_dot = BYTE_PER_DOT;
		4798	unsigned long nchar = 0;
		4799
		4800	fp = fopen(filename, "rb");
		4801	if( fp == NULL ) {
		4802	if( verbose ) {
		4803	sa02Printf( "cannot open \"%s\"\n", filename );
		4804	}
		4805	return -1;
		4806	}
		4807	if(verbose) sa02Printf( "file \"%s\" opened.\n", filename );
		4808
		4809	/* ------------------------------------------------------------ *\
		4810	The data for the configuration start from 0xffff_ffff_aa99_aa66
		4811	( cf. xapp138; we don't know the definition of the BIT file )
		4812	\* ------------------------------------------------------------ */
		4813	dummyword = 0;
		4814	do {
		4815	if( (c = getc( fp )) == EOF ) {
		4816	if(verbose) {
		4817	sa02Printf( "EOF detected. Exit.\n");
		4818
		4819
		4820	}
		4821	return -1;
		4822	}
		4823	(c == 0xff) ? dummyword++ : (dummyword=0);
		4824	} while( dummyword < 4 );
		4825
		4826	if( mode == SLAVESERIAL_MODE ) {
		4827	if(verbose) sa02Printf("slave serial mode");
		4828	Pts_write( addr +ADR_MODE, mode );
		4829	Pts_erase( addr, verbose );
		4830	for( j=0; j<32; j++ ) Pts_write( addr + ADR_CFG, 0x1 );
		4831	while( (c=getc(fp))!=EOF ) {
		4832	for( j=0; j<8; j++ ) Pts_write( addr + ADR_CFG, (c>>(7-j))&0x1 );
		4833	nchar++;
		4834	if( verbose && nchar%byte_per_dot==0 ) {
		4835	sa02Printf( "#");
		4836	}
		4837	}
		4838	} else if( mode == SELECTMAP_MODE ) {
		4839	if( verbose ) sa02Printf("select map mode\n");
		4840	Pts_write( addr + ADR_MODE, SELECTMAP_MODE );
		4841	Pts_erase( addr, verbose );
		4842	VME_MWRST();
		4843	for( j=0; j<4; j++ ) Pts_Mwrite( addr + ADR_CFG, 0xff );
		4844	VME_MWEXEC();
		4845
		4846	VME_MWRST();
		4847	while( (c=getc(fp))!=EOF ) {
		4848	int cc = 0;
		4849	for(j=0; j<8; j++) cc \|= ((c&(1<<j))>>j)<<(7-j);
		4850	Pts_Mwrite( addr + ADR_CFG, cc );
		4851	nchar++;
		4852	if( verbose && nchar%byte_per_dot==0 ) {
		4853	VME_MWEXEC();
		4854	VME_MWRST();
		4855	sa02Printf( "#");
		4856
		4857	}
		4858	}
		4859	VME_MWEXEC();
		4860	} else {
		4861	if(verbose) {
		4862	sa02Printf( "\nIllegal mode\n");
		4863
		4864	}
		4865	return -1;
		4866	}
		4867	if(verbose) {
		4868	sa02Printf("\ntotal %ld bits\n", nchar);
		4869	}
		4870	fclose(fp);
		4871	return Pts_check_configure( addr, verbose );
		4872	}
		4873
		4874	int Pts_check_configure( uint32_t addr ,int verbose ) {
		4875	uint32_t csr1_value;
		4876	Pts_read(addr + ADR_CSR1,&csr1_value);
		4877	if(verbose) {
		4878	sa02Printf("CSR1(0x%02x)=0x%04x\n",ADR_CSR1,csr1_value&0xffff);
		4879	}
		4880	if(csr1_value&CSR1_DONE) {
		4881	if(verbose) sa02Printf("configure complete.\n");
		4882	return 1;
		4883	} else {
		4884	if(verbose) sa02Printf("configure not complete.");
		4885	return -1;
		4886	}
		4887	}
		4888
		4889
		4890	int CVICALLBACK PtsDownloadCB (int panel, int control, int event,
		4891	void *callbackData, int eventData1, int eventData2) {
		4892	char filename[254];
		4893	int mode=0;
		4894	char saddress[0xFF];
		4895	uint32_t addr;
		4896
		4897
		4898	switch (event) {
		4899	case EVENT_COMMIT:
		4900	GetCtrlVal(p3h,P3_ADDRESS, saddress);
		4901	addr= strtoul (saddress,NULL,0);
		4902	GetCtrlVal(p3h,P3_PTSFIRMWARE,filename);
		4903	GetCtrlVal(p3h,P3_PTSMODE,&mode);
		4904	if(VME_CONNECTED() >=0 ) {
		4905	Pts_configure_bit( addr , filename, mode, 1 );
		4906	} else {
		4907	MessagePopup ("Warning", "Connect VME!!");
		4908	}
		4909	break;
		4910	}
		4911	return 0;
		4912	}
		4913
		4914
		4915
		4916	int CVICALLBACK SelectPtsOutputCB (int panel, int control, int event,
		4917	void *callbackData, int eventData1, int eventData2) {
		4918	switch (event) {
		4919	case EVENT_COMMIT: {
		4920	unsigned short value;
		4921	GetCtrlVal(panel,control,&value);
		4922	sa02Printf("Selecting Pts Output Channel %d\n",value);
		4923	Sa02SetPtsOutput(value);
		4924	break;
		4925	}
		4926	}
		4927	return 0;
		4928	}
		4929
		4930	int CVICALLBACK SendTriggerTypeCB (int panel, int control, int event,
		4931	void *callbackData, int eventData1, int eventData2) {
		4932	switch (event) {
		4933	case EVENT_COMMIT: {
		4934	int trglen, trg;
		4935	uint16_t mask;
		4936	//int ison;
		4937	GetCtrlVal(p1h,P1_SENDSWTRIG,&trg);
		4938	GetCtrlVal(p1h,P1_INTTRGLEN, &trglen);
		4939	mask=GetConnectedFebMask();
		4940	sa02Printf("Selecting Trigger %d length of the internal triger %d mask =%04x\n", trg, trglen);
		4941	Sa02SelectTriggerWithMaskAndLength (trg, mask, trglen);
		4942
		4943	break;
		4944	}
		4945	}
		4946	return 0;
		4947	}
		4948
		4949	int CVICALLBACK StdIo2FileCB (int panel, int control, int event,
		4950	void *callbackData, int eventData1, int eventData2) {
		4951	switch (event) {
		4952	case EVENT_COMMIT:
		4953	GetCtrlVal(p1h,P1_STDIOLOG, &gLog);
		4954	break;
		4955	}
		4956	return 0;
		4957	}

Subversion Repositories f9daq

(root)//cvi/apps/sa02_daq/cvi/sa02_CVI.c – Rev 326