WebSVN – f9daq – Blame – /cvi/instr/DRS/drs4.c/

Rev	Author	Line No.	Line
217	f9daq	1	#include "H1D.h"
		2	#include "H2D.h"
203	f9daq	3	#include <formatio.h>
195	f9daq	4	#include <utility.h>
		5	#include <ansi_c.h>
203	f9daq	6	#include <cvirte.h>
195	f9daq	7	#include <userint.h>
		8	#include "drs4.h"
203	f9daq	9	#include "drsread.h"
195	f9daq	10
203	f9daq	11	#define MIKRO
		12
		13	#ifdef MIKRO
		14	#include "MIKRO.h"
		15	#endif
		16
195	f9daq	17	static int daq_on;
203	f9daq	18	static int ph, p2,plothandle[4]= {0,0,0,0};
217	f9daq	19	static int scanplothandle;
195	f9daq	20	static int tfID;
		21	static int controlID;
		22
203	f9daq	23	#define MAX_THREADS 10
195	f9daq	24
203	f9daq	25	static CmtThreadPoolHandle poolHandle = 0;
195	f9daq	26
217	f9daq	27	static float gSum[4]={0,0,0,0};
195	f9daq	28	int main (int argc, char *argv[]) {
203	f9daq	29	short port;
		30	if (InitCVIRTE (0, argv, 0) == 0)
		31	return -1; /* out of memory */
		32	if ((ph = LoadPanel (0, "drs4.uir", PANEL)) < 0)
		33	return -1;
		34	if ((p2 = LoadPanel (0, "drs4.uir", SCAN)) < 0)
		35	return -1;
		36	SetStdioPort (CVI_STDIO_WINDOW);
		37	SetSleepPolicy(VAL_SLEEP_MORE);
		38	CmtNewThreadPool (MAX_THREADS, &poolHandle);
		39
		40	DisplayPanel (ph);
		41	DisplayPanel (p2);
		42
		43	#ifdef MIKRO
		44	GetCtrlVal(p2, SCAN_PORT, &port);
		45	if (MIKRO_Open (port)) MessagePopup ("Error", "Mikro Port Not found !\n Change in the GUI") ;
		46	MIKRO_Init(1,0);
		47	MIKRO_Init(2,0);
		48	#endif
		49
		50	RunUserInterface ();
		51	DiscardPanel (ph);
		52	DiscardPanel (p2);
		53	CmtDiscardThreadPool (poolHandle);
		54	MIKRO_Close ();
		55	return 0;
195	f9daq	56	}
		57
		58
210	f9daq	59	char strbuf[0xFF];
195	f9daq	60
210	f9daq	61	int gLog=0;
195	f9daq	62
210	f9daq	63	int printf(const char *format, ...) {
		64	va_list aptr;
		65	int ret;
		66	FILE *flog;
195	f9daq	67
210	f9daq	68	va_start(aptr, format);
		69	ret = vsprintf(strbuf, format, aptr);
		70	va_end(aptr);
		71	SetCtrlVal(ph,PANEL_STDIO,strbuf);
		72
		73	if (gLog) {
		74	flog = fopen ("stdio.log", "a");
		75	fprintf (flog, "%s", strbuf);
		76	fclose (flog);
		77	}
		78	return(ret);
		79	}
		80
		81
		82
195	f9daq	83	static void start_timer (double tout) {
203	f9daq	84	SetCtrlAttribute (ph, PANEL_TIMER, ATTR_INTERVAL, tout);
		85	SetCtrlAttribute (ph, PANEL_TIMER, ATTR_ENABLED, 1);
195	f9daq	86	}
		87
		88	static void stop_timer ( void ) {
203	f9daq	89	SetCtrlAttribute (ph, PANEL_TIMER, ATTR_ENABLED, 0);
		90	DRSSetTimeout();
195	f9daq	91	}
		92
		93
		94
		95
		96	void CVICALLBACK EndOfThread ( CmtThreadPoolHandle poolhandle,
203	f9daq	97	CmtThreadFunctionID functionID, unsigned int event,
		98	int value, void *callbackData ) {
195	f9daq	99
203	f9daq	100	daq_on=0;
		101	//SetDimming(0);
		102	printf("End of Thread \n");
		103	return ;
195	f9daq	104
		105	}
		106
		107
