update to libusb-1.0
[rigol] / scope.c
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <unistd.h>
4 #include <stdint.h>
5 #include <string.h>
6 #include <strings.h>
7
8 #include "scope.h"
9 #include "usbtmc.h"
10
11 #define DATASIZE 10240
12
13 #define COPY_SCOPE_STRING(sc, cmd, dst) { \
14 char *buf; \
15 buf = scope_get_string(sc, cmd, sizeof(dst)); \
16 if (buf) { \
17 strcpy(dst, buf); \
18 free(buf); \
19 }\
20 }
21
22 /* Just USB for now... */
23 int sendscpi(struct scope* sc, char* cmd, unsigned char *resp, int resplen)
24 {
25 return usbtmc_sendscpi(sc, cmd, resp, resplen);
26 }
27
28 void closescope(struct scope* sc)
29 {
30 return usbtmc_close(sc);
31 }
32
33 void claimscope(struct scope* sc)
34 {
35 return usbtmc_claim(sc);
36 }
37
38 void releasescope(struct scope* sc)
39 {
40 /* Disable keylock, so the user doesn't have to press the 'force'-button */
41 sendscpi(sc, ":KEY:LOCK DISABLE",NULL,0);
42 return usbtmc_release(sc);
43 }
44
45 void resetscope(struct scope* sc)
46 {
47 return usbtmc_reset(sc);
48 }
49
50 struct scope* initscope(void)
51 {
52 struct scope *sc;
53
54 sc = usbtmc_initscope();
55
56 if (!sc) {
57 printf("No scope found.\n");
58 exit(EXIT_FAILURE);
59 }
60
61 claimscope(sc);
62 COPY_SCOPE_STRING(sc, "*IDN?", sc->idn);
63 releasescope(sc);
64
65 printf("Scope found (%s)\n", sc->idn);
66
67 return sc;
68 }
69
70 char *scope_idn(struct scope *sc)
71 {
72 return sc->idn;
73 }
74
75 char *scope_get_string(struct scope *sc, char *cmd, int maxlen)
76 {
77 unsigned char *buf;
78 int res;
79
80 buf = malloc(maxlen+1);
81 if (buf == NULL) {
82 perror("malloc(scope_get_strings)");
83 exit(EXIT_FAILURE);
84 }
85
86 res = sendscpi(sc, cmd, buf, maxlen);
87 if (res < 0) {
88 fprintf(stderr, "Command %s failed with %d\n", cmd, res);
89 free(buf);
90 return NULL;
91 }
92
93 buf[res] = 0;
94
95 return (char*)buf;
96 }
97
98 int scope_get_truth_value(struct scope *sc, char *cmd)
99 {
100 char buf[128];
101 int res;
102
103 bzero(buf, sizeof(buf));
104 res = sendscpi(sc, cmd, (unsigned char*)buf, sizeof(buf)-1);
105 if (res < 0) {
106 fprintf(stderr, "Command %s failed with %d\n", cmd, res);
107 return 0;
108 }
109
110 if (strcasecmp(buf, "on") == 0) {
111 return 1;
112 } else if (strcasecmp(buf, "enable") == 0) {
113 return 1;
114 }
115
116 return 0;
117 }
118
119 int scope_get_int(struct scope *sc, char *cmd)
120 {
121 char buf[128];
122 int res;
123
124 bzero(buf, sizeof(buf));
125 res = sendscpi(sc, cmd, (unsigned char*)buf, sizeof(buf)-1);
126 if (res < 0) {
127 fprintf(stderr, "Command %s failed with %d\n", cmd, res);
128 return 0;
129 }
130
131 return atoi(buf);
132 }
133
134 double scope_get_double(struct scope *sc, char*cmd)
135 {
136 char buf[128];
137 int res;
138 double ret;
139
140 bzero(buf, sizeof(buf));
141 res = sendscpi(sc, cmd, (unsigned char*)buf, sizeof(buf)-1);
142 if (res < 0) {
143 fprintf(stderr, "Command %s failed with %d\n", cmd, res);
144 return 0.0;
145 }
146
147 ret = strtod(buf, NULL);
148
149 return ret;
150 }
151
152 char *scope_get_data(struct scope *sc, char *source, int *len)
153 {
154 char *data = NULL;
155 char cmd[128];
156
157 if ((data = malloc(DATASIZE)) == NULL) {
158 perror("malloc");
159 return NULL;
160 }
161
162 snprintf(cmd, sizeof(cmd), ":WAV:DATA? %s", source);
163 *len = sendscpi(sc, cmd, (unsigned char*)data, DATASIZE);
164
165 return data;
166 }
167
168 void update_scope_measurements(struct scope *sc)
169 {
170 sc->status.measure.ch1.vpp = scope_get_double(sc, ":MEAS:VPP? CHAN1");
171 sc->status.measure.ch1.vmax = scope_get_double(sc, ":MEAS:VMAX? CHAN1");
172 sc->status.measure.ch1.vmin = scope_get_double(sc, ":MEAS:VMIN? CHAN1");
173 sc->status.measure.ch1.vamplitude = scope_get_double(sc, ":MEAS:VAMP? CHAN1");
174 sc->status.measure.ch1.vtop = scope_get_double(sc, ":MEAS:VTOP? CHAN1");
175 sc->status.measure.ch1.vbase = scope_get_double(sc, ":MEAS:VBAS? CHAN1");
176 sc->status.measure.ch1.vaverage = scope_get_double(sc, ":MEAS:VAV? CHAN1");
177 sc->status.measure.ch1.vrms = scope_get_double(sc, ":MEAS:VRMS? CHAN1");
178 sc->status.measure.ch1.overshoot = scope_get_double(sc, ":MEAS:OVER? CHAN1");
179 sc->status.measure.ch1.preshoot = scope_get_double(sc, ":MEAS:PRES? CHAN1");
180 sc->status.measure.ch1.frequency = scope_get_double(sc, ":MEAS:FREQ? CHAN1");
181 sc->status.measure.ch1.risetime = scope_get_double(sc, ":MEAS:RIS? CHAN1");
182 sc->status.measure.ch1.falltime = scope_get_double(sc, ":MEAS:FALL? CHAN1");
183 sc->status.measure.ch1.period = scope_get_double(sc, ":MEAS:PER? CHAN1");
184 sc->status.measure.ch1.pwidth = scope_get_double(sc, ":MEAS:PWID? CHAN1");
185 sc->status.measure.ch1.nwidth = scope_get_double(sc, ":MEAS:NWID? CHAN1");
186 sc->status.measure.ch1.pdutycycle = scope_get_double(sc, ":MEAS:PDUT? CHAN1");
187 sc->status.measure.ch1.ndutycycle = scope_get_double(sc, ":MEAS:NDUT? CHAN1");
188 sc->status.measure.ch1.pdelay = scope_get_double(sc, ":MEAS:PDEL? CHAN1");
189 sc->status.measure.ch1.ndelay = scope_get_double(sc, ":MEAS:NDEL? CHAN1");
190
191 sc->status.measure.ch2.vpp = scope_get_double(sc, ":MEAS:VPP? CHAN2");
192 sc->status.measure.ch2.vmax = scope_get_double(sc, ":MEAS:VMAX? CHAN2");
193 sc->status.measure.ch2.vmin = scope_get_double(sc, ":MEAS:VMIN? CHAN2");
194 sc->status.measure.ch2.vamplitude = scope_get_double(sc, ":MEAS:VAMP? CHAN2");
195 sc->status.measure.ch2.vtop = scope_get_double(sc, ":MEAS:VTOP? CHAN2");
196 sc->status.measure.ch2.vbase = scope_get_double(sc, ":MEAS:VBAS? CHAN2");
197 sc->status.measure.ch2.vaverage = scope_get_double(sc, ":MEAS:VAV? CHAN2");
198 sc->status.measure.ch2.vrms = scope_get_double(sc, ":MEAS:VRMS? CHAN2");
199 sc->status.measure.ch2.overshoot = scope_get_double(sc, ":MEAS:OVER? CHAN2");
200 sc->status.measure.ch2.preshoot = scope_get_double(sc, ":MEAS:PRES? CHAN2");
201 sc->status.measure.ch2.frequency = scope_get_double(sc, ":MEAS:FREQ? CHAN2");
202 sc->status.measure.ch2.risetime = scope_get_double(sc, ":MEAS:RIS? CHAN2");
203 sc->status.measure.ch2.falltime = scope_get_double(sc, ":MEAS:FALL? CHAN2");
204 sc->status.measure.ch2.period = scope_get_double(sc, ":MEAS:PER? CHAN2");
205 sc->status.measure.ch2.pwidth = scope_get_double(sc, ":MEAS:PWID? CHAN2");
206 sc->status.measure.ch2.nwidth = scope_get_double(sc, ":MEAS:NWID? CHAN2");
207 sc->status.measure.ch2.pdutycycle = scope_get_double(sc, ":MEAS:PDUT? CHAN2");
208 sc->status.measure.ch2.ndutycycle = scope_get_double(sc, ":MEAS:NDUT? CHAN2");
209 sc->status.measure.ch2.pdelay = scope_get_double(sc, ":MEAS:PDEL? CHAN2");
210 sc->status.measure.ch2.ndelay = scope_get_double(sc, ":MEAS:NDEL? CHAN2");
211
212 sc->status.measure.total = scope_get_truth_value(sc, ":MEAS:TOT?");
213 COPY_SCOPE_STRING(sc, ":MEAS:SOUR?", sc->status.measure.source);
214
215 }
216
217 void update_scope_channel(struct scope *sc, int channel)
218 {
219 struct channel_s *ch;
220 char cmd[128];
221 int offs;
222
223 if (channel == 1) {
224 ch = &(sc->status.channel.ch1);
225 strcpy(cmd, ":CHAN1:");
226 } else if (channel == 2) {
227 ch = &(sc->status.channel.ch2);
228 strcpy(cmd, ":CHAN2:");
229 } else {
230 fprintf(stderr, "Unknown channel %d!\n", channel);
231 return;
232 }
233
234 offs=strlen(cmd);
235
236 strcpy(cmd + offs, "BWL?"); ch->bwlimit_enabled = scope_get_truth_value(sc, cmd);
237 strcpy(cmd + offs, "COUP?"); COPY_SCOPE_STRING(sc, cmd, ch->coupling);
238 strcpy(cmd + offs, "DISP?"); ch->displayed = scope_get_truth_value(sc, cmd);
239 strcpy(cmd + offs, "INV?"); ch->inverted = scope_get_truth_value(sc, cmd);
240 strcpy(cmd + offs, "OFFS?"); ch->offset = scope_get_double(sc, cmd);
241 strcpy(cmd + offs, "PROB?"); ch->probe = scope_get_double(sc, cmd);
242 strcpy(cmd + offs, "SCAL?"); ch->scale = scope_get_double(sc, cmd);
243 strcpy(cmd + offs, "FILT?"); ch->filter_enabled = scope_get_truth_value(sc, cmd);
244 strcpy(cmd + offs, "MEMD?"); ch->memory_depth = scope_get_int(sc, cmd);
245 strcpy(cmd + offs, "VERN?"); COPY_SCOPE_STRING(sc, cmd, ch->vernier);
246 }
247
248 int update_scope_status(struct scope *sc)
249 {
250 bzero(&(sc->status), sizeof(sc->status));
251
252 COPY_SCOPE_STRING(sc, ":INFO:LANG?", sc->status.system.lang);
253
254 sc->status.system.counter_enabled = scope_get_truth_value(sc, ":COUN:ENAB?");
255 sc->status.system.beep_enabled = scope_get_truth_value(sc, ":BEEP:ENAB?");
256
257 sc->status.keyboard.key_lock = scope_get_truth_value(sc, ":KEY:LOCK?");
258
259 update_scope_measurements(sc);
260
261 COPY_SCOPE_STRING(sc, ":DISP:TYPE?", sc->status.display.type);
262 COPY_SCOPE_STRING(sc, ":DISP:GRID?", sc->status.display.grid);
263 sc->status.display.persist = scope_get_truth_value(sc, ":DISP:PERS?");
264 COPY_SCOPE_STRING(sc, ":DISP:MNUD?", sc->status.display.mnudisplay);
265 sc->status.display.mnustatus = scope_get_truth_value(sc, ":DISP:MNUS?");
266 COPY_SCOPE_STRING(sc, ":DISP:SCR?", sc->status.display.screen);
267 sc->status.display.brightness = scope_get_int(sc, ":DISP:BRIG?");
268 sc->status.display.intensity = scope_get_int(sc, ":DISP:INT?");
269
270 update_scope_channel(sc, 1);
271 update_scope_channel(sc, 2);
272
273 COPY_SCOPE_STRING(sc, ":ACQ:TYPE?", sc->status.acquire.type);
274 COPY_SCOPE_STRING(sc, ":ACQ:MODE?", sc->status.acquire.mode);
275
276 sc->status.acquire.averages = scope_get_int(sc, ":ACQ:AVER?");
277 sc->status.acquire.srate_ch1 = scope_get_double(sc, ":ACQ:SAMP? CHAN1");
278 sc->status.acquire.srate_ch2 = scope_get_double(sc, ":ACQ:SAMP? CHAN2");
279 sc->status.acquire.srate_digital = scope_get_double(sc, ":ACQ:SAMP? DIGITAL");
280
281 COPY_SCOPE_STRING(sc, ":TIM:MODE?", sc->status.timebase.mode);
282 sc->status.timebase.offset = scope_get_double(sc, ":TIM:OFFS?");
283 sc->status.timebase.delayed_offset = scope_get_double(sc, ":TIM:DEL:OFFS?");
284 sc->status.timebase.scale = scope_get_double(sc, ":TIM:SCAL?");
285 COPY_SCOPE_STRING(sc, ":TIM:FORM?", sc->status.timebase.format);
286
287 sc->status.math.displayed = scope_get_truth_value(sc, ":MATH:DISP?");
288 sc->status.fft.displayed = scope_get_truth_value(sc, ":FFT:DISP?");
289
290 return 0;
291 }
Impressum, Datenschutz