WebSVN – f9daq – Diff – /lab/sipmscan/trunk/src/daqscope.C


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include "../include/vxi11_i686/vxi11_user.h"
#include "../include/daqscope.h"
#include "../include/workstation.h"
 
CLINK *clink;
char *savedIP;
const char *allChans[8] = {"CH1","CH2","CH3","CH4","MATH1","MATH2","MATH3","MATH4"};
const char *measType[11] = {"AMP","ARE","DEL","FALL","FREQ","MAX","MEAN","MINI","PK2P","PWI","RIS"};
char *bbq;
 
// Query and command functions to simplify analysis --------------
int vxi11_query(CLINK *clink, const char *mycmd)
{
   char buf[WAVE_LEN];
   memset(buf, 0, WAVE_LEN);
   vxi11_send(clink, mycmd);
   int bytes_returned = vxi11_receive(clink, buf, WAVE_LEN);
   if (bytes_returned > 0)
   {
      printf("%s\n", buf);
   }
   else if (bytes_returned == -15)
      printf("*** [ NOTHING RECEIVED ] ***\n");
 
   return 0;
}
 
void vxi11_command(CLINK *clink,char *mycmd)
{
   char buf[WAVE_LEN];
   memset(buf, 0, WAVE_LEN);
   vxi11_send(clink, mycmd);
}
// ---------------------------------------------------------------
 
// Tektronix unit conversion -------------------------------------
double daqscope::tekunit(char *prefix)
{
   if (strcmp(prefix,"m")==0) return 0.001;
   else if (strcmp(prefix,"u")==0) return 0.000001;
   else if (strcmp(prefix,"n")==0) return 0.000000001;
   else return 1;
}
// ---------------------------------------------------------------
 
// Connect to a scope through IP address IPaddr ------------------
int daqscope::connect(char *IPaddr)
{
   int iTemp;
   char buf[WAVE_LEN];
   printf("daqscope::connect(%s)\n", IPaddr);
   clink = new CLINK;
   iTemp = vxi11_open_device(IPaddr, clink);
   if(iTemp == 0)
   {
      vxi11_send(clink, "*IDN?");
      vxi11_receive(clink, buf, WAVE_LEN);
      printf("Connected to device (%s): %s\n", IPaddr, buf);
      savedIP = IPaddr;
      return iTemp;
   }
   else
      return iTemp;
}
// ---------------------------------------------------------------
 
// Disconnect from scope with IP address IPaddr ------------------
int daqscope::disconnect(char *IPaddr)
{
   int iTemp;
   printf("daqscope::disconnect(%s)\n", IPaddr);
   iTemp = vxi11_close_device(IPaddr, clink);
   if(iTemp == 0)
   {
      printf("Disconnected from device (%s).\n", IPaddr);
      delete clink;
   }
   return iTemp;
}
// ---------------------------------------------------------------
 