217	f9daq	108	static float xs[4][1024];
203	f9daq	109	int CVICALLBACK daq(void *functionData) {
195	f9daq	110
		111
203	f9daq	112	int neve;
		113	char filename[0xff];
		114	int imask[4];
		115	unsigned long mask;
		116	int frequency;
		117	double trgdelay;
		118	double trglevel;
		119	int trgtype;
		120	int trgchannel;
		121	int trgpolarity;
		122	int verbose;
		123	double range;
		124	int pfreq;
		125	int enabledoutput;
		126	int neveold = 0;
		127	double rate;
		128	int args = (int ) functionData;
217	f9daq	129	double twin[2];
265	f9daq	130
201	f9daq	131
217	f9daq	132
203	f9daq	133	GetCtrlVal(ph, PANEL_CH0, &imask[0] );
		134	GetCtrlVal(ph, PANEL_CH1, &imask[1] );
		135	GetCtrlVal(ph, PANEL_CH2, &imask[2] );
		136	GetCtrlVal(ph, PANEL_CH3, &imask[3] );
		137	mask = 0;
		138	for (int i=0; i<4; i++) {
		139	if (imask[i]) mask \|= (1<<i);
201	f9daq	140	}
203	f9daq	141
265	f9daq	142
		143
203	f9daq	144	GetCtrlVal(ph,PANEL_NEVE, &neve);
		145	GetCtrlVal(ph,PANEL_DEBUG, &verbose);
		146	GetCtrlVal(ph,PANEL_PFREQ, &pfreq);
		147	GetCtrlVal(ph,PANEL_ENABLEDOUTPUT, &enabledoutput);
		148
		149	GetCtrlVal(ph,PANEL_FREQUENCY, &frequency);
		150	GetCtrlVal(ph,PANEL_TRGDELAY, &trgdelay);
		151	GetCtrlVal(ph,PANEL_TRGCHANNEL, &trgchannel);
		152
265	f9daq	153
203	f9daq	154	GetCtrlVal(ph,PANEL_TRGTYPE, &trgtype);
		155	GetCtrlVal(ph,PANEL_TRGLEVEL, &trglevel);
		156	GetCtrlVal(ph,PANEL_TRGPOLARITY, &trgpolarity);
		157	GetCtrlVal(ph,PANEL_RANGE, &range);
		158
217	f9daq	159	GetCtrlVal(ph,PANEL_TWIN0, &twin[0]);
		160	GetCtrlVal(ph,PANEL_TWIN1, &twin[1]);
203	f9daq	161	//printf("mask=0x%x\n",mask);
		162
		163	DRSSetMask( (unsigned char)( mask & 0xF ) );
		164
		165	DRSSetFrequency( frequency );
		166	DRSSetTriggerDelay(trgdelay );
		167	DRSSetTriggerChannel(trgchannel );
		168	DRSSetTriggerType( trgtype );
		169	DRSSetTriggerLevel(trglevel);
		170	DRSSetTriggerPolarity(trgpolarity);
		171
		172	DRSSetRange ( range );
		173
		174
		175
		176	FILE *fp= NULL;
		177
		178	if (enabledoutput) {
217	f9daq	179	if (args[0]) {
		180	GetCtrlVal(ph, PANEL_FILENAME, filename );
		181	fp = fopen(filename,"wb");
		182	} else {
		183	GetCtrlVal(p2, SCAN_FILENAME, filename );
		184	fp = fopen(filename,"ab");
		185	}
203	f9daq	186	}
		187
		188	static unsigned char *buffer;
		189
		190	int buffer_size = 0;
		191	const int nBoards=1;
		192	const int waveDepth=1024;
207	f9daq	193
203	f9daq	194	if (buffer_size == 0) {
207	f9daq	195	buffer_size = 8; // file header + time header
		196	buffer_size += nBoards * (4 + 4(4+waveDepth4)); // bin widths
		197	buffer_size += 24 + nBoards * (8 + 4(8+waveDepth2));
		198	buffer = (unsigned char *)malloc(buffer_size);
		199	}
		200
203	f9daq	201	time_t t=0,told=0, tstart=0;
		202
		203	if (!DRSInit()) {
265	f9daq	204
203	f9daq	205	time(&tstart);
		206	told=tstart;
217	f9daq	207	int nev=0;
		208	for (int k = 0;k<4;k++){
		209	gSum[k]=0;
		210	}
		211	for (int i=0; i<neve; i++) {
203	f9daq	212	start_timer(1);// 1 s timeout
		213	int retval = DRSRead(0);
		214	stop_timer();
		215	int nb = ( retval == 0 && fp ) ? DRSToBuffer( buffer , i ) : 0;
		216	SetCtrlVal(ph,PANEL_CEVE,i);
		217	if (retval) i--;
217	f9daq	218	nev++;
203	f9daq	219	if (!daq_on) break;
		220	time(&t);
		221	if (t!=told ) {
		222	rate = (i-neveold);
		223	printf("%d events in %2.2f min (%d s) Rate %f Hz %s ",i+1, (double)(t-tstart)/60.,(t-tstart), rate , ctime(&t));
		224	GetCtrlVal(ph,PANEL_PFREQ, &pfreq);
		225	neveold = i;
		226	}
		227	told=t;
		228	// Save data
		229	if (nb>0 && fp) fwrite(buffer, 1,nb ,fp);
		230	// Plot Data
217	f9daq	231	for (int k=0; k<4; k++) {
		232	if ( (mask & ( 0x1<<k )) ){
		233	float *t=DRSGetTime(k);
		234	float *x=DRSGetWave(k);
		235	;
		236	for (int j=0 ; j<1024 ; j++) {
		237	xs[k][j]= x[j]*1e-3;
		238
		239	if (t[j]> twin[0] && t[j] < twin[1]) gSum[k]+= fabs(xs[k][j]);
		240	if (verbose) printf("[%d] %d. x= %3.2f y=%3.2f\n", k, i, t[j], x[j] );
		241	//h[k]->Fill( t[i], x[i]*1e-3);
		242	}
203	f9daq	243
217	f9daq	244	if (i % pfreq == 0) {
		245
		246	const int col[4]= {VAL_WHITE,VAL_RED,VAL_GREEN,VAL_BLUE};
		247	if (plothandle[k]) DeleteGraphPlot (ph, PANEL_GRAPH, plothandle[k], VAL_IMMEDIATE_DRAW);
		248	plothandle[k] = PlotXY (ph, PANEL_GRAPH, t, xs[k], 1024, VAL_FLOAT, VAL_FLOAT, VAL_THIN_LINE, VAL_NO_POINT, VAL_SOLID, 1, col[k]);
		249	}
203	f9daq	250	}
217	f9daq	251
203	f9daq	252	}
		253
		254
		255	}
		256	time(&t);
217	f9daq	257	printf("%d events in %2.2f min (%d s) %s",nev, (double)(t-tstart)/60.,t-tstart, ctime(&t));
203	f9daq	258	DRSEnd();
		259	}
		260
		261	if (fp) fclose(fp);
		262
		263	free(buffer);
		264
		265	return 0;
		266
195	f9daq	267	}
		268
		269
		270
