WebSVN - f9daq - Blame - Rev 285

Rev	Author	Line No.	Line
285	f9daq	1	#include <ansi_c.h>
		2	/* Program qe2d.c za testiranje povrsinske obcutljivosti
		3
		4	Avtor: Samo Korpar
		5	Verzija:
		6	1.00 28.9.2009
		7	-
		8	*/
		9	#include <utility.h>
		10	#include <userint.h>
		11	#include "K617.h"
		12	#include <cvirte.h>
		13	#include "qe2d_ui.h"
		14
		15	#define uSMC_USB
		16	#ifdef uSMC_USB
		17	# include "uSMC.h"
		18	# define uSMC_SERIAL_X "0000000000004925"
		19	# define uSMC_SERIAL_Y "0000000000006030"
		20	# define uSMC_SERIAL_Z "0000000000002894"
		21	const char serials[3][16]= {uSMC_SERIAL_X,uSMC_SERIAL_Y,uSMC_SERIAL_Z};
		22	#endif /* uSMC_USB */
		23
		24	//#define MIKRO_COM 6
		25	#ifdef MIKRO_COM
		26	# include "MIKRO.h"
		27	#endif /* MIKRO_COM */
		28
		29	#define SP2155_PORT 4
		30	#ifdef SP2155_PORT
		31	# include "SP2155.h"
		32	#endif /* SP2155_PORT */
		33
		34	#define PROLOGIX_PORT 5
		35	#define K617_ADDR 3
		36
		37	#define MAXXY 1000
		38	#define MAXWL 1000
		39	const int PosCtrl[3]= {P1_X,P1_Y,P1_Z};
		40	const int ncurroff=10;
		41	const int ncurrmes=3;
		42
		43	static int node[3];
		44	static int CurPos[3]= {0,0,0};
		45	static int p1h,pID,rID,tfID,plh[MAXXY],plqeh[MAXXY];
		46	static int wl[MAXXY][MAXWL];
		47	static float tok[MAXXY][MAXWL],qe[MAXXY][MAXWL],tokoff[MAXXY];
		48
		49	//static float
		50
		51	float getavg(int n) {
		52	int i;
		53	float tok;
		54
		55	tok=0;
		56	for (i=0; i<n; i++)
		57	tok+=K617_get(NULL, NULL);
		58	return (tok/(float)n);
		59	}
		60
		61	int CVICALLBACK cb_timer (int panel, int control, int event, void *callbackData,
		62	int eventData1, int eventData2) {
		63	QueueUserEvent (9000, p1h, P1_TIMER);
		64	return (0);
		65	}
		66
		67
		68	int MDelay(double t) {
		69	while (0.5<t) {
		70	ProcessSystemEvents();
		71	GetUserEvent (0, &pID, &rID);
		72	switch (rID) {
		73	case P1_STOP:
		74	return 1;
		75	break;
		76	}
		77
		78	Delay(0.5);
		79	t-=0.5;
		80	SetCtrlVal(p1h,P1_TOUT,t);
		81	}
		82	Delay(t);
		83	SetCtrlVal(p1h,P1_TOUT,0.0);
		84	return 0;
		85	}
		86
		87	int qescan() {
		88	int i;
		89	int npos,nref;
		90	float wait;
		91	int icwl;
		92	double rcurr;
		93
		94	SetCtrlAttribute (p1h, P1_TIMER, ATTR_ENABLED, 0);
		95	GetCtrlVal (p1h, P1_POSITION, &npos);
		96	#ifdef MIKRO_COM
		97	SetCtrlVal(p1h,P1_STAGELED,1);
		98	for (i=0; i<2; i++) {
		99	GetTableCellVal(p1h,P1_POINTS,MakePoint(i+1,npos+1),&CurPos[i]);
		100	MIKRO_MoveTo(node[i],CurPos[i]);
		101	MIKRO_GetPosition(node[i],&CurPos[i]);
		102	SetCtrlVal(p1h,PosCtrl[i],CurPos[i]);
		103	}
		104	SetCtrlVal(p1h,P1_STAGELED,0);
		105	#endif /* MIKRO_COM */
		106	#ifdef uSMC_USB
		107	SetCtrlVal(p1h,P1_STAGELED,1);
		108	for (i=0; i<2; i++) {
		109	GetTableCellVal(p1h,P1_POINTS,MakePoint(i+1,npos+1),&CurPos[i]);
		110	uSMC_MoveTo(node[i],CurPos[i]);
		111	uSMC_GetPosition (node[i],&CurPos[i]);
		112	SetCtrlVal(p1h,PosCtrl[i],CurPos[i]);
		113	}
		114	SetCtrlVal(p1h,P1_STAGELED,0);
		115	#endif /* uSMC_USB */
		116	K617_trigger_mode(1);
		117	#ifdef SP2155_PORT
		118	SetCtrlVal (p1h, P1_GLED, 1);
		119	SP2155_SetWavelength(1000);
		120	SetCtrlVal (p1h, P1_GLED, 0);
		121	#endif /* SP2155_PORT */
		122
		123
		124	GetCtrlVal (p1h, P1_WAIT0, &wait);
		125	if (MDelay(wait*60.)) return 1;
		126
		127	GetCtrlVal (p1h, P1_WAIT, &wait);
		128	tokoff[npos]=getavg(ncurroff);
		129	SetCtrlVal (p1h, P1_BGRCUR1,tokoff[npos]);
		130	GetCtrlVal (p1h, P1_NREF, &nref);
		131	for (i=0; i<nref; i++) {
		132	icwl=wl[0][i];
		133	#ifdef SP2155_PORT
		134	SetCtrlVal (p1h, P1_GLED, 1);
		135	SP2155_SetWavelength(icwl);
		136	SetCtrlVal (p1h, P1_GLED, 0);
		137	#endif /* SP2155_PORT */
		138	SetCtrlVal (p1h, P1_CWL, icwl);
		139	if (MDelay(wait)) return 1;
		140	rcurr=getavg(ncurrmes);
		141	SetCtrlVal (p1h, P1_CURR, rcurr);
		142	wl[npos][i]=icwl;
		143	tok[npos][i]=-(rcurr-tokoff[npos]);
		144
		145	}
		146	if (plh[npos]) DeleteGraphPlot (p1h, P1_GSAMPLE, plh[npos], VAL_IMMEDIATE_DRAW);
		147	plh[npos] = PlotXY (p1h, P1_GSAMPLE, wl[npos], tok[npos], nref, VAL_INTEGER, VAL_FLOAT,
		148	VAL_THIN_LINE, VAL_EMPTY_SQUARE, VAL_SOLID, 1, VAL_RED);
		149
		150	for (i=0; i<nref; i++)
		151	if (tok[0][i]>1e-12)
		152	qe[npos][i]=qe[0][i]*tok[npos][i]/tok[0][i];
		153	else
		154	qe[npos][i]=0.;
		155
		156	if (plqeh[npos]) DeleteGraphPlot (p1h, P1_GQE, plqeh[npos], VAL_IMMEDIATE_DRAW);
		157	plqeh[npos] = PlotXY (p1h, P1_GQE, wl[npos], qe[npos], nref, VAL_INTEGER,
		158	VAL_FLOAT, VAL_THIN_LINE, VAL_EMPTY_SQUARE,
		159	VAL_SOLID, 1, VAL_BLUE);
		160
		161	K617_trigger_mode(0);
		162	SetCtrlAttribute (p1h, P1_TIMER, ATTR_ENABLED, 1);
		163	#ifdef MIKRO_COM
		164	SetCtrlVal (p1h, P1_STAGELED, 1);
		165	for (i=0; i<2; i++) {
		166	MIKRO_GetPosition (node[i],&CurPos[i]);
		167	SetCtrlVal (p1h,PosCtrl[i],CurPos[i]);
		168	}
		169	SetCtrlVal (p1h, P1_STAGELED, 0);
		170	#endif /* MIKRO_COM */
		171	#ifdef uSMC_USB
		172	SetCtrlVal(p1h,P1_STAGELED,1);
		173	for (i=0; i<2; i++) {
		174	uSMC_GetPosition(node[i],&CurPos[i]);
		175	SetCtrlVal(p1h,PosCtrl[i],CurPos[i]);
		176	}
		177	SetCtrlVal (p1h, P1_STAGELED, 0);
		178	#endif /* uSMC_USB */
		179	return 0;
		180
		181	}
		182
		183
		184	int mcp_positions() {
		185
		186	FILE *fp=fopen("mcp_positions.txt","w");
		187	int i=0,j=0;
		188	int nx=10;
		189	int ny=10;
		190	int minx=130000;
		191	int maxx=280000;
		192	int miny=115000;
		193	int maxy=265000;
		194	fprintf(fp,"30000 124000\n");
		195	for (i=0; i<nx+1; i++) for (j=0; j<ny+1; j++)
		196	fprintf(fp,"%d %d\n",minx+i(maxx-minx)/nx, miny+j(maxy-miny)/ny);
		197	fclose(fp);
		198	return 0;
		199	}
		200
		201	int __stdcall WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
		202	LPSTR lpszCmdLine, int nCmdShow) {
		203
		204	int i,j,iret,nb;
		205	int npos,nref,nrows;
		206	int igr,iwl0,idwl,inwl,ilwl,icwl;
		207	int scan_on;
		208	int irange,vsource;
		209	float vout,wait;
		210	double rcurr;
		211	int hdr[10];
		212	float *fhdr;
		213	float sdata[5];
		214	// char cpref[100];
		215	char pfile[300];
		216	FILE *fp;
		217
		218	scan_on=0;
		219	fhdr=(float *)&hdr[0];
		220
		221	if (InitCVIRTE (hInstance, 0, 0) == 0) return -1; /* out of memory */
		222
		223	mcp_positions();
		224	for (i=0; i<MAXXY; i++) {
		225	tokoff[i]=0;
		226	plh[i]=0;
		227	plqeh[i]=0;
		228	for (j=0; j<MAXWL; j++) {
		229	tok[i][j]=0.;
		230	wl[i][j]=0;
		231	qe[i][j]=0.;
		232	}
		233	}
		234
		235	#ifdef MIKRO_COM
		236	MIKRO_Open(MIKRO_COM);
		237	for (i=0; i<3; i++) {
		238	node[i]=i+1;
		239	MIKRO_Init(node[i],0);
		240	}
		241	#endif /* MIKRO_COM */
		242	#ifdef uSMC_USB
		243	uSMC_Open();
		244	for (i=0; i<3; i++) {
		245	node[i]=uSMC_FindSerial(serials[i])+1;
		246	uSMC_Init(node[i],1);
		247	}
		248	#endif /* uSMC_USB */
		249	#ifdef SP2155_PORT
		250	SP2155_Open (SP2155_PORT);
		251	#endif /* SP2155_PORT */
		252
		253	if ((p1h = LoadPanel (0, "qe2d_ui.uir", P1)) < 0) return -1;
		254	DisplayPanel (p1h);
		255
		256	K617_open(1,PROLOGIX_PORT,K617_ADDR,0,13);
		257	K617_clear();
		258	GetCtrlVal(p1h,P1_RANGE_R,&irange);
		259	K617_current_mode(irange);
		260	K617_zero_correct(1);
		261	K617_data_format(0);
		262	K617_trigger_mode(1);
		263
		264	#ifdef SP2155_PORT
		265	igr=SP2155_GetGrating();
		266	SetCtrlVal (p1h, P1_GRATING, igr);
		267	icwl = SP2155_GetWavelength ();
		268	SetCtrlVal (p1h, P1_CWL, icwl);
		269	#endif /* SP2155_PORT */
		270
		271	QueueUserEvent (1000, p1h, P1_VOUT);
		272	QueueUserEvent (1000, p1h, P1_VSOURCE);
		273	QueueUserEvent (1000, p1h, P1_TIMER);
		274	QueueUserEvent (1000, p1h, P1_WL0);
		275	QueueUserEvent (1000, p1h, P1_POSITION);
		276
		277	fp = fopen ("refqe.txt", "r");
		278	nref=0;
		279	while(1) {
		280	iret=fscanf (fp, " %d %f", &wl[0][nref], &qe[0][nref]);
		281	if (iret==2) nref++;
		282	else break;
		283	}
		284	fclose (fp);
		285	SetCtrlVal (p1h, P1_NREF, nref);
		286	plqeh[0] = PlotXY (p1h, P1_GQE, wl[0], qe[0], nref, VAL_INTEGER,
		287	VAL_FLOAT, VAL_THIN_LINE, VAL_EMPTY_SQUARE,
		288	VAL_SOLID, 1, VAL_BLACK);
		289
		290	#ifdef MIKRO_COM
		291	SetCtrlVal(p1h, P1_STAGELED,1);
		292	for (i=0; i<3; i++) {
		293	MIKRO_GetPosition(node[i],&CurPos[i]);
		294	SetCtrlVal(p1h,PosCtrl[i],CurPos[i]);
		295	}
		296	SetCtrlVal(p1h,P1_STAGELED,0);
		297	#endif /* MIKRO_COM */
		298	#ifdef uSMC_USB
		299	SetCtrlVal(p1h, P1_STAGELED,1);
		300	for (i=0; i<3; i++) {
		301	uSMC_GetPosition(node[i],&CurPos[i]);
		302	SetCtrlVal(p1h,PosCtrl[i],CurPos[i]);
		303	}
		304	SetCtrlVal(p1h, P1_STAGELED,0);
		305	#endif /* uSMC_USB */
		306
		307	do {
		308	GetUserEvent (1, &pID, &rID);
		309	switch (rID) {
		310	case P1_TIMER:
		311	rcurr=K617_get(NULL, NULL);
		312	SetCtrlVal (p1h, P1_CURR, rcurr);
		313	K617_status ();
		314	SetCtrlVal (p1h, P1_VSOURCE, K617Stat.vsource_operate);
		315	break;
		316	case P1_GRATING:
		317	GetCtrlVal (p1h, P1_GRATING, &igr);
		318	#ifdef SP2155_PORT
		319	SetCtrlVal (p1h, P1_GLED, 1);
		320	SP2155_SetGrating (igr);
		321	SetCtrlVal (p1h, P1_GLED, 0);
		322	#endif /* SP2155_PORT */
		323	MessagePopup ("Reminder", "1.Switch the light source!\n2.Adjust the slit!\n3.Load the range file!");
		324	break;
		325	case P1_WL0:
		326	case P1_DWL:
		327	case P1_NWL:
		328	GetCtrlVal (p1h, P1_WL0, &iwl0);
		329	GetCtrlVal (p1h, P1_DWL, &idwl);
		330	GetCtrlVal (p1h, P1_NWL, &inwl);
		331	ilwl=iwl0+(inwl-1)*idwl;
		332	SetCtrlVal (p1h, P1_LWL, ilwl);
		333	break;
		334	case P1_CWL:
		335	GetCtrlVal (p1h, P1_CWL, &icwl);
		336	#ifdef SP2155_PORT
		337	SetCtrlVal (p1h, P1_GLED, 1);
		338	SP2155_SetWavelength (icwl);
		339	SetCtrlVal (p1h, P1_GLED, 0);
		340	#endif /* SP2155_PORT */
		341	break;
		342	case P1_SCAN:
		343	SetCtrlAttribute (p1h, P1_TIMER, ATTR_ENABLED, 0);
		344	GetCtrlVal (p1h, P1_WL0, &iwl0);
		345	GetCtrlVal (p1h, P1_DWL, &idwl);
		346	GetCtrlVal (p1h, P1_NWL, &inwl);
		347	GetCtrlVal (p1h, P1_WAIT, &wait);
		348	K617_trigger_mode(1);
		349	MDelay(2);
		350	for (i=0; i<inwl; i++) {
		351	icwl=iwl0+i*idwl;
		352	#ifdef SP2155_PORT
		353	SetCtrlVal (p1h, P1_GLED, 1);
		354	SP2155_SetWavelength(icwl);
		355	SetCtrlVal (p1h, P1_GLED, 0);
		356	#endif /* SP2155_PORT */
		357	SetCtrlVal (p1h, P1_CWL, icwl);
		358	MDelay(wait);
		359	rcurr=K617_get(NULL, NULL);
		360	SetCtrlVal (p1h, P1_CURR, rcurr);
		361	wl[1][i]=icwl;
		362	tok[1][i]=-rcurr;
		363	}
		364	if (plh[1]) DeleteGraphPlot (p1h, P1_GSAMPLE, plh[1], VAL_IMMEDIATE_DRAW);
		365	plh[1] = PlotXY (p1h, P1_GSAMPLE, wl[1], tok[1], inwl, VAL_INTEGER, VAL_FLOAT,
		366	VAL_THIN_LINE, VAL_EMPTY_SQUARE, VAL_SOLID, 1, VAL_RED);
		367
		368	K617_trigger_mode(0);
		369	SetCtrlAttribute (p1h, P1_TIMER, ATTR_ENABLED, 1);
		370	break;
		371	case P1_READREFCURR:
		372	iret = FileSelectPopup ("", "*.dat", ".dat",
		373	"Izberi binarno datoteko za meritve",
		374	VAL_SELECT_BUTTON, 0, 0, 1, 1, pfile);
		375
		376	if (iret==1) {
		377	fp = fopen (pfile, "rb");
		378	nb=fread(hdr,sizeof(int),5,fp);
		379	//printf("[%d] %d %d %d %d %d\n",nb, hdr[0], hdr[1], hdr[2], hdr[3],hdr[4]);
		380	switch (hdr[0]) {
		381	case 3: {
		382	nb=fread(&hdr[5],sizeof(int),5,fp);
		383	//printf("x=%u y=%u \| i0=%g i1=%g t=%u\t",hdr[5],hdr[6],fhdr[7],fhdr[8],hdr[9]);
		384	}
		385	case 2:
		386	case 1:
		387	nref=hdr[1]/sizeof(int)/5-1;
		388	if (hdr[0]==3) nref--;
		389	//printf("%d [%d] x=%d y=%d\n",hdr[2],nref, hdr[3],hdr[4]);
		390	for (i=0; i<nref; i++) {
		391	nb=fread(sdata,sizeof(float),5,fp);
		392	wl[0][i]=sdata[0];
		393	tok[0][i]=sdata[1];
		394	qe[0][i]=sdata[3];
		395	}
		396	SetCtrlVal (p1h, P1_NREF, nref);
		397	if (plqeh[0]) DeleteGraphPlot (p1h, P1_GQE, plqeh[0], VAL_IMMEDIATE_DRAW);
		398	plqeh[0] = PlotXY (p1h, P1_GQE, wl[0], qe[0], nref, VAL_INTEGER,
		399	VAL_FLOAT, VAL_THIN_LINE, VAL_EMPTY_SQUARE,
		400	VAL_SOLID, 1, VAL_BLACK);
		401	if (plh[0]) DeleteGraphPlot (p1h, P1_GREF, plh[0], VAL_IMMEDIATE_DRAW);
		402	plh[0] = PlotXY (p1h, P1_GREF, wl[0], tok[0], nref, VAL_INTEGER, VAL_FLOAT,
		403	VAL_THIN_LINE, VAL_EMPTY_SQUARE, VAL_SOLID, 1, VAL_RED);
		404	break;
		405	}
		406	fclose(fp);
		407	}
		408	break;
		409	case P1_REFSCAN:
		410	MessagePopup ("Reminder", "Switch the cable to measure the reference PMT current!");
		411	SetCtrlAttribute (p1h, P1_TIMER, ATTR_ENABLED, 0);
		412	#ifdef MIKRO_COM
		413	SetCtrlVal (p1h, P1_STAGELED, 1);
		414	for (i=0; i<2; i++) {
		415	GetTableCellVal(p1h,P1_POINTS,MakePoint(i+1,1),&CurPos[i]);
		416	MIKRO_MoveTo(node[i],CurPos[i]);
		417	MIKRO_GetPosition (node[i],&CurPos[i]);
		418	SetCtrlVal (p1h, PosCtrl[i],CurPos[i]);
		419	}
		420	SetCtrlVal (p1h, P1_STAGELED, 0);
		421	#endif /* MIKRO_COM */
		422	#ifdef uSMC_USB
		423	SetCtrlVal (p1h, P1_STAGELED, 1);
		424	for (i=0; i<2; i++) {
		425	GetTableCellVal(p1h,P1_POINTS,MakePoint(i+1,1),&CurPos[i]);
		426	uSMC_MoveTo(node[i],CurPos[i]);
		427	uSMC_GetPosition (node[i],&CurPos[i]);
		428	SetCtrlVal (p1h, PosCtrl[i],CurPos[i]);
		429	}
		430	SetCtrlVal (p1h, P1_STAGELED, 0);
		431	#endif /* uSMC_USB */
		432	K617_trigger_mode(1);
		433	#ifdef SP2155_PORT
		434	SetCtrlVal (p1h, P1_GLED, 1);
		435	SP2155_SetWavelength(1000);
		436	SetCtrlVal (p1h, P1_GLED, 0);
		437	#endif /* SP2155_PORT */
		438	GetCtrlVal (p1h, P1_WAIT0, &wait);
		439	if (MDelay(wait*60.)) break;
		440	GetCtrlVal (p1h, P1_WAIT, &wait);
		441	tokoff[0]=getavg(ncurroff);
		442	SetCtrlVal (p1h, P1_BGRCUR0,tokoff[0]);
		443	for (i=0; i<nref; i++) {
		444	icwl=wl[0][i];
		445	#ifdef SP2155_PORT
		446	SetCtrlVal (p1h, P1_GLED, 1);
		447	SP2155_SetWavelength(icwl);
		448	SetCtrlVal (p1h, P1_GLED, 0);
		449	#endif /* SP2155_PORT */
		450	SetCtrlVal (p1h, P1_CWL, icwl);
		451	if (MDelay(wait)) break;
		452	rcurr=getavg(ncurrmes);
		453	SetCtrlVal (p1h, P1_CURR, rcurr);
		454	tok[0][i]=-(rcurr-tokoff[0]);
		455	}
		456	if (plh[0]) DeleteGraphPlot (p1h, P1_GREF, plh[0], VAL_IMMEDIATE_DRAW);
		457	plh[0] = PlotXY (p1h, P1_GREF, wl[0], tok[0], nref, VAL_INTEGER, VAL_FLOAT,
		458	VAL_THIN_LINE, VAL_EMPTY_SQUARE, VAL_SOLID, 1, VAL_RED);
		459
		460	K617_trigger_mode(0);
		461	SetCtrlAttribute (p1h, P1_TIMER, ATTR_ENABLED, 1);
		462	break;
		463	case P1_QESCAN:
		464	MessagePopup ("Reminder", "Switch the cable to measure the sample detector current!");
		465	// moved the delay into qescan()
		466	//GetCtrlVal (p1h, P1_WAIT0, &wait);
		467	//if (MDelay(wait*60)) break;
		468
		469	// reset plots for new scan
		470	for (i=1; i<MAXXY; i++) {
		471	if(plqeh[i]) SetPlotAttribute (p1h, P1_GQE, plqeh[i], ATTR_TRACE_COLOR, VAL_LT_GRAY);
		472	if(plh[i]) SetPlotAttribute (p1h, P1_GSAMPLE, plh[i], ATTR_TRACE_COLOR, VAL_LT_GRAY);
		473
		474	plh[i]=0;
		475	plqeh[i]=0;
		476	}
		477	if(plqeh[0]) DeleteGraphPlot (p1h, P1_GQE, plqeh[0], VAL_IMMEDIATE_DRAW);
		478	plqeh[0] = PlotXY (p1h, P1_GQE, wl[0], qe[0], nref, VAL_INTEGER,
		479	VAL_FLOAT, VAL_THIN_LINE, VAL_EMPTY_SQUARE,
		480	VAL_SOLID, 1, VAL_BLACK);
		481	RefreshGraph (p1h, P1_GQE);
		482	RefreshGraph (p1h, P1_GSAMPLE);
		483
		484	qescan();
		485	break;
		486	case P1_QESCANALL:
		487	MessagePopup ("Reminder", "Switch the cable to measure the sample detector current!");
		488	iret=FileSelectPopup ("", "*.dat", ".dat",
		489	"Izberi binarno datoteko za meritve",
		490	VAL_SAVE_BUTTON, 0, 0, 1, 1, pfile);
		491
		492	if (iret==1\|\|(iret==2)) {
		493	// moved the delay into qescan()
		494	//GetCtrlVal (p1h, P1_WAIT0, &wait);
		495	//if (MDelay(wait*60)) break;
		496
		497	// reset plots for new scan
		498	/*DeleteGraphPlot (p1h, P1_GQE, -1, VAL_IMMEDIATE_DRAW);
		499	plqeh[0] = PlotXY (p1h, P1_GQE, wl[0], qe[0], nref, VAL_INTEGER,
		500	VAL_FLOAT, VAL_THIN_LINE, VAL_EMPTY_SQUARE,
		501	VAL_SOLID, 1, VAL_BLACK);
		502	DeleteGraphPlot (p1h, P1_GSAMPLE, -1, VAL_IMMEDIATE_DRAW);
		503	for (i=0; i<MAXXY; i++) {
		504	plh[i]=0;
		505	plqeh[i]=0;
		506	}
		507	*/
		508	for (i=1; i<MAXXY; i++) {
		509	if(plqeh[i]) SetPlotAttribute (p1h, P1_GQE, plqeh[i], ATTR_TRACE_COLOR, VAL_LT_GRAY);
		510	if(plh[i]) SetPlotAttribute (p1h, P1_GSAMPLE, plh[i], ATTR_TRACE_COLOR, VAL_LT_GRAY);
		511
		512	plh[i]=0;
		513	plqeh[i]=0;
		514	}
		515	if(plqeh[0]) DeleteGraphPlot (p1h, P1_GQE, plqeh[0], VAL_IMMEDIATE_DRAW);
		516	plqeh[0] = PlotXY (p1h, P1_GQE, wl[0], qe[0], nref, VAL_INTEGER,
		517	VAL_FLOAT, VAL_THIN_LINE, VAL_EMPTY_SQUARE,
		518	VAL_SOLID, 1, VAL_BLACK);
		519	RefreshGraph (p1h, P1_GQE);
		520	RefreshGraph (p1h, P1_GSAMPLE);
		521
		522
		523
		524	fp = fopen (pfile, "wb");
		525
		526	GetNumTableRows(p1h, P1_POINTS, &nrows);
		527	for (j=1; j<nrows; j++) {
		528	SetCtrlVal (p1h, P1_POSITION, j);
		529	SetTableSelection (p1h, P1_POINTS, MakeRect(j+1,1,1,2));
		530	GetTableCellVal (p1h, P1_POINTS, MakePoint (1,j+1), &CurPos[0]);
		531	GetTableCellVal (p1h, P1_POINTS, MakePoint (2,j+1), &CurPos[1]);
		532	if (CurPos[0] <= 0 && CurPos[1]<= 0) {
		533	j=nrows ;
		534	continue;
		535	}
		536	iret=qescan();
		537	if (iret) break;
		538	GetCtrlVal (p1h, P1_X, &CurPos[0]);
		539	GetCtrlVal (p1h, P1_Y, &CurPos[1]);
		540
		541	hdr[0]=3;//recid 1,2= hdr len=5, 3=hdr len=10
		542	hdr[1]=(nref5+10)sizeof(int);
		543	hdr[2]=j;
		544	hdr[3]=CurPos[0];
		545	hdr[4]=CurPos[1];
		546	GetTableCellVal (p1h, P1_POINTS, MakePoint (1,j+1), &CurPos[0]);
		547	GetTableCellVal (p1h, P1_POINTS, MakePoint (2,j+1), &CurPos[1]);
		548	hdr[5]=CurPos[0];
		549	hdr[6]=CurPos[1];
		550	fhdr[7]=tokoff[0];
		551	fhdr[8]=tokoff[j];
		552	hdr[9]=time(NULL);
		553	//printf("--> %d %d %d %d %d\n", hdr[0],hdr[1],hdr[2],hdr[3],hdr[4]);
		554	fwrite (hdr, sizeof(int), 10, fp);
		555	for (i=0; i<nref; i++) {
		556	sdata[0]=wl[0][i];
		557	sdata[1]=tok[0][i];
		558	sdata[2]=tok[j][i];
		559	sdata[3]=qe[0][i];
		560	sdata[4]=qe[j][i];
		561
		562	fwrite (sdata, sizeof(float), 5, fp);
		563	}
		564	}
		565	fclose (fp);
		566
		567
		568	}
		569
		570	break;
		571	case P1_HO:
		572	// if (!daq_on) {
		573	SetWaitCursor (1);
		574	#ifdef MIKRO_COM
		575	SetCtrlVal(p1h,P1_STAGELED,1);
		576	for (i=0; i<3; i++) MIKRO_ReferenceMove(node[i]);
		577	SetCtrlVal(p1h,P1_STAGELED,0);
		578	#endif /* MIKRO_COM */
		579	#ifdef uSMC_USB
		580	SetCtrlVal(p1h,P1_STAGELED,1);
		581	for (i=0; i<3; i++)uSMC_ReferenceMove(node[i]);
		582	SetCtrlVal(p1h,P1_STAGELED,0);
		583	#endif /* uSMC_USB */
		584	SetWaitCursor (0);
		585	// }
		586	break;
		587	case P1_GOXY:
		588	GetCtrlVal(p1h,P1_POSITION,&npos);
		589	#ifdef MIKRO_COM
		590	SetCtrlVal(p1h,P1_STAGELED,1);
		591	for (i=0; i<2; i++) {
		592	GetTableCellVal(p1h,P1_POINTS,MakePoint(i+1,npos+1),&CurPos[i]);
		593	MIKRO_MoveTo(node[i],CurPos[i]);
		594	MIKRO_GetPosition (node[i],&CurPos[i]);
		595	SetCtrlVal (p1h,PosCtrl[i],CurPos[i]);
		596	}
		597	SetCtrlVal(p1h,P1_STAGELED,0);
		598	#endif /* MIKRO_COM */
		599	#ifdef uSMC_USB
		600	SetCtrlVal(p1h,P1_STAGELED,1);
		601	for (i=0; i<2; i++) {
		602	GetTableCellVal(p1h,P1_POINTS,MakePoint(i+1,npos+1),&CurPos[i]);
		603	uSMC_MoveTo(node[i],CurPos[i]);
		604	uSMC_GetPosition (node[i],&CurPos[i]);
		605	SetCtrlVal (p1h,PosCtrl[i],CurPos[i]);
		606	}
		607	SetCtrlVal(p1h,P1_STAGELED,0);
		608	#endif /* uSMC_USB */
		609	break;
		610	case P1_ZC:
		611	K617_zero_correct(1);
		612	break;
		613	case P1_VOUT:
		614	GetCtrlVal (p1h, P1_VOUT, &vout);
		615	K617_vsource_set (vout);
		616	break;
		617	case P1_VSOURCE:
		618	GetCtrlVal (p1h, P1_VSOURCE, &vsource);
		619	K617_vsource_operate (vsource);
		620	break;
		621	case P1_RANGE_R:
		622	GetCtrlVal(p1h,P1_RANGE_R,&irange);
		623	K617_current_mode(irange);
		624	break;
		625	case P1_LOADPOINTS:
		626	iret = FileSelectPopup ("", "*.txt", ".txt",
		627	"Izberi datoteko s pozicijami",
		628	VAL_LOAD_BUTTON, 0, 0, 1, 0, pfile);
		629	if (iret==1) {
		630	fp = fopen (pfile, "r");
		631	i=1;
		632	while(1) {
		633	iret=fscanf (fp, " %d %d", &CurPos[0], &CurPos[1]);
		634	if (iret==2) {
		635	SetTableCellVal (p1h, P1_POINTS, MakePoint (1,i), CurPos[0]);
		636	SetTableCellVal (p1h, P1_POINTS, MakePoint (2,i), CurPos[1]);
		637	i++;
		638	} else
		639	break;
		640	}
		641	fclose (fp);
		642	}
		643	break;
		644	case P1_SAVEPOINTS:
		645	iret=FileSelectPopup ("", "*.txt", ".txt",
		646	"Izberi datoteko s pozicijami",
		647	VAL_SAVE_BUTTON, 0, 0, 1, 1, pfile);
		648	if ((iret==1)\|\|(iret==2)) {
		649	fp=fopen(pfile,"w");
		650	GetNumTableRows(p1h, P1_POINTS, &i);
		651	for (j=0; j<i;) {
		652	j++;
		653	GetTableCellVal (p1h, P1_POINTS, MakePoint (1,j), &CurPos[0]);
		654	GetTableCellVal (p1h, P1_POINTS, MakePoint (2,j), &CurPos[1]);
		655	fprintf(fp,"%d %d\n", CurPos[0], CurPos[1]);
		656	}
		657	fclose (fp);
		658	}
		659	break;
		660	case P1_SAVEQE:
		661	iret=FileSelectPopup ("", "*.txt", ".txt",
		662	"Izberi datoteko za meritve",
		663	VAL_SAVE_BUTTON, 0, 0, 1, 1, pfile);
		664	if (iret==1\|\|(iret==2)) {
		665	fp = fopen (pfile, "w");
		666	GetCtrlVal (p1h, P1_POSITION, &npos);
		667	for (i=0; i<nref; i++)
		668	fprintf(fp,"%d %g %g %g %g\n",
		669	wl[0][i],tok[0][i],tok[npos][i],qe[0][i],qe[npos][i]);
		670	fclose (fp);
		671	}
		672	break;
		673	case P1_POSITION:
		674	GetCtrlVal(p1h,P1_POSITION,&npos);
		675	SetTableSelection (p1h, P1_POINTS, MakeRect(npos+1,1,1,2));
		676	break;
		677	case P1_READQE:
		678	iret = FileSelectPopup ("", "*.txt", ".txt",
		679	"Izberi referencni QE",
		680	VAL_LOAD_BUTTON, 0, 0, 1, 0, pfile);
		681	if (iret==1) {
		682	fp = fopen (pfile, "r");
		683	nref=0;
		684	while(1) {
		685	iret=fscanf (fp, " %d %f", &wl[0][nref], &qe[0][nref]);
		686	if (iret==2) nref++;
		687	else break;
		688	}
		689	fclose (fp);
		690	SetCtrlVal (p1h, P1_NREF, nref);
		691	if (plqeh[0]) DeleteGraphPlot (p1h, P1_GQE, plqeh[0], VAL_IMMEDIATE_DRAW);
		692	plqeh[0] = PlotXY (p1h, P1_GQE, wl[0], qe[0], nref, VAL_INTEGER,
		693	VAL_FLOAT, VAL_THIN_LINE, VAL_EMPTY_SQUARE,
		694	VAL_SOLID, 1, VAL_BLACK);
		695	}
		696	break;
		697	case P1_GLED:
		698	break;
		699	case P1_ZSET:
		700	GetCtrlVal(p1h,P1_ZSETTO,&CurPos[2]);
		701	#ifdef MIKRO_COM
		702	SetCtrlVal(p1h,P1_STAGELED,1);
		703	MIKRO_MoveTo(node[2],CurPos[2]);
		704	MIKRO_GetPosition (node[2],&CurPos[2]);
		705	SetCtrlVal (p1h,PosCtrl[2],CurPos[2]);
		706	SetCtrlVal(p1h,P1_STAGELED,0);
		707	#endif /* MIKRO_COM */
		708	#ifdef uSMC_USB
		709	SetCtrlVal(p1h,P1_STAGELED,1);
		710	uSMC_MoveTo(node[2],CurPos[2]);
		711	uSMC_GetPosition (node[2],&CurPos[2]);
		712	SetCtrlVal (p1h,PosCtrl[2],CurPos[2]);
		713	SetCtrlVal(p1h,P1_STAGELED,0);
		714	#endif /* uSMC_USB */
		715	break;
		716	}
		717
		718	} while ((rID != P1_EXIT)\|\|scan_on);
		719
		720	DiscardPanel (p1h);
		721
		722	K617_trigger_mode (0);
		723	K617_close ();
		724	#ifdef SP2155_PORT
		725	SP2155_Close ();
		726	#endif /* SP2155_PORT */
		727	#ifdef MIKRO_COM
		728	MIKRO_Close ();
		729	#endif /* MIKRO_COM */
		730	#ifdef uSMC_USB
		731	for (i=0; i<3; i++) uSMC_PowerOff(node[i]);
		732	uSMC_Close();
		733	#endif /* uSMC_USB */
		734
		735	return 0;
		736	}

Subversion Repositories f9daq

(root)/cvi/apps/qe2d.c - Rev 285