// Initialize the scope for waveform or measurement --------------
int daqscope::init()
{
   int iTemp;
   char cmd[512];
   char cTemp[256];
   printf("daqscope::init()\n");
 
   printf("Measurement type is: %d\n", scopeUseType);
 
   // For measurements, only one channel can be used (rise, fall, period,...)
   if(scopeUseType == 2) scopeChanNr = 1;
   printf("Nr. of channels selected: %d\n", scopeChanNr);
 
   // Only use scope if measurement is different than 0
   if(scopeUseType == 0)
      return 0;
   else
   {
      // Combine all selected channels into a comma separated string
      for(int i = 0; i < scopeChanNr; i++)
      {
         if(i == scopeChanNr-1)
         {
            if(i == 0) sprintf(scopeChanstring, "%s", allChans[scopeChans[i]]);
            else sprintf(cTemp, "%s", allChans[scopeChans[i]]);
         }
         else
         {
            if(i == 0) sprintf(scopeChanstring, "%s,", allChans[scopeChans[i]]);
            else sprintf(cTemp, "%s,", allChans[scopeChans[i]]);
         }
         if(i > 0)
            strcat(scopeChanstring, cTemp);
      }
      printf("Selected channels: %s\n", scopeChanstring);
 
      // Check scope ID and turn the header display on
#if WORKSTAT == 'I' || WORKSTAT == 'S'
      vxi11_query(clink, "*IDN?");
      vxi11_command(clink,(char*)"HEADER ON");
#else
      printf("Identify Tek (*IDN?, HEADER ON)\n");
#endif
 
      // Set the scope data sources
      sprintf(cmd, "DATA:SOURCE %s", scopeChanstring);
#if WORKSTAT == 'I' || WORKSTAT == 'S'
      vxi11_command(clink,cmd);
#else
      printf("Set data source (DATA:SOURCE): %s\n", cmd);
#endif
 
      // Set to fast acquisition and set encoding
#if WORKSTAT == 'I' || WORKSTAT == 'S'
      vxi11_command(clink,(char*)"FASTACQ:STATE 0");
      vxi11_command(clink,(char*)"DATA:ENCDG SRIBINARY");
      vxi11_command(clink,(char*)"WFMO:BYT_N 2");
 
      // Set gating (currently not used)
      vxi11_command(clink,(char*)"GAT OFF");
#else
      printf("Set fastacq, encoding and gating (FASTACQ:STATE 0, DATA:ENCDG SRIBINARY, WFMO:BYT_N 2, MEASU:GAT OFF).\n");
#endif
 
      // Check scale on each of selected channels (is this even needed?)
      bbq = strtok(scopeChanstring,",");
      while(bbq != NULL)
      {
         sprintf(cmd,"%s:SCALE?",bbq);
#if WORKSTAT == 'I' || WORKSTAT == 'S'
         vxi11_query(clink,cmd);
#else
         printf("Return the scale of channel: %s\n", cmd);
#endif
         bbq = strtok(NULL, ",");
      }
 
      // Check waveform and data options/settings
      char buf[WAVE_LEN];
      memset(buf, 0, WAVE_LEN);
#if WORKSTAT == 'I' || WORKSTAT == 'S'
      vxi11_send(clink, "WFMO:WFID?");
      iTemp = vxi11_receive(clink, buf, WAVE_LEN);
      printf("Init out (length = %d): %s\n", iTemp, buf);
#else
      printf("Get acquisition parameters (WFMOUTPRE:WFID?).\n");
      sprintf(buf, ":WFMOUTPRE:WFID \"Ch1, DC coupling, 20.0mV/div, 10.0ns/div, 500 points, Sample mode\"");
      iTemp = strlen(buf);
#endif
      if (iTemp == -15)
         printf("\n*** [ NOTHING RECEIVED ] ***\n");
      else
      {
         bbq = strtok(buf,","); // break WFID out into substrings
         for (int k = 0; k < 5; k++)
         {
            // info on voltage per division setting
            if (k == 2)
            {
               memcpy(cTemp, &bbq[1], 5);
               cTemp[5] = 0;
               bbq[7] = 0;
               tekvolt = atoi(cTemp)*tekunit(&bbq[6]);
               printf("Voltage per division: %lf\n", tekvolt);
            }
            // info on time per division setting
            if (k == 3)
            {
               memcpy(cTemp, &bbq[1], 5);
               cTemp[5] = 0;
               bbq[7] = 0;
               tektime = atoi(cTemp)*tekunit(&bbq[6]);
               printf("Time per division: %lf\n", tektime);
            }
            // info on last point to be transfered by CURVE?
            if (k == 4)
            {
               bbq[strlen(bbq)-7] = 0;
               sprintf(cmd, "DATA:STOP %d", atoi(bbq));
#if WORKSTAT == 'I' || WORKSTAT == 'S'
               vxi11_command(clink, cmd);
#else
               printf("Stop data collection (DATA:STOP): %s\n", cmd);
#endif
            }
//          printf("bbq = %s\n",bbq);
            bbq = strtok (NULL, ",");
         }
      }
 
      // Recheck waveform and data options/settings, turn off header
#if WORKSTAT == 'I' || WORKSTAT == 'S'
      vxi11_query(clink,"WFMO:WFID?");
      vxi11_query(clink,"DATA?");
      vxi11_command(clink,(char*)"HEADER OFF");
#else
      printf("Data format query (WFMOUTPRE:WFID?, DATA?, HEADER OFF).\n");
#endif
 
      // Get the channel y-axis offset (only for one CH so far)
      char posoff[WAVE_LEN];
#if WORKSTAT == 'I' || WORKSTAT == 'S'
      sprintf(cmd, "%s:POS?", allChans[scopeChans[0]]);
      vxi11_command(clink, cmd);
      vxi11_receive(clink, posoff, WAVE_LEN);
      choffset = (double)atof(posoff);
#else
      sprintf(posoff, "Just some temporary string info.");
      printf("Check for channel position offset (CHx:POS?)\n");
#endif
 
      // If measurements are to be performed
      if(scopeUseType == 2)
      {
         sprintf(cmd, "MEASU:IMM:SOURCE1 %s", scopeChanstring);
#if WORKSTAT == 'I' || WORKSTAT == 'S'
         vxi11_command(clink, cmd);
#else
         printf("Set immediate measurement source (MEASU:IMM:SOURCE1): %s\n", cmd);
#endif
 
         sprintf(cmd, "MEASU:IMM:TYP %s", measType[scopeMeasSel]);
#if WORKSTAT == 'I' || WORKSTAT == 'S'
         vxi11_command(clink, cmd);
#else
         printf("Set immediate measurement type (MEASU:IMM:TYP): %s\n", cmd);
#endif
      }
 
      return 0;
   }
}
// ---------------------------------------------------------------
 
// Send a custom command to the scope ----------------------------
int daqscope::customCommand(char *command, bool query, char *sReturn)
{
   if(query)
   {
      char buf[WAVE_LEN];
      memset(buf, 0, WAVE_LEN);
      vxi11_send(clink, command);
      int bytes_returned = vxi11_receive(clink, buf, WAVE_LEN);
      if (bytes_returned > 0)
      {
         printf("%s\n", buf);
         sprintf(sReturn, "%s", buf);
 
         // For testing purposes
/*       if( strcmp(command, "CURVE?") == 0 )
         {
            FILE *fp;
            char tst[2];
            fp = fopen("./curve_return.txt","w");
            for(int i = 6; i < bytes_returned; i++)
            {
               if(i%2 == 1)
               {
                  tst[0] = buf[i];
                  tst[1] = buf[i-1];
                  fprintf(fp, "bytes returned = %d\tbyte %d = %d\treturn = %s\n", bytes_returned, i, buf[i], tst);
               }
               else
                  fprintf(fp, "bytes returned = %d\tbyte %d = %d\n", bytes_returned, i, buf[i]);
            }
            fclose(fp);
         }*/
      }
      else if (bytes_returned == -15)
      {
         printf("*** [ NOTHING RECEIVED ] ***\n");
         sprintf(sReturn, "*** [ NOTHING RECEIVED ] ***");
      }
   }
   else
   {
      vxi11_command(clink, command);
      sprintf(sReturn, "*** [ COMMAND NOT QUERY - NO RETURN ] ***");
   }
 
   return 0;
}
// ---------------------------------------------------------------
 