203	f9daq	271	int CVICALLBACK scan(void *functionData) {
195	f9daq	272
207	f9daq	273	int dx[3]={0,0,0};
		274	int nx[3]={0,0,0};
		275	int x0[3]={0,0,0};
		276	int ix[3]={0,0,0};
		277	int idx[3]={0,0,0};
203	f9daq	278	int size;
207	f9daq	279	char posrec[4]="POSR";
		280	char runbuf[4]="PRUN";
203	f9daq	281
207	f9daq	282	int n[3];
203	f9daq	283	char filename[0xFF];
		284	int enabledoutput;
		285
		286	FILE *fp;
217	f9daq	287	GetCtrlVal(p2, SCAN_FILENAME, filename );
203	f9daq	288
		289	GetCtrlVal(ph,PANEL_ENABLEDOUTPUT, &enabledoutput);
		290
		291	if ( GetFileInfo(filename,&size) ) {
217	f9daq	292	MessagePopup ("Warning","File exist. Remove it first or choose another file");
		293	return 0;
203	f9daq	294	}
		295	GetCtrlVal(p2, SCAN_STEPX, &dx[0]);
		296	GetCtrlVal(p2, SCAN_STEPY, &dx[1]);
		297	GetCtrlVal(p2, SCAN_NSTEPSX, &nx[0]);
		298	GetCtrlVal(p2, SCAN_NSTEPSY, &nx[1]);
		299	GetCtrlVal(p2, SCAN_STARTX, &x0[0]);
		300	GetCtrlVal(p2, SCAN_STARTY, &x0[1]);
217	f9daq	301	for (int k=0;k<4;k++) {
		302	H2D_Init(k, "charge","Induced charge",
		303	nx[0], x0[0] - dx[0]0.5 ,x0[0] + dx[0] ( nx[0] - 0.5) ,
		304	nx[1], x0[1] - dx[1]0.5 ,x0[1] + dx[1] ( nx[1] - 0.5));
		305	H1D_Init(k, "charge","Induced charge projection x",
		306	nx[0], x0[0] - dx[0]0.5 ,x0[0] + dx[0] ( nx[0] - 0.5) );
		307	H1D_Init(100 + k, "charge","Induced charge projection y",
		308	nx[1], x0[1] - dx[1]0.5 ,x0[1] + dx[1] ( nx[1] - 0.5) );
		309	}
207	f9daq	310	if (enabledoutput) {
		311	fp = fopen(filename,"ab");
		312	if (fp) {
		313	size=36;
		314	fwrite(runbuf, 1,4 ,fp);
		315	fwrite(&size , 1,4 ,fp);
		316	fwrite(x0 , 1,4*3 ,fp);
		317	fwrite(dx , 1,4*3 ,fp);
		318	fwrite(nx , 1,4*3 ,fp);
		319	fclose(fp);
		320	}
		321	}
		322
203	f9daq	323	for (int i=0; i<nx[0]; i++) {
		324
		325	ix[0]= x0[0]+i*dx[0];
		326	#ifdef MIKRO
		327	MIKRO_MoveTo(1,ix[0]);
		328	#endif
		329	SetCtrlVal (p2, SCAN_IX, i);
		330	for (int j=0; j<nx[1]; j++) {
		331
		332	SetCtrlVal (p2, SCAN_IY, j);
		333
		334	ix[1]= x0[1]+j*dx[1];
		335	#ifdef MIKRO
		336	MIKRO_MoveTo(2,ix[1]);
		337
		338	MIKRO_GetPosition(1,&n[0]);
		339	SetCtrlVal (p2, SCAN_XP, n[0]);
		340	MIKRO_GetPosition(2,&n[1]);
		341	SetCtrlVal (p2, SCAN_YP, n[1]);
207	f9daq	342
		343	if (enabledoutput) {
203	f9daq	344	fp = fopen(filename,"ab");
		345	if (fp) {
207	f9daq	346	idx[0]=i;
		347	idx[1]=j;
		348	size=24;
		349	fwrite(posrec, 1,4 ,fp);
		350	fwrite(&size , 1,4 ,fp);
		351	fwrite(n , 1,4*3 ,fp);
		352	fwrite(idx , 1,4*3 ,fp);
203	f9daq	353	fclose(fp);
		354	}
		355	}
		356
		357	#endif
		358	daq(functionData);
217	f9daq	359
		360	for (int k=0;k<4;k++) {
		361	H2D_Fill(k, ix[0], ix[1] , gSum[k] );
		362	H1D_Fill(k, ix[0] , gSum[k] );
		363	H1D_Fill(100+ k, ix[1] , gSum[k] );
		364	}
		365	PlotScanHistogramCB(0,0,EVENT_COMMIT,NULL, 0,0);
203	f9daq	366	if (!daq_on) break;
		367	}
		368	if (!daq_on) break;
		369	}
		370
		371	return 0;
195	f9daq	372	}
		373