// Get a measuring event (either waveform or measure) ------------
int daqscope::lockunlock(bool lockit)
{
   // Lock the scope front panel for measurements
   if(lockit)
   {
#if WORKSTAT == 'I' || WORKSTAT == 'S'
      vxi11_command(clink,(char*)"LOCK ALL");
      return 0;
#else
//      printf("Locking the front panel (LOCK ALL).\n");
      return -1;
#endif
   }
   // Unlock the scope front panel after measurements
   else
   {
#if WORKSTAT == 'I' || WORKSTAT == 'S'
      vxi11_command(clink,(char*)"LOCK NONE");
      return 0;
#else
//      printf("Unlocking the front panel (LOCK ALL).\n");
      return -1;
#endif
   }
}
// ---------------------------------------------------------------
 
// Get a measuring event (either waveform or measure) ------------
int daqscope::event()
{
   int bytes_returned;
 
   if(scopeUseType == 0)
      return -1;
   else if(scopeUseType == 1)
   {
#if WORKSTAT == 'I' || WORKSTAT == 'S'
      memset(eventbuf, 0, WAVE_LEN);
      vxi11_send(clink, "CURVE?");
      bytes_returned = vxi11_receive(clink, eventbuf, WAVE_LEN);
#else
      printf("Ask to return the waveform (CURVE?)\n");
      bytes_returned = 0;
#endif
 
      if(bytes_returned > 0) return 0;
      else return -1;
   }
   else if(scopeUseType == 2)
   {
#if WORKSTAT == 'I' || WORKSTAT == 'S'
      char buf[WAVE_LEN];
      memset(buf, 0, WAVE_LEN);
      vxi11_send(clink, "MEASU:IMMED:VALUE?");
      bytes_returned = vxi11_receive(clink, buf, WAVE_LEN);
      measubuf = (double)atof(buf);
#else
//      printf("Ask to return the measurement (MEASU:IMMED:VALUE?)\n");
      bytes_returned = 0;
      measubuf = (double)rand()/(double)RAND_MAX;
#endif
 
      if(bytes_returned > 0) return 0;
      else return -1;
   }
   else
      return -1;
}
// ---------------------------------------------------------------
 
// daqscope class constructor and destructor ---------------------
daqscope::daqscope() {
   fStop=0;
}
 
daqscope::~daqscope() {
   disconnect(savedIP);
}
// ---------------------------------------------------------------
 

Rev 146	Rev 173
1	#include <stdio.h>	1	#include <stdio.h>
2	#include <stdlib.h>	2	#include <stdlib.h>
3	#include <string.h>	3	#include <string.h>
4		4
5	#include "../include/~~vxi11_x86_64~~/vxi11_user.h"	5	#include "../include/vxi11_i686/vxi11_user.h"
6	#include "../include/daqscope.h"	6	#include "../include/daqscope.h"
7	#include "../include/workstation.h"	7	#include "../include/workstation.h"
8		8
9	CLINK *clink;	9	CLINK *clink;
10	char *savedIP;	10	char *savedIP;
11	const char *allChans[8] = {"CH1","CH2","CH3","CH4","MATH1","MATH2","MATH3","MATH4"};	11	const char *allChans[8] = {"CH1","CH2","CH3","CH4","MATH1","MATH2","MATH3","MATH4"};
12	const char *measType[11] = {"AMP","ARE","DEL","FALL","FREQ","MAX","MEAN","MINI","PK2P","PWI","RIS"};	12	const char *measType[11] = {"AMP","ARE","DEL","FALL","FREQ","MAX","MEAN","MINI","PK2P","PWI","RIS"};
13	char *bbq;	13	char *bbq;
14		14
15	// Query and command functions to simplify analysis --------------	15	// Query and command functions to simplify analysis --------------
16	int vxi11_query(CLINK clink, const char mycmd)	16	int vxi11_query(CLINK clink, const char mycmd)
17	{	17	{
18	char buf[WAVE_LEN];	18	char buf[WAVE_LEN];
19	memset(buf, 0, WAVE_LEN);	19	memset(buf, 0, WAVE_LEN);
20	vxi11_send(clink, mycmd);	20	vxi11_send(clink, mycmd);
21	int bytes_returned = vxi11_receive(clink, buf, WAVE_LEN);	21	int bytes_returned = vxi11_receive(clink, buf, WAVE_LEN);
22	if (bytes_returned > 0)	22	if (bytes_returned > 0)
23	{	23	{
24	printf("%s\n", buf);	24	printf("%s\n", buf);
25	}	25	}
26	else if (bytes_returned == -15)	26	else if (bytes_returned == -15)
27	printf("* [ NOTHING RECEIVED ] *\n");	27	printf("* [ NOTHING RECEIVED ] *\n");
28		28
29	return 0;	29	return 0;
30	}	30	}
31		31
32	void vxi11_command(CLINK clink,char mycmd)	32	void vxi11_command(CLINK clink,char mycmd)
33	{	33	{
34	char buf[WAVE_LEN];	34	char buf[WAVE_LEN];
35	memset(buf, 0, WAVE_LEN);	35	memset(buf, 0, WAVE_LEN);
36	vxi11_send(clink, mycmd);	36	vxi11_send(clink, mycmd);
37	}	37	}
38	// ---------------------------------------------------------------	38	// ---------------------------------------------------------------
39		39
40	// Tektronix unit conversion -------------------------------------	40	// Tektronix unit conversion -------------------------------------
41	double daqscope::tekunit(char *prefix)	41	double daqscope::tekunit(char *prefix)
42	{	42	{
43	if (strcmp(prefix,"m")==0) return 0.001;	43	if (strcmp(prefix,"m")==0) return 0.001;
44	else if (strcmp(prefix,"u")==0) return 0.000001;	44	else if (strcmp(prefix,"u")==0) return 0.000001;
45	else if (strcmp(prefix,"n")==0) return 0.000000001;	45	else if (strcmp(prefix,"n")==0) return 0.000000001;
46	else return 1;	46	else return 1;
47	}	47	}
48	// ---------------------------------------------------------------	48	// ---------------------------------------------------------------
49		49
50	// Connect to a scope through IP address IPaddr ------------------	50	// Connect to a scope through IP address IPaddr ------------------
51	int daqscope::connect(char *IPaddr)	51	int daqscope::connect(char *IPaddr)
52	{	52	{
53	int iTemp;	53	int iTemp;
54	char buf[WAVE_LEN];	54	char buf[WAVE_LEN];
55	printf("daqscope::connect(%s)\n", IPaddr);	55	printf("daqscope::connect(%s)\n", IPaddr);
56	clink = new CLINK;	56	clink = new CLINK;
57	iTemp = vxi11_open_device(IPaddr, clink);	57	iTemp = vxi11_open_device(IPaddr, clink);
58	if(iTemp == 0)	58	if(iTemp == 0)
59	{	59	{
60	vxi11_send(clink, "*IDN?");	60	vxi11_send(clink, "*IDN?");
61	vxi11_receive(clink, buf, WAVE_LEN);	61	vxi11_receive(clink, buf, WAVE_LEN);
62	printf("Connected to device (%s): %s\n", IPaddr, buf);	62	printf("Connected to device (%s): %s\n", IPaddr, buf);
63	savedIP = IPaddr;	63	savedIP = IPaddr;
64	return iTemp;	64	return iTemp;
65	}	65	}
66	else	66	else
67	return iTemp;	67	return iTemp;
68	}	68	}
69	// ---------------------------------------------------------------	69	// ---------------------------------------------------------------
70		70
71	// Disconnect from scope with IP address IPaddr ------------------	71	// Disconnect from scope with IP address IPaddr ------------------
72	int daqscope::disconnect(char *IPaddr)	72	int daqscope::disconnect(char *IPaddr)
73	{	73	{
74	int iTemp;	74	int iTemp;
75	printf("daqscope::disconnect(%s)\n", IPaddr);	75	printf("daqscope::disconnect(%s)\n", IPaddr);
76	iTemp = vxi11_close_device(IPaddr, clink);	76	iTemp = vxi11_close_device(IPaddr, clink);
77	if(iTemp == 0)	77	if(iTemp == 0)
78	{	78	{
79	printf("Disconnected from device (%s).\n", IPaddr);	79	printf("Disconnected from device (%s).\n", IPaddr);
80	delete clink;	80	delete clink;
81	}	81	}
82	return iTemp;	82	return iTemp;
83	}	83	}
84	// ---------------------------------------------------------------	84	// ---------------------------------------------------------------
85		85
86	// Initialize the scope for waveform or measurement --------------	86	// Initialize the scope for waveform or measurement --------------
87	int daqscope::init()	87	int daqscope::init()
88	{	88	{
89	int iTemp;	89	int iTemp;
90	char cmd[512];	90	char cmd[512];
91	char cTemp[256];	91	char cTemp[256];
92	printf("daqscope::init()\n");	92	printf("daqscope::init()\n");
93		93
94	printf("Measurement type is: %d\n", scopeUseType);	94	printf("Measurement type is: %d\n", scopeUseType);
95		95
96	// For measurements, only one channel can be used (rise, fall, period,...)	96	// For measurements, only one channel can be used (rise, fall, period,...)
97	if(scopeUseType == 2) scopeChanNr = 1;	97	if(scopeUseType == 2) scopeChanNr = 1;
98	printf("Nr. of channels selected: %d\n", scopeChanNr);	98	printf("Nr. of channels selected: %d\n", scopeChanNr);
99		99
100	// Only use scope if measurement is different than 0	100	// Only use scope if measurement is different than 0
101	if(scopeUseType == 0)	101	if(scopeUseType == 0)
102	return 0;	102	return 0;
103	else	103	else
104	{	104	{
105	// Combine all selected channels into a comma separated string	105	// Combine all selected channels into a comma separated string
106	for(int i = 0; i < scopeChanNr; i++)	106	for(int i = 0; i < scopeChanNr; i++)
107	{	107	{
108	if(i == scopeChanNr-1)	108	if(i == scopeChanNr-1)
109	{	109	{
110	if(i == 0) sprintf(scopeChanstring, "%s", allChans[scopeChans[i]]);	110	if(i == 0) sprintf(scopeChanstring, "%s", allChans[scopeChans[i]]);
111	else sprintf(cTemp, "%s", allChans[scopeChans[i]]);	111	else sprintf(cTemp, "%s", allChans[scopeChans[i]]);
112	}	112	}
113	else	113	else
114	{	114	{
115	if(i == 0) sprintf(scopeChanstring, "%s,", allChans[scopeChans[i]]);	115	if(i == 0) sprintf(scopeChanstring, "%s,", allChans[scopeChans[i]]);
116	else sprintf(cTemp, "%s,", allChans[scopeChans[i]]);	116	else sprintf(cTemp, "%s,", allChans[scopeChans[i]]);
117	}	117	}
118	if(i > 0)	118	if(i > 0)
119	strcat(scopeChanstring, cTemp);	119	strcat(scopeChanstring, cTemp);
120	}	120	}
121	printf("Selected channels: %s\n", scopeChanstring);	121	printf("Selected channels: %s\n", scopeChanstring);
122		122
123	// Check scope ID and turn the header display on	123	// Check scope ID and turn the header display on
124	#if WORKSTAT == 'I' \|\| WORKSTAT == 'S'	124	#if WORKSTAT == 'I' \|\| WORKSTAT == 'S'
125	vxi11_query(clink, "*IDN?");	125	vxi11_query(clink, "*IDN?");
126	vxi11_command(clink,(char*)"HEADER ON");	126	vxi11_command(clink,(char*)"HEADER ON");
127	#else	127	#else
128	printf("Identify Tek (*IDN?, HEADER ON)\n");	128	printf("Identify Tek (*IDN?, HEADER ON)\n");
129	#endif	129	#endif
130		130
131	// Set the scope data sources	131	// Set the scope data sources
132	sprintf(cmd, "DATA:SOURCE %s", scopeChanstring);	132	sprintf(cmd, "DATA:SOURCE %s", scopeChanstring);
133	#if WORKSTAT == 'I' \|\| WORKSTAT == 'S'	133	#if WORKSTAT == 'I' \|\| WORKSTAT == 'S'
134	vxi11_command(clink,cmd);	134	vxi11_command(clink,cmd);
135	#else	135	#else
136	printf("Set data source (DATA:SOURCE): %s\n", cmd);	136	printf("Set data source (DATA:SOURCE): %s\n", cmd);
137	#endif	137	#endif
138		138
139	// Set to fast acquisition and set encoding	139	// Set to fast acquisition and set encoding
140	#if WORKSTAT == 'I' \|\| WORKSTAT == 'S'	140	#if WORKSTAT == 'I' \|\| WORKSTAT == 'S'
141	vxi11_command(clink,(char*)"FASTACQ:STATE 0");	141	vxi11_command(clink,(char*)"FASTACQ:STATE 0");
142	vxi11_command(clink,(char*)"DATA:ENCDG SRIBINARY");	142	vxi11_command(clink,(char*)"DATA:ENCDG SRIBINARY");
143	vxi11_command(clink,(char*)"WFMO:BYT_N 2");	143	vxi11_command(clink,(char*)"WFMO:BYT_N 2");
144		144
145	// Set gating (currently not used)	145	// Set gating (currently not used)
146	vxi11_command(clink,(char*)"GAT OFF");	146	vxi11_command(clink,(char*)"GAT OFF");
147	#else	147	#else
148	printf("Set fastacq, encoding and gating (FASTACQ:STATE 0, DATA:ENCDG SRIBINARY, WFMO:BYT_N 2, MEASU:GAT OFF).\n");	148	printf("Set fastacq, encoding and gating (FASTACQ:STATE 0, DATA:ENCDG SRIBINARY, WFMO:BYT_N 2, MEASU:GAT OFF).\n");
149	#endif	149	#endif
150		150
151	// Check scale on each of selected channels (is this even needed?)	151	// Check scale on each of selected channels (is this even needed?)
152	bbq = strtok(scopeChanstring,",");	152	bbq = strtok(scopeChanstring,",");
153	while(bbq != NULL)	153	while(bbq != NULL)
154	{	154	{
155	sprintf(cmd,"%s:SCALE?",bbq);	155	sprintf(cmd,"%s:SCALE?",bbq);
156	#if WORKSTAT == 'I' \|\| WORKSTAT == 'S'	156	#if WORKSTAT == 'I' \|\| WORKSTAT == 'S'
157	vxi11_query(clink,cmd);	157	vxi11_query(clink,cmd);
158	#else	158	#else
159	printf("Return the scale of channel: %s\n", cmd);	159	printf("Return the scale of channel: %s\n", cmd);
160	#endif	160	#endif
161	bbq = strtok(NULL, ",");	161	bbq = strtok(NULL, ",");
162	}	162	}
163		163
164	// Check waveform and data options/settings	164	// Check waveform and data options/settings
165	char buf[WAVE_LEN];	165	char buf[WAVE_LEN];
166	memset(buf, 0, WAVE_LEN);	166	memset(buf, 0, WAVE_LEN);
167	#if WORKSTAT == 'I' \|\| WORKSTAT == 'S'	167	#if WORKSTAT == 'I' \|\| WORKSTAT == 'S'
168	vxi11_send(clink, "WFMO:WFID?");	168	vxi11_send(clink, "WFMO:WFID?");
169	iTemp = vxi11_receive(clink, buf, WAVE_LEN);	169	iTemp = vxi11_receive(clink, buf, WAVE_LEN);
170	printf("Init out (length = %d): %s\n", iTemp, buf);	170	printf("Init out (length = %d): %s\n", iTemp, buf);
171	#else	171	#else
172	printf("Get acquisition parameters (WFMOUTPRE:WFID?).\n");	172	printf("Get acquisition parameters (WFMOUTPRE:WFID?).\n");
173	sprintf(buf, ":WFMOUTPRE:WFID \"Ch1, DC coupling, 20.0mV/div, 10.0ns/div, 500 points, Sample mode\"");	173	sprintf(buf, ":WFMOUTPRE:WFID \"Ch1, DC coupling, 20.0mV/div, 10.0ns/div, 500 points, Sample mode\"");
174	iTemp = strlen(buf);	174	iTemp = strlen(buf);
175	#endif	175	#endif
176	if (iTemp == -15)	176	if (iTemp == -15)
177	printf("\n* [ NOTHING RECEIVED ] *\n");	177	printf("\n* [ NOTHING RECEIVED ] *\n");
178	else	178	else
179	{	179	{
180	bbq = strtok(buf,","); // break WFID out into substrings	180	bbq = strtok(buf,","); // break WFID out into substrings
181	for (int k = 0; k < 5; k++)	181	for (int k = 0; k < 5; k++)
182	{	182	{
183	// info on voltage per division setting	183	// info on voltage per division setting
184	if (k == 2)	184	if (k == 2)
185	{	185	{
186	memcpy(cTemp, &bbq[1], 5);	186	memcpy(cTemp, &bbq[1], 5);
187	cTemp[5] = 0;	187	cTemp[5] = 0;
188	bbq[7] = 0;	188	bbq[7] = 0;
189	tekvolt = atoi(cTemp)*tekunit(&bbq[6]);	189	tekvolt = atoi(cTemp)*tekunit(&bbq[6]);
190	printf("Voltage per division: %lf\n", tekvolt);	190	printf("Voltage per division: %lf\n", tekvolt);
191	}	191	}
192	// info on time per division setting	192	// info on time per division setting
193	if (k == 3)	193	if (k == 3)
194	{	194	{
195	memcpy(cTemp, &bbq[1], 5);	195	memcpy(cTemp, &bbq[1], 5);
196	cTemp[5] = 0;	196	cTemp[5] = 0;
197	bbq[7] = 0;	197	bbq[7] = 0;
198	tektime = atoi(cTemp)*tekunit(&bbq[6]);	198	tektime = atoi(cTemp)*tekunit(&bbq[6]);
199	printf("Time per division: %lf\n", tektime);	199	printf("Time per division: %lf\n", tektime);
200	}	200	}
201	// info on last point to be transfered by CURVE?	201	// info on last point to be transfered by CURVE?
202	if (k == 4)	202	if (k == 4)
203	{	203	{
204	bbq[strlen(bbq)-7] = 0;	204	bbq[strlen(bbq)-7] = 0;
205	sprintf(cmd, "DATA:STOP %d", atoi(bbq));	205	sprintf(cmd, "DATA:STOP %d", atoi(bbq));
206	#if WORKSTAT == 'I' \|\| WORKSTAT == 'S'	206	#if WORKSTAT == 'I' \|\| WORKSTAT == 'S'
207	vxi11_command(clink, cmd);	207	vxi11_command(clink, cmd);
208	#else	208	#else
209	printf("Stop data collection (DATA:STOP): %s\n", cmd);	209	printf("Stop data collection (DATA:STOP): %s\n", cmd);
210	#endif	210	#endif
211	}	211	}
212	// printf("bbq = %s\n",bbq);	212	// printf("bbq = %s\n",bbq);
213	bbq = strtok (NULL, ",");	213	bbq = strtok (NULL, ",");
214	}	214	}
215	}	215	}
216		216
217	// Recheck waveform and data options/settings, turn off header	217	// Recheck waveform and data options/settings, turn off header
218	#if WORKSTAT == 'I' \|\| WORKSTAT == 'S'	218	#if WORKSTAT == 'I' \|\| WORKSTAT == 'S'
219	vxi11_query(clink,"WFMO:WFID?");	219	vxi11_query(clink,"WFMO:WFID?");
220	vxi11_query(clink,"DATA?");	220	vxi11_query(clink,"DATA?");
221	vxi11_command(clink,(char*)"HEADER OFF");	221	vxi11_command(clink,(char*)"HEADER OFF");
222	#else	222	#else
223	printf("Data format query (WFMOUTPRE:WFID?, DATA?, HEADER OFF).\n");	223	printf("Data format query (WFMOUTPRE:WFID?, DATA?, HEADER OFF).\n");
224	#endif	224	#endif
225		225
226	// Get the channel y-axis offset (only for one CH so far)	226	// Get the channel y-axis offset (only for one CH so far)
227	char posoff[WAVE_LEN];	227	char posoff[WAVE_LEN];
228	#if WORKSTAT == 'I' \|\| WORKSTAT == 'S'	228	#if WORKSTAT == 'I' \|\| WORKSTAT == 'S'
229	sprintf(cmd, "%s:POS?", allChans[scopeChans[0]]);	229	sprintf(cmd, "%s:POS?", allChans[scopeChans[0]]);
230	vxi11_command(clink, cmd);	230	vxi11_command(clink, cmd);
231	vxi11_receive(clink, posoff, WAVE_LEN);	231	vxi11_receive(clink, posoff, WAVE_LEN);
232	choffset = (double)atof(posoff);	232	choffset = (double)atof(posoff);
233	#else	233	#else
234	sprintf(posoff, "Just some temporary string info.");	234	sprintf(posoff, "Just some temporary string info.");
235	printf("Check for channel position offset (CHx:POS?)\n");	235	printf("Check for channel position offset (CHx:POS?)\n");
236	#endif	236	#endif
237		237
238	// If measurements are to be performed	238	// If measurements are to be performed
239	if(scopeUseType == 2)	239	if(scopeUseType == 2)
240	{	240	{
241	sprintf(cmd, "MEASU:IMM:SOURCE1 %s", scopeChanstring);	241	sprintf(cmd, "MEASU:IMM:SOURCE1 %s", scopeChanstring);
242	#if WORKSTAT == 'I' \|\| WORKSTAT == 'S'	242	#if WORKSTAT == 'I' \|\| WORKSTAT == 'S'
243	vxi11_command(clink, cmd);	243	vxi11_command(clink, cmd);
244	#else	244	#else
245	printf("Set immediate measurement source (MEASU:IMM:SOURCE1): %s\n", cmd);	245	printf("Set immediate measurement source (MEASU:IMM:SOURCE1): %s\n", cmd);
246	#endif	246	#endif
247		247
248	sprintf(cmd, "MEASU:IMM:TYP %s", measType[scopeMeasSel]);	248	sprintf(cmd, "MEASU:IMM:TYP %s", measType[scopeMeasSel]);
249	#if WORKSTAT == 'I' \|\| WORKSTAT == 'S'	249	#if WORKSTAT == 'I' \|\| WORKSTAT == 'S'
250	vxi11_command(clink, cmd);	250	vxi11_command(clink, cmd);
251	#else	251	#else
252	printf("Set immediate measurement type (MEASU:IMM:TYP): %s\n", cmd);	252	printf("Set immediate measurement type (MEASU:IMM:TYP): %s\n", cmd);
253	#endif	253	#endif
254	}	254	}
255		255
256	return 0;	256	return 0;
257	}	257	}
258	}	258	}
259	// ---------------------------------------------------------------	259	// ---------------------------------------------------------------
260		260
261	// Send a custom command to the scope ----------------------------	261	// Send a custom command to the scope ----------------------------
262	int daqscope::customCommand(char command, bool query, char sReturn)	262	int daqscope::customCommand(char command, bool query, char sReturn)
263	{	263	{
264	if(query)	264	if(query)
265	{	265	{
266	char buf[WAVE_LEN];	266	char buf[WAVE_LEN];
267	memset(buf, 0, WAVE_LEN);	267	memset(buf, 0, WAVE_LEN);
268	vxi11_send(clink, command);	268	vxi11_send(clink, command);
269	int bytes_returned = vxi11_receive(clink, buf, WAVE_LEN);	269	int bytes_returned = vxi11_receive(clink, buf, WAVE_LEN);
270	if (bytes_returned > 0)	270	if (bytes_returned > 0)
271	{	271	{
272	printf("%s\n", buf);	272	printf("%s\n", buf);
273	sprintf(sReturn, "%s", buf);	273	sprintf(sReturn, "%s", buf);
274		274
275	// For testing purposes	275	// For testing purposes
276	/* if( strcmp(command, "CURVE?") == 0 )	276	/* if( strcmp(command, "CURVE?") == 0 )
277	{	277	{
278	FILE *fp;	278	FILE *fp;
279	char tst[2];	279	char tst[2];
280	fp = fopen("./curve_return.txt","w");	280	fp = fopen("./curve_return.txt","w");
281	for(int i = 6; i < bytes_returned; i++)	281	for(int i = 6; i < bytes_returned; i++)
282	{	282	{
283	if(i%2 == 1)	283	if(i%2 == 1)
284	{	284	{
285	tst[0] = buf[i];	285	tst[0] = buf[i];
286	tst[1] = buf[i-1];	286	tst[1] = buf[i-1];
287	fprintf(fp, "bytes returned = %d\tbyte %d = %d\treturn = %s\n", bytes_returned, i, buf[i], tst);	287	fprintf(fp, "bytes returned = %d\tbyte %d = %d\treturn = %s\n", bytes_returned, i, buf[i], tst);
288	}	288	}
289	else	289	else
290	fprintf(fp, "bytes returned = %d\tbyte %d = %d\n", bytes_returned, i, buf[i]);	290	fprintf(fp, "bytes returned = %d\tbyte %d = %d\n", bytes_returned, i, buf[i]);
291	}	291	}
292	fclose(fp);	292	fclose(fp);
293	}*/	293	}*/
294	}	294	}
295	else if (bytes_returned == -15)	295	else if (bytes_returned == -15)
296	{	296	{
297	printf("* [ NOTHING RECEIVED ] *\n");	297	printf("* [ NOTHING RECEIVED ] *\n");
298	sprintf(sReturn, "* [ NOTHING RECEIVED ] *");	298	sprintf(sReturn, "* [ NOTHING RECEIVED ] *");
299	}	299	}
300	}	300	}
301	else	301	else
302	{	302	{
303	vxi11_command(clink, command);	303	vxi11_command(clink, command);
304	sprintf(sReturn, "* [ COMMAND NOT QUERY - NO RETURN ] *");	304	sprintf(sReturn, "* [ COMMAND NOT QUERY - NO RETURN ] *");
305	}	305	}
306		306
307	return 0;	307	return 0;
308	}	308	}
309	// ---------------------------------------------------------------	309	// ---------------------------------------------------------------
310		310
311	// Get a measuring event (either waveform or measure) ------------	311	// Get a measuring event (either waveform or measure) ------------
312	int daqscope::lockunlock(bool lockit)	312	int daqscope::lockunlock(bool lockit)
313	{	313	{
314	// Lock the scope front panel for measurements	314	// Lock the scope front panel for measurements
315	if(lockit)	315	if(lockit)
316	{	316	{
317	#if WORKSTAT == 'I' \|\| WORKSTAT == 'S'	317	#if WORKSTAT == 'I' \|\| WORKSTAT == 'S'
318	vxi11_command(clink,(char*)"LOCK ALL");	318	vxi11_command(clink,(char*)"LOCK ALL");
319	return 0;	319	return 0;
320	#else	320	#else
321	// printf("Locking the front panel (LOCK ALL).\n");	321	// printf("Locking the front panel (LOCK ALL).\n");
322	return -1;	322	return -1;
323	#endif	323	#endif
324	}	324	}
325	// Unlock the scope front panel after measurements	325	// Unlock the scope front panel after measurements
326	else	326	else
327	{	327	{
328	#if WORKSTAT == 'I' \|\| WORKSTAT == 'S'	328	#if WORKSTAT == 'I' \|\| WORKSTAT == 'S'
329	vxi11_command(clink,(char*)"LOCK NONE");	329	vxi11_command(clink,(char*)"LOCK NONE");
330	return 0;	330	return 0;
331	#else	331	#else
332	// printf("Unlocking the front panel (LOCK ALL).\n");	332	// printf("Unlocking the front panel (LOCK ALL).\n");
333	return -1;	333	return -1;
334	#endif	334	#endif
335	}	335	}
336	}	336	}
337	// ---------------------------------------------------------------	337	// ---------------------------------------------------------------
338		338
339	// Get a measuring event (either waveform or measure) ------------	339	// Get a measuring event (either waveform or measure) ------------
340	int daqscope::event()	340	int daqscope::event()
341	{	341	{
342	int bytes_returned;	342	int bytes_returned;
343		343
344	if(scopeUseType == 0)	344	if(scopeUseType == 0)
345	return -1;	345	return -1;
346	else if(scopeUseType == 1)	346	else if(scopeUseType == 1)
347	{	347	{
348	#if WORKSTAT == 'I' \|\| WORKSTAT == 'S'	348	#if WORKSTAT == 'I' \|\| WORKSTAT == 'S'
349	memset(eventbuf, 0, WAVE_LEN);	349	memset(eventbuf, 0, WAVE_LEN);
350	vxi11_send(clink, "CURVE?");	350	vxi11_send(clink, "CURVE?");
351	bytes_returned = vxi11_receive(clink, eventbuf, WAVE_LEN);	351	bytes_returned = vxi11_receive(clink, eventbuf, WAVE_LEN);
352	#else	352	#else
353	printf("Ask to return the waveform (CURVE?)\n");	353	printf("Ask to return the waveform (CURVE?)\n");
354	bytes_returned = 0;	354	bytes_returned = 0;
355	#endif	355	#endif
356		356
357	if(bytes_returned > 0) return 0;	357	if(bytes_returned > 0) return 0;
358	else return -1;	358	else return -1;
359	}	359	}
360	else if(scopeUseType == 2)	360	else if(scopeUseType == 2)
361	{	361	{
362	#if WORKSTAT == 'I' \|\| WORKSTAT == 'S'	362	#if WORKSTAT == 'I' \|\| WORKSTAT == 'S'
363	char buf[WAVE_LEN];	363	char buf[WAVE_LEN];
364	memset(buf, 0, WAVE_LEN);	364	memset(buf, 0, WAVE_LEN);
365	vxi11_send(clink, "MEASU:IMMED:VALUE?");	365	vxi11_send(clink, "MEASU:IMMED:VALUE?");
366	bytes_returned = vxi11_receive(clink, buf, WAVE_LEN);	366	bytes_returned = vxi11_receive(clink, buf, WAVE_LEN);
367	measubuf = (double)atof(buf);	367	measubuf = (double)atof(buf);
368	#else	368	#else
369	// printf("Ask to return the measurement (MEASU:IMMED:VALUE?)\n");	369	// printf("Ask to return the measurement (MEASU:IMMED:VALUE?)\n");
370	bytes_returned = 0;	370	bytes_returned = 0;
371	measubuf = (double)rand()/(double)RAND_MAX;	371	measubuf = (double)rand()/(double)RAND_MAX;
372	#endif	372	#endif
373		373
374	if(bytes_returned > 0) return 0;	374	if(bytes_returned > 0) return 0;
375	else return -1;	375	else return -1;
376	}	376	}
377	else	377	else
378	return -1;	378	return -1;
379	}	379	}
380	// ---------------------------------------------------------------	380	// ---------------------------------------------------------------
381		381
382	// daqscope class constructor and destructor ---------------------	382	// daqscope class constructor and destructor ---------------------
383	daqscope::daqscope() {	383	daqscope::daqscope() {
384	fStop=0;	384	fStop=0;
385	}	385	}
386		386
387	daqscope::~daqscope() {	387	daqscope::~daqscope() {
388	disconnect(savedIP);	388	disconnect(savedIP);
389	}	389	}
390	// ---------------------------------------------------------------	390	// ---------------------------------------------------------------
391		391

Subversion Repositories f9daq

(root)/lab/sipmscan/trunk/src/daqscope.C – Rev 146 → 173