203	f9daq	374
195	f9daq	375	int CVICALLBACK StartCB (int panel, int control, int event,
203	f9daq	376	void *callbackData, int eventData1, int eventData2) {
		377	ThreadFunctionPtr mythread = NULL;
		378	switch (event) {
		379
		380	case EVENT_COMMIT:
		381
		382	controlID=0;
		383	if (panel == ph && control == PANEL_START) {
		384	mythread = daq;
		385	controlID= control;
		386	}
		387	if (panel == p2 && control == SCAN_SCAN) mythread = scan;
		388	if (mythread!=NULL) {
		389	printf("New Thread panel=%d button=%d\n", panel, control);
		390
		391	// SetDimming(1);
		392
		393	daq_on=1;
		394	CmtScheduleThreadPoolFunctionAdv (poolHandle, mythread, &controlID,
		395	DEFAULT_THREAD_PRIORITY,
		396	EndOfThread,
		397	EVENT_TP_THREAD_FUNCTION_END,
		398	NULL, RUN_IN_SCHEDULED_THREAD,
		399	&tfID);
		400	}
		401	break;
		402	}
		403	return 0;
195	f9daq	404	}
		405
		406	int CVICALLBACK StopCB (int panel, int control, int event,
203	f9daq	407	void *callbackData, int eventData1, int eventData2) {
		408	switch (event) {
		409	case EVENT_COMMIT:
		410	daq_on=0;
		411	break;
		412	}
		413	return 0;
195	f9daq	414	}
		415
		416	int CVICALLBACK ExitCB (int panel, int control, int event,
203	f9daq	417	void *callbackData, int eventData1, int eventData2) {
		418	switch (event) {
		419	case EVENT_COMMIT:
		420	QuitUserInterface (0);
		421	break;
		422	}
		423	return 0;
195	f9daq	424	}
203	f9daq	425
		426	int CVICALLBACK MoveStageCB (int panel, int control, int event,
		427	void *callbackData, int eventData1, int eventData2) {
		428	int axis=0, step=1000, direction=1, n;
		429	switch (event) {
		430	case EVENT_COMMIT:
		431
		432	if (panel == p2) {
		433	switch (control) {
		434	case SCAN_BR :
		435	axis = 1;
		436	direction = 1;
		437	GetCtrlVal(p2, SCAN_STEPX, &step);
		438	break;
		439	case SCAN_BL :
		440	axis = 1;
		441	direction = -1;
		442	GetCtrlVal(p2, SCAN_STEPX, &step);
		443	break;
		444	case SCAN_BU :
		445	axis = 2;
		446	direction = 1;
		447	GetCtrlVal(p2, SCAN_STEPY, &step);
		448	break;
		449	case SCAN_BD :
		450	axis = 2;
		451	direction = -1;
		452	GetCtrlVal(p2, SCAN_STEPY, &step);
		453	break;
		454	}
		455	#ifdef MIKRO
		456	MIKRO_MoveFor(axis, direction*step );
		457	MIKRO_GetPosition(axis,&n);
		458	if (axis == 1) SetCtrlVal (p2, SCAN_XP, n);
		459	if (axis == 2) SetCtrlVal (p2, SCAN_YP, n);
		460	#endif // MIKRO
		461	}
		462
		463	break;
		464	}
		465	return 0;
		466	}
		467
		468
		469
		470
		471
		472	int CVICALLBACK GoXCB (int panel, int control, int event,
		473	void *callbackData, int eventData1, int eventData2) {
		474	int n2;
		475	switch (event) {
		476	case EVENT_COMMIT:
		477	GetCtrlVal (p2, SCAN_XG, &n2);
		478	#ifdef MIKRO
		479	MIKRO_MoveTo(1,n2);
		480	MIKRO_GetPosition(1,&n2);
		481
		482	#endif
		483	SetCtrlVal (p2, SCAN_XP, n2);
		484	break;
		485	}
		486	return 0;
		487	}
		488
		489	int CVICALLBACK GoYCB (int panel, int control, int event,
		490	void *callbackData, int eventData1, int eventData2) {
		491	int n2;
		492	switch (event) {
		493	case EVENT_COMMIT:
		494	GetCtrlVal (p2, SCAN_YG, &n2);
		495	#ifdef MIKRO
		496	MIKRO_MoveTo(2,n2);
		497	MIKRO_GetPosition(2,&n2);
		498
		499	#endif
		500	SetCtrlVal (p2, SCAN_YP, n2);
		501	break;
		502	}
		503	return 0;
		504	}
		505
		506	int CVICALLBACK GetCurrentPositionCB (int panel, int control, int event,
		507	void *callbackData, int eventData1, int eventData2) {
		508
		509	int n[2];
		510	switch (event) {
		511	case EVENT_COMMIT:
		512	#ifdef MIKRO
		513	MIKRO_GetPosition(1,&n[0]);
		514	SetCtrlVal (p2, SCAN_XP, n[0]);
		515	MIKRO_GetPosition(2,&n[1]);
		516	SetCtrlVal (p2, SCAN_YP, n[1]);
		517	#endif
		518	break;
		519	}
		520	return 0;
		521	}
		522
		523	int CVICALLBACK HomeCB (int panel, int control, int event,
		524	void *callbackData, int eventData1, int eventData2) {
		525	switch (event) {
		526	case EVENT_COMMIT:
		527	#ifdef MIKRO
		528	MIKRO_ReferenceMove(1);
		529	MIKRO_ReferenceMove(2);
		530	GetCurrentPositionCB(panel, control, event, NULL, 0, 0);
		531	#endif
		532	break;
		533	}
		534	return 0;
		535	}
217	f9daq	536
		537	int CVICALLBACK PlotScanHistogramCB (int panel, int control, int event,
		538	void *callbackData, int eventData1, int eventData2) {
		539	int hid=0;
		540	int nx;
		541	int ny;
		542	switch (event) {
		543	case EVENT_COMMIT:
		544	GetCtrlVal (p2, SCAN_CHANNEL, &hid);
		545	GetCtrlVal(p2, SCAN_NSTEPSX, &nx);
		546	GetCtrlVal(p2, SCAN_NSTEPSY, &ny);
		547	if (nx>1 && ny>1) {
		548	H2D_Draw(hid,p2,SCAN_GRAPH,&scanplothandle);
		549	printf("redraw 2d\n");
		550	} else {
		551	if (nx>1) {
		552	printf("redraw 1d x\n");
		553	H1D_Draw(hid,p2,SCAN_GRAPH,&scanplothandle);
		554	}
		555	if (ny>1) {
		556	printf("redraw 1d x\n");
		557	H1D_Draw(100+hid,p2,SCAN_GRAPH,&scanplothandle);
		558	}
		559	}
		560	break;
		561	}
		562	return 0;
		563	}
		564
		565	int CVICALLBACK OpenGuiCB (int panel, int control, int event,
		566	void *callbackData, int eventData1, int eventData2) {
		567	switch (event) {
		568	case EVENT_COMMIT:
		569	DisplayPanel (ph);
		570	DisplayPanel (p2);
		571	break;
		572	}
		573	return 0;
		574	}
265	f9daq	575
		576	int CVICALLBACK CalibrateCB (int panel, int control, int event,
		577	void *callbackData, int eventData1, int eventData2) {
		578	int status = 0;
		579	switch (event) {
		580	case EVENT_COMMIT:
		581	status = DRSCalibrateTiming();
		582	printf("DRSCalibrateTiming() status = %d\n", status);
		583	break;
		584	}
		585	return 0;
		586	}

Subversion Repositories f9daq

(root)/cvi/instr/DRS/drs4.c/ – Rev 265