]> sigrok.org Git - libsigrok.git/blame_incremental - src/hardware/rigol-ds/api.c
projects / libsigrok.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
clear_helper(): Use a cast to shorten all implementations.
[libsigrok.git] / src / hardware / rigol-ds / api.c
... / ...
CommitLineData
1/*
2 * This file is part of the libsigrok project.
3 *
4 * Copyright (C) 2012 Martin Ling <martin-git@earth.li>
5 * Copyright (C) 2013 Bert Vermeulen <bert@biot.com>
6 * Copyright (C) 2013 Mathias Grimmberger <mgri@zaphod.sax.de>
7 *
8 * This program is free software: you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation, either version 3 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program. If not, see <http://www.gnu.org/licenses/>.
20 */
21
22#include <config.h>
23#include <fcntl.h>
24#include <unistd.h>
25#include <stdlib.h>
26#include <string.h>
27#include <strings.h>
28#include <math.h>
29#include <glib.h>
30#include <libsigrok/libsigrok.h>
31#include "libsigrok-internal.h"
32#include "scpi.h"
33#include "protocol.h"
34
35static const uint32_t scanopts[] = {
36 SR_CONF_CONN,
37 SR_CONF_SERIALCOMM
38};
39
40static const uint32_t drvopts[] = {
41 SR_CONF_OSCILLOSCOPE,
42};
43
44static const uint32_t devopts[] = {
45 SR_CONF_LIMIT_FRAMES | SR_CONF_SET,
46 SR_CONF_SAMPLERATE | SR_CONF_GET,
47 SR_CONF_TIMEBASE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
48 SR_CONF_NUM_HDIV | SR_CONF_GET,
49 SR_CONF_HORIZ_TRIGGERPOS | SR_CONF_SET,
50 SR_CONF_TRIGGER_SOURCE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
51 SR_CONF_TRIGGER_SLOPE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
52 SR_CONF_TRIGGER_LEVEL | SR_CONF_GET | SR_CONF_SET,
53 SR_CONF_DATA_SOURCE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
54};
55
56static const uint32_t analog_devopts[] = {
57 SR_CONF_NUM_VDIV | SR_CONF_GET,
58 SR_CONF_VDIV | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
59 SR_CONF_COUPLING | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
60 SR_CONF_PROBE_FACTOR | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
61};
62
63static const uint64_t timebases[][2] = {
64 /* nanoseconds */
65 { 1, 1000000000 },
66 { 2, 1000000000 },
67 { 5, 1000000000 },
68 { 10, 1000000000 },
69 { 20, 1000000000 },
70 { 50, 1000000000 },
71 { 100, 1000000000 },
72 { 500, 1000000000 },
73 /* microseconds */
74 { 1, 1000000 },
75 { 2, 1000000 },
76 { 5, 1000000 },
77 { 10, 1000000 },
78 { 20, 1000000 },
79 { 50, 1000000 },
80 { 100, 1000000 },
81 { 200, 1000000 },
82 { 500, 1000000 },
83 /* milliseconds */
84 { 1, 1000 },
85 { 2, 1000 },
86 { 5, 1000 },
87 { 10, 1000 },
88 { 20, 1000 },
89 { 50, 1000 },
90 { 100, 1000 },
91 { 200, 1000 },
92 { 500, 1000 },
93 /* seconds */
94 { 1, 1 },
95 { 2, 1 },
96 { 5, 1 },
97 { 10, 1 },
98 { 20, 1 },
99 { 50, 1 },
100 { 100, 1 },
101 { 200, 1 },
102 { 500, 1 },
103 { 1000, 1 },
104};
105
106static const uint64_t vdivs[][2] = {
107 /* microvolts */
108 { 500, 1000000 },
109 /* millivolts */
110 { 1, 1000 },
111 { 2, 1000 },
112 { 5, 1000 },
113 { 10, 1000 },
114 { 20, 1000 },
115 { 50, 1000 },
116 { 100, 1000 },
117 { 200, 1000 },
118 { 500, 1000 },
119 /* volts */
120 { 1, 1 },
121 { 2, 1 },
122 { 5, 1 },
123 { 10, 1 },
124 { 20, 1 },
125 { 50, 1 },
126 { 100, 1 },
127};
128
129#define NUM_TIMEBASE ARRAY_SIZE(timebases)
130#define NUM_VDIV ARRAY_SIZE(vdivs)
131
132static const char *trigger_sources[] = {
133 "CH1",
134 "CH2",
135 "CH3",
136 "CH4",
137 "EXT",
138 "AC Line",
139 "D0",
140 "D1",
141 "D2",
142 "D3",
143 "D4",
144 "D5",
145 "D6",
146 "D7",
147 "D8",
148 "D9",
149 "D10",
150 "D11",
151 "D12",
152 "D13",
153 "D14",
154 "D15",
155};
156
157static const char *trigger_slopes[] = {
158 "r",
159 "f",
160};
161
162static const char *coupling[] = {
163 "AC",
164 "DC",
165 "GND",
166};
167
168static const uint64_t probe_factor[] = {
169 1,
170 2,
171 5,
172 10,
173 20,
174 50,
175 100,
176 200,
177 500,
178 1000,
179};
180
181/* Do not change the order of entries */
182static const char *data_sources[] = {
183 "Live",
184 "Memory",
185 "Segmented",
186};
187
188enum vendor {
189 RIGOL,
190 AGILENT,
191};
192
193enum series {
194 VS5000,
195 DS1000,
196 DS2000,
197 DS2000A,
198 DSO1000,
199 DS1000Z,
200};
201
202/* short name, full name */
203static const struct rigol_ds_vendor supported_vendors[] = {
204 [RIGOL] = {"Rigol", "Rigol Technologies"},
205 [AGILENT] = {"Agilent", "Agilent Technologies"},
206};
207
208#define VENDOR(x) &supported_vendors[x]
209/* vendor, series, protocol, max timebase, min vdiv, number of horizontal divs,
210 * live waveform samples, memory buffer samples */
211static const struct rigol_ds_series supported_series[] = {
212 [VS5000] = {VENDOR(RIGOL), "VS5000", PROTOCOL_V1, FORMAT_RAW,
213 {50, 1}, {2, 1000}, 14, 2048, 0},
214 [DS1000] = {VENDOR(RIGOL), "DS1000", PROTOCOL_V2, FORMAT_IEEE488_2,
215 {50, 1}, {2, 1000}, 12, 600, 1048576},
216 [DS2000] = {VENDOR(RIGOL), "DS2000", PROTOCOL_V3, FORMAT_IEEE488_2,
217 {500, 1}, {500, 1000000}, 14, 1400, 14000},
218 [DS2000A] = {VENDOR(RIGOL), "DS2000A", PROTOCOL_V3, FORMAT_IEEE488_2,
219 {1000, 1}, {500, 1000000}, 14, 1400, 14000},
220 [DSO1000] = {VENDOR(AGILENT), "DSO1000", PROTOCOL_V3, FORMAT_IEEE488_2,
221 {50, 1}, {2, 1000}, 12, 600, 20480},
222 [DS1000Z] = {VENDOR(RIGOL), "DS1000Z", PROTOCOL_V4, FORMAT_IEEE488_2,
223 {50, 1}, {1, 1000}, 12, 1200, 12000000},
224};
225
226#define SERIES(x) &supported_series[x]
227/* series, model, min timebase, analog channels, digital */
228static const struct rigol_ds_model supported_models[] = {
229 {SERIES(VS5000), "VS5022", {20, 1000000000}, 2, false},
230 {SERIES(VS5000), "VS5042", {10, 1000000000}, 2, false},
231 {SERIES(VS5000), "VS5062", {5, 1000000000}, 2, false},
232 {SERIES(VS5000), "VS5102", {2, 1000000000}, 2, false},
233 {SERIES(VS5000), "VS5202", {2, 1000000000}, 2, false},
234 {SERIES(VS5000), "VS5022D", {20, 1000000000}, 2, true},
235 {SERIES(VS5000), "VS5042D", {10, 1000000000}, 2, true},
236 {SERIES(VS5000), "VS5062D", {5, 1000000000}, 2, true},
237 {SERIES(VS5000), "VS5102D", {2, 1000000000}, 2, true},
238 {SERIES(VS5000), "VS5202D", {2, 1000000000}, 2, true},
239 {SERIES(DS1000), "DS1052E", {5, 1000000000}, 2, false},
240 {SERIES(DS1000), "DS1102E", {2, 1000000000}, 2, false},
241 {SERIES(DS1000), "DS1152E", {2, 1000000000}, 2, false},
242 {SERIES(DS1000), "DS1052D", {5, 1000000000}, 2, true},
243 {SERIES(DS1000), "DS1102D", {2, 1000000000}, 2, true},
244 {SERIES(DS1000), "DS1152D", {2, 1000000000}, 2, true},
245 {SERIES(DS2000), "DS2072", {5, 1000000000}, 2, false},
246 {SERIES(DS2000), "DS2102", {5, 1000000000}, 2, false},
247 {SERIES(DS2000), "DS2202", {2, 1000000000}, 2, false},
248 {SERIES(DS2000), "DS2302", {1, 1000000000}, 2, false},
249 {SERIES(DS2000A), "DS2072A", {5, 1000000000}, 2, false},
250 {SERIES(DS2000A), "DS2102A", {5, 1000000000}, 2, false},
251 {SERIES(DS2000A), "DS2202A", {2, 1000000000}, 2, false},
252 {SERIES(DS2000A), "DS2302A", {1, 1000000000}, 2, false},
253 {SERIES(DS2000A), "MSO2072A", {5, 1000000000}, 2, true},
254 {SERIES(DS2000A), "MSO2102A", {5, 1000000000}, 2, true},
255 {SERIES(DS2000A), "MSO2202A", {2, 1000000000}, 2, true},
256 {SERIES(DS2000A), "MSO2302A", {1, 1000000000}, 2, true},
257 {SERIES(DSO1000), "DSO1002A", {5, 1000000000}, 2, false},
258 {SERIES(DSO1000), "DSO1004A", {5, 1000000000}, 4, false},
259 {SERIES(DSO1000), "DSO1012A", {2, 1000000000}, 2, false},
260 {SERIES(DSO1000), "DSO1014A", {2, 1000000000}, 4, false},
261 {SERIES(DSO1000), "DSO1022A", {2, 1000000000}, 2, false},
262 {SERIES(DSO1000), "DSO1024A", {2, 1000000000}, 4, false},
263 {SERIES(DS1000Z), "DS1054Z", {5, 1000000000}, 4, false},
264 {SERIES(DS1000Z), "DS1074Z", {5, 1000000000}, 4, false},
265 {SERIES(DS1000Z), "DS1104Z", {5, 1000000000}, 4, false},
266 {SERIES(DS1000Z), "DS1074Z-S", {5, 1000000000}, 4, false},
267 {SERIES(DS1000Z), "DS1104Z-S", {5, 1000000000}, 4, false},
268 {SERIES(DS1000Z), "DS1074Z Plus", {5, 1000000000}, 4, false},
269 {SERIES(DS1000Z), "DS1104Z Plus", {5, 1000000000}, 4, false},
270 {SERIES(DS1000Z), "MSO1074Z", {5, 1000000000}, 4, true},
271 {SERIES(DS1000Z), "MSO1104Z", {5, 1000000000}, 4, true},
272 {SERIES(DS1000Z), "MSO1074Z-S", {5, 1000000000}, 4, true},
273 {SERIES(DS1000Z), "MSO1104Z-S", {5, 1000000000}, 4, true},
274};
275
276static struct sr_dev_driver rigol_ds_driver_info;
277
278static void clear_helper(struct dev_context *devc)
279{
280 unsigned int i;
281
282 g_free(devc->data);
283 g_free(devc->buffer);
284 for (i = 0; i < ARRAY_SIZE(devc->coupling); i++)
285 g_free(devc->coupling[i]);
286 g_free(devc->trigger_source);
287 g_free(devc->trigger_slope);
288 g_free(devc->analog_groups);
289}
290
291static int dev_clear(const struct sr_dev_driver *di)
292{
293 return std_dev_clear_with_callback(di, (std_dev_clear_callback)clear_helper);
294}
295
296static struct sr_dev_inst *probe_device(struct sr_scpi_dev_inst *scpi)
297{
298 struct dev_context *devc;
299 struct sr_dev_inst *sdi;
300 struct sr_scpi_hw_info *hw_info;
301 struct sr_channel *ch;
302 long n[3];
303 unsigned int i;
304 const struct rigol_ds_model *model = NULL;
305 gchar *channel_name, **version;
306
307 if (sr_scpi_get_hw_id(scpi, &hw_info) != SR_OK) {
308 sr_info("Couldn't get IDN response, retrying.");
309 sr_scpi_close(scpi);
310 sr_scpi_open(scpi);
311 if (sr_scpi_get_hw_id(scpi, &hw_info) != SR_OK) {
312 sr_info("Couldn't get IDN response.");
313 return NULL;
314 }
315 }
316
317 for (i = 0; i < ARRAY_SIZE(supported_models); i++) {
318 if (!g_ascii_strcasecmp(hw_info->manufacturer,
319 supported_models[i].series->vendor->full_name) &&
320 !strcmp(hw_info->model, supported_models[i].name)) {
321 model = &supported_models[i];
322 break;
323 }
324 }
325
326 if (!model) {
327 sr_scpi_hw_info_free(hw_info);
328 return NULL;
329 }
330
331 sdi = g_malloc0(sizeof(struct sr_dev_inst));
332 sdi->vendor = g_strdup(model->series->vendor->name);
333 sdi->model = g_strdup(model->name);
334 sdi->version = g_strdup(hw_info->firmware_version);
335 sdi->conn = scpi;
336 sdi->driver = &rigol_ds_driver_info;
337 sdi->inst_type = SR_INST_SCPI;
338 sdi->serial_num = g_strdup(hw_info->serial_number);
339 devc = g_malloc0(sizeof(struct dev_context));
340 devc->limit_frames = 0;
341 devc->model = model;
342 devc->format = model->series->format;
343
344 /* DS1000 models with firmware before 0.2.4 used the old data format. */
345 if (model->series == SERIES(DS1000)) {
346 version = g_strsplit(hw_info->firmware_version, ".", 0);
347 do {
348 if (!version[0] || !version[1] || !version[2])
349 break;
350 if (version[0][0] == 0 || version[1][0] == 0 || version[2][0] == 0)
351 break;
352 for (i = 0; i < 3; i++) {
353 if (sr_atol(version[i], &n[i]) != SR_OK)
354 break;
355 }
356 if (i != 3)
357 break;
358 scpi->firmware_version = n[0] * 100 + n[1] * 10 + n[2];
359 if (scpi->firmware_version < 24) {
360 sr_dbg("Found DS1000 firmware < 0.2.4, using raw data format.");
361 devc->format = FORMAT_RAW;
362 }
363 break;
364 } while (0);
365 g_strfreev(version);
366 }
367
368 sr_scpi_hw_info_free(hw_info);
369
370 devc->analog_groups = g_malloc0(sizeof(struct sr_channel_group*) *
371 model->analog_channels);
372
373 for (i = 0; i < model->analog_channels; i++) {
374 channel_name = g_strdup_printf("CH%d", i + 1);
375 ch = sr_channel_new(sdi, i, SR_CHANNEL_ANALOG, TRUE, channel_name);
376
377 devc->analog_groups[i] = g_malloc0(sizeof(struct sr_channel_group));
378
379 devc->analog_groups[i]->name = channel_name;
380 devc->analog_groups[i]->channels = g_slist_append(NULL, ch);
381 sdi->channel_groups = g_slist_append(sdi->channel_groups,
382 devc->analog_groups[i]);
383 }
384
385 if (devc->model->has_digital) {
386 devc->digital_group = g_malloc0(sizeof(struct sr_channel_group));
387
388 for (i = 0; i < ARRAY_SIZE(devc->digital_channels); i++) {
389 channel_name = g_strdup_printf("D%d", i);
390 ch = sr_channel_new(sdi, i, SR_CHANNEL_LOGIC, TRUE, channel_name);
391 g_free(channel_name);
392 devc->digital_group->channels = g_slist_append(
393 devc->digital_group->channels, ch);
394 }
395 devc->digital_group->name = g_strdup("LA");
396 sdi->channel_groups = g_slist_append(sdi->channel_groups,
397 devc->digital_group);
398 }
399
400 for (i = 0; i < NUM_TIMEBASE; i++) {
401 if (!memcmp(&devc->model->min_timebase, &timebases[i], sizeof(uint64_t[2])))
402 devc->timebases = &timebases[i];
403 if (!memcmp(&devc->model->series->max_timebase, &timebases[i], sizeof(uint64_t[2])))
404 devc->num_timebases = &timebases[i] - devc->timebases + 1;
405 }
406
407 for (i = 0; i < NUM_VDIV; i++) {
408 if (!memcmp(&devc->model->series->min_vdiv,
409 &vdivs[i], sizeof(uint64_t[2]))) {
410 devc->vdivs = &vdivs[i];
411 devc->num_vdivs = NUM_VDIV - i;
412 }
413 }
414
415 devc->buffer = g_malloc(ACQ_BUFFER_SIZE);
416 devc->data = g_malloc(ACQ_BUFFER_SIZE * sizeof(float));
417
418 devc->data_source = DATA_SOURCE_LIVE;
419
420 sdi->priv = devc;
421
422 return sdi;
423}
424
425static GSList *scan(struct sr_dev_driver *di, GSList *options)
426{
427 return sr_scpi_scan(di->context, options, probe_device);
428}
429
430static int dev_open(struct sr_dev_inst *sdi)
431{
432 int ret;
433 struct sr_scpi_dev_inst *scpi = sdi->conn;
434
435 if ((ret = sr_scpi_open(scpi)) < 0) {
436 sr_err("Failed to open SCPI device: %s.", sr_strerror(ret));
437 return SR_ERR;
438 }
439
440 if ((ret = rigol_ds_get_dev_cfg(sdi)) < 0) {
441 sr_err("Failed to get device config: %s.", sr_strerror(ret));
442 return SR_ERR;
443 }
444
445 return SR_OK;
446}
447
448static int dev_close(struct sr_dev_inst *sdi)
449{
450 struct sr_scpi_dev_inst *scpi;
451 struct dev_context *devc;
452
453 scpi = sdi->conn;
454 devc = sdi->priv;
455
456 if (!scpi)
457 return SR_ERR_BUG;
458
459 if (devc->model->series->protocol == PROTOCOL_V2)
460 rigol_ds_config_set(sdi, ":KEY:LOCK DISABLE");
461
462 return sr_scpi_close(scpi);
463}
464
465static int analog_frame_size(const struct sr_dev_inst *sdi)
466{
467 struct dev_context *devc = sdi->priv;
468 struct sr_channel *ch;
469 int analog_channels = 0;
470 GSList *l;
471
472 for (l = sdi->channels; l; l = l->next) {
473 ch = l->data;
474 if (ch->type == SR_CHANNEL_ANALOG && ch->enabled)
475 analog_channels++;
476 }
477
478 if (analog_channels == 0)
479 return 0;
480
481 switch (devc->data_source) {
482 case DATA_SOURCE_LIVE:
483 return devc->model->series->live_samples;
484 case DATA_SOURCE_MEMORY:
485 return devc->model->series->buffer_samples / analog_channels;
486 default:
487 return 0;
488 }
489}
490
491static int digital_frame_size(const struct sr_dev_inst *sdi)
492{
493 struct dev_context *devc = sdi->priv;
494
495 switch (devc->data_source) {
496 case DATA_SOURCE_LIVE:
497 return devc->model->series->live_samples * 2;
498 case DATA_SOURCE_MEMORY:
499 return devc->model->series->buffer_samples * 2;
500 default:
501 return 0;
502 }
503}
504
505static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
506 const struct sr_channel_group *cg)
507{
508 struct dev_context *devc;
509 struct sr_channel *ch;
510 const char *tmp_str;
511 uint64_t samplerate;
512 int analog_channel = -1;
513 float smallest_diff = INFINITY;
514 int idx = -1;
515 unsigned i;
516
517 if (!sdi)
518 return SR_ERR_ARG;
519
520 devc = sdi->priv;
521
522 /* If a channel group is specified, it must be a valid one. */
523 if (cg && !g_slist_find(sdi->channel_groups, cg)) {
524 sr_err("Invalid channel group specified.");
525 return SR_ERR;
526 }
527
528 if (cg) {
529 ch = g_slist_nth_data(cg->channels, 0);
530 if (!ch)
531 return SR_ERR;
532 if (ch->type == SR_CHANNEL_ANALOG) {
533 if (ch->name[2] < '1' || ch->name[2] > '4')
534 return SR_ERR;
535 analog_channel = ch->name[2] - '1';
536 }
537 }
538
539 switch (key) {
540 case SR_CONF_NUM_HDIV:
541 *data = g_variant_new_int32(devc->model->series->num_horizontal_divs);
542 break;
543 case SR_CONF_NUM_VDIV:
544 *data = g_variant_new_int32(devc->num_vdivs);
545 break;
546 case SR_CONF_DATA_SOURCE:
547 if (devc->data_source == DATA_SOURCE_LIVE)
548 *data = g_variant_new_string("Live");
549 else if (devc->data_source == DATA_SOURCE_MEMORY)
550 *data = g_variant_new_string("Memory");
551 else
552 *data = g_variant_new_string("Segmented");
553 break;
554 case SR_CONF_SAMPLERATE:
555 if (devc->data_source == DATA_SOURCE_LIVE) {
556 samplerate = analog_frame_size(sdi) /
557 (devc->timebase * devc->model->series->num_horizontal_divs);
558 *data = g_variant_new_uint64(samplerate);
559 } else {
560 sr_dbg("Unknown data source: %d.", devc->data_source);
561 return SR_ERR_NA;
562 }
563 break;
564 case SR_CONF_TRIGGER_SOURCE:
565 if (!strcmp(devc->trigger_source, "ACL"))
566 tmp_str = "AC Line";
567 else if (!strcmp(devc->trigger_source, "CHAN1"))
568 tmp_str = "CH1";
569 else if (!strcmp(devc->trigger_source, "CHAN2"))
570 tmp_str = "CH2";
571 else if (!strcmp(devc->trigger_source, "CHAN3"))
572 tmp_str = "CH3";
573 else if (!strcmp(devc->trigger_source, "CHAN4"))
574 tmp_str = "CH4";
575 else
576 tmp_str = devc->trigger_source;
577 *data = g_variant_new_string(tmp_str);
578 break;
579 case SR_CONF_TRIGGER_SLOPE:
580 if (!strncmp(devc->trigger_slope, "POS", 3)) {
581 tmp_str = "r";
582 } else if (!strncmp(devc->trigger_slope, "NEG", 3)) {
583 tmp_str = "f";
584 } else {
585 sr_dbg("Unknown trigger slope: '%s'.", devc->trigger_slope);
586 return SR_ERR_NA;
587 }
588 *data = g_variant_new_string(tmp_str);
589 break;
590 case SR_CONF_TRIGGER_LEVEL:
591 *data = g_variant_new_double(devc->trigger_level);
592 break;
593 case SR_CONF_TIMEBASE:
594 for (i = 0; i < devc->num_timebases; i++) {
595 float tb = (float)devc->timebases[i][0] / devc->timebases[i][1];
596 float diff = fabs(devc->timebase - tb);
597 if (diff < smallest_diff) {
598 smallest_diff = diff;
599 idx = i;
600 }
601 }
602 if (idx < 0) {
603 sr_dbg("Negative timebase index: %d.", idx);
604 return SR_ERR_NA;
605 }
606 *data = g_variant_new("(tt)", devc->timebases[idx][0],
607 devc->timebases[idx][1]);
608 break;
609 case SR_CONF_VDIV:
610 if (analog_channel < 0) {
611 sr_dbg("Negative analog channel: %d.", analog_channel);
612 return SR_ERR_NA;
613 }
614 for (i = 0; i < ARRAY_SIZE(vdivs); i++) {
615 float vdiv = (float)vdivs[i][0] / vdivs[i][1];
616 float diff = fabs(devc->vdiv[analog_channel] - vdiv);
617 if (diff < smallest_diff) {
618 smallest_diff = diff;
619 idx = i;
620 }
621 }
622 if (idx < 0) {
623 sr_dbg("Negative vdiv index: %d.", idx);
624 return SR_ERR_NA;
625 }
626 *data = g_variant_new("(tt)", vdivs[idx][0], vdivs[idx][1]);
627 break;
628 case SR_CONF_COUPLING:
629 if (analog_channel < 0) {
630 sr_dbg("Negative analog channel: %d.", analog_channel);
631 return SR_ERR_NA;
632 }
633 *data = g_variant_new_string(devc->coupling[analog_channel]);
634 break;
635 case SR_CONF_PROBE_FACTOR:
636 if (analog_channel < 0) {
637 sr_dbg("Negative analog channel: %d.", analog_channel);
638 return SR_ERR_NA;
639 }
640 *data = g_variant_new_uint64(devc->attenuation[analog_channel]);
641 break;
642 default:
643 return SR_ERR_NA;
644 }
645
646 return SR_OK;
647}
648
649static int config_set(uint32_t key, GVariant *data, const struct sr_dev_inst *sdi,
650 const struct sr_channel_group *cg)
651{
652 struct dev_context *devc;
653 uint64_t p, q;
654 double t_dbl;
655 unsigned int i, j;
656 int ret;
657 const char *tmp_str;
658 char buffer[16];
659
660 devc = sdi->priv;
661
662 /* If a channel group is specified, it must be a valid one. */
663 if (cg && !g_slist_find(sdi->channel_groups, cg)) {
664 sr_err("Invalid channel group specified.");
665 return SR_ERR;
666 }
667
668 ret = SR_OK;
669 switch (key) {
670 case SR_CONF_LIMIT_FRAMES:
671 devc->limit_frames = g_variant_get_uint64(data);
672 break;
673 case SR_CONF_TRIGGER_SLOPE:
674 tmp_str = g_variant_get_string(data, NULL);
675
676 if (!tmp_str || !(tmp_str[0] == 'f' || tmp_str[0] == 'r')) {
677 sr_err("Unknown trigger slope: '%s'.",
678 (tmp_str) ? tmp_str : "NULL");
679 return SR_ERR_ARG;
680 }
681
682 g_free(devc->trigger_slope);
683 devc->trigger_slope = g_strdup((tmp_str[0] == 'r') ? "POS" : "NEG");
684 ret = rigol_ds_config_set(sdi, ":TRIG:EDGE:SLOP %s", devc->trigger_slope);
685 break;
686 case SR_CONF_HORIZ_TRIGGERPOS:
687 t_dbl = g_variant_get_double(data);
688 if (t_dbl < 0.0 || t_dbl > 1.0) {
689 sr_err("Invalid horiz. trigger position: %g.", t_dbl);
690 return SR_ERR;
691 }
692 devc->horiz_triggerpos = t_dbl;
693 /* We have the trigger offset as a percentage of the frame, but
694 * need to express this in seconds. */
695 t_dbl = -(devc->horiz_triggerpos - 0.5) * devc->timebase * devc->num_timebases;
696 g_ascii_formatd(buffer, sizeof(buffer), "%.6f", t_dbl);
697 ret = rigol_ds_config_set(sdi, ":TIM:OFFS %s", buffer);
698 break;
699 case SR_CONF_TRIGGER_LEVEL:
700 t_dbl = g_variant_get_double(data);
701 g_ascii_formatd(buffer, sizeof(buffer), "%.3f", t_dbl);
702 ret = rigol_ds_config_set(sdi, ":TRIG:EDGE:LEV %s", buffer);
703 if (ret == SR_OK)
704 devc->trigger_level = t_dbl;
705 break;
706 case SR_CONF_TIMEBASE:
707 g_variant_get(data, "(tt)", &p, &q);
708 for (i = 0; i < devc->num_timebases; i++) {
709 if (devc->timebases[i][0] == p && devc->timebases[i][1] == q) {
710 devc->timebase = (float)p / q;
711 g_ascii_formatd(buffer, sizeof(buffer), "%.9f",
712 devc->timebase);
713 ret = rigol_ds_config_set(sdi, ":TIM:SCAL %s", buffer);
714 break;
715 }
716 }
717 if (i == devc->num_timebases) {
718 sr_err("Invalid timebase index: %d.", i);
719 ret = SR_ERR_ARG;
720 }
721 break;
722 case SR_CONF_TRIGGER_SOURCE:
723 tmp_str = g_variant_get_string(data, NULL);
724 for (i = 0; i < ARRAY_SIZE(trigger_sources); i++) {
725 if (!strcmp(trigger_sources[i], tmp_str)) {
726 g_free(devc->trigger_source);
727 devc->trigger_source = g_strdup(trigger_sources[i]);
728 if (!strcmp(devc->trigger_source, "AC Line"))
729 tmp_str = "ACL";
730 else if (!strcmp(devc->trigger_source, "CH1"))
731 tmp_str = "CHAN1";
732 else if (!strcmp(devc->trigger_source, "CH2"))
733 tmp_str = "CHAN2";
734 else if (!strcmp(devc->trigger_source, "CH3"))
735 tmp_str = "CHAN3";
736 else if (!strcmp(devc->trigger_source, "CH4"))
737 tmp_str = "CHAN4";
738 else
739 tmp_str = (char *)devc->trigger_source;
740 ret = rigol_ds_config_set(sdi, ":TRIG:EDGE:SOUR %s", tmp_str);
741 break;
742 }
743 }
744 if (i == ARRAY_SIZE(trigger_sources)) {
745 sr_err("Invalid trigger source index: %d.", i);
746 ret = SR_ERR_ARG;
747 }
748 break;
749 case SR_CONF_VDIV:
750 if (!cg) {
751 sr_err("No channel group specified.");
752 return SR_ERR_CHANNEL_GROUP;
753 }
754 g_variant_get(data, "(tt)", &p, &q);
755 for (i = 0; i < devc->model->analog_channels; i++) {
756 if (cg == devc->analog_groups[i]) {
757 for (j = 0; j < ARRAY_SIZE(vdivs); j++) {
758 if (vdivs[j][0] != p || vdivs[j][1] != q)
759 continue;
760 devc->vdiv[i] = (float)p / q;
761 g_ascii_formatd(buffer, sizeof(buffer), "%.3f",
762 devc->vdiv[i]);
763 return rigol_ds_config_set(sdi, ":CHAN%d:SCAL %s", i + 1,
764 buffer);
765 }
766 sr_err("Invalid vdiv index: %d.", j);
767 return SR_ERR_ARG;
768 }
769 }
770 sr_dbg("Didn't set vdiv, unknown channel(group).");
771 return SR_ERR_NA;
772 case SR_CONF_COUPLING:
773 if (!cg) {
774 sr_err("No channel group specified.");
775 return SR_ERR_CHANNEL_GROUP;
776 }
777 tmp_str = g_variant_get_string(data, NULL);
778 for (i = 0; i < devc->model->analog_channels; i++) {
779 if (cg == devc->analog_groups[i]) {
780 for (j = 0; j < ARRAY_SIZE(coupling); j++) {
781 if (!strcmp(tmp_str, coupling[j])) {
782 g_free(devc->coupling[i]);
783 devc->coupling[i] = g_strdup(coupling[j]);
784 return rigol_ds_config_set(sdi, ":CHAN%d:COUP %s", i + 1,
785 devc->coupling[i]);
786 }
787 }
788 sr_err("Invalid coupling index: %d.", j);
789 return SR_ERR_ARG;
790 }
791 }
792 sr_dbg("Didn't set coupling, unknown channel(group).");
793 return SR_ERR_NA;
794 case SR_CONF_PROBE_FACTOR:
795 if (!cg) {
796 sr_err("No channel group specified.");
797 return SR_ERR_CHANNEL_GROUP;
798 }
799 p = g_variant_get_uint64(data);
800 for (i = 0; i < devc->model->analog_channels; i++) {
801 if (cg == devc->analog_groups[i]) {
802 for (j = 0; j < ARRAY_SIZE(probe_factor); j++) {
803 if (p == probe_factor[j]) {
804 devc->attenuation[i] = p;
805 ret = rigol_ds_config_set(sdi, ":CHAN%d:PROB %"PRIu64,
806 i + 1, p);
807 if (ret == SR_OK)
808 rigol_ds_get_dev_cfg_vertical(sdi);
809 return ret;
810 }
811 }
812 sr_err("Invalid probe factor: %"PRIu64".", p);
813 return SR_ERR_ARG;
814 }
815 }
816 sr_dbg("Didn't set probe factor, unknown channel(group).");
817 return SR_ERR_NA;
818 case SR_CONF_DATA_SOURCE:
819 tmp_str = g_variant_get_string(data, NULL);
820 if (!strcmp(tmp_str, "Live"))
821 devc->data_source = DATA_SOURCE_LIVE;
822 else if (devc->model->series->protocol >= PROTOCOL_V2
823 && !strcmp(tmp_str, "Memory"))
824 devc->data_source = DATA_SOURCE_MEMORY;
825 else if (devc->model->series->protocol >= PROTOCOL_V3
826 && !strcmp(tmp_str, "Segmented"))
827 devc->data_source = DATA_SOURCE_SEGMENTED;
828 else {
829 sr_err("Unknown data source: '%s'.", tmp_str);
830 return SR_ERR;
831 }
832 break;
833 default:
834 return SR_ERR_NA;
835 }
836
837 return ret;
838}
839
840static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
841 const struct sr_channel_group *cg)
842{
843 GVariant *tuple, *rational[2];
844 GVariantBuilder gvb;
845 unsigned int i;
846 struct dev_context *devc = NULL;
847
848 /* SR_CONF_SCAN_OPTIONS is always valid, regardless of sdi or channel group. */
849 if (key == SR_CONF_SCAN_OPTIONS) {
850 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
851 scanopts, ARRAY_SIZE(scanopts), sizeof(uint32_t));
852 return SR_OK;
853 }
854
855 /* If sdi is NULL, nothing except SR_CONF_DEVICE_OPTIONS can be provided. */
856 if (key == SR_CONF_DEVICE_OPTIONS && !sdi) {
857 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
858 drvopts, ARRAY_SIZE(drvopts), sizeof(uint32_t));
859 return SR_OK;
860 }
861
862 /* Every other option requires a valid device instance. */
863 if (!sdi)
864 return SR_ERR_ARG;
865 devc = sdi->priv;
866
867 /* If a channel group is specified, it must be a valid one. */
868 if (cg && !g_slist_find(sdi->channel_groups, cg)) {
869 sr_err("Invalid channel group specified.");
870 return SR_ERR;
871 }
872
873 switch (key) {
874 case SR_CONF_DEVICE_OPTIONS:
875 if (!cg) {
876 /* If cg is NULL, only the SR_CONF_DEVICE_OPTIONS that are not
877 * specific to a channel group must be returned. */
878 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
879 devopts, ARRAY_SIZE(devopts), sizeof(uint32_t));
880 return SR_OK;
881 }
882 if (cg == devc->digital_group) {
883 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
884 NULL, 0, sizeof(uint32_t));
885 return SR_OK;
886 } else {
887 for (i = 0; i < devc->model->analog_channels; i++) {
888 if (cg == devc->analog_groups[i]) {
889 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
890 analog_devopts, ARRAY_SIZE(analog_devopts), sizeof(uint32_t));
891 return SR_OK;
892 }
893 }
894 return SR_ERR_NA;
895 }
896 break;
897 case SR_CONF_COUPLING:
898 if (!cg) {
899 sr_err("No channel group specified.");
900 return SR_ERR_CHANNEL_GROUP;
901 }
902 *data = g_variant_new_strv(coupling, ARRAY_SIZE(coupling));
903 break;
904 case SR_CONF_PROBE_FACTOR:
905 if (!cg) {
906 sr_err("No channel group specified.");
907 return SR_ERR_CHANNEL_GROUP;
908 }
909 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT64,
910 probe_factor, ARRAY_SIZE(probe_factor), sizeof(uint64_t));
911 break;
912 case SR_CONF_VDIV:
913 if (!devc)
914 /* Can't know this until we have the exact model. */
915 return SR_ERR_ARG;
916 if (!cg) {
917 sr_err("No channel group specified.");
918 return SR_ERR_CHANNEL_GROUP;
919 }
920 g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
921 for (i = 0; i < devc->num_vdivs; i++) {
922 rational[0] = g_variant_new_uint64(devc->vdivs[i][0]);
923 rational[1] = g_variant_new_uint64(devc->vdivs[i][1]);
924 tuple = g_variant_new_tuple(rational, 2);
925 g_variant_builder_add_value(&gvb, tuple);
926 }
927 *data = g_variant_builder_end(&gvb);
928 break;
929 case SR_CONF_TIMEBASE:
930 if (!devc)
931 /* Can't know this until we have the exact model. */
932 return SR_ERR_ARG;
933 if (devc->num_timebases <= 0)
934 return SR_ERR_NA;
935 g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
936 for (i = 0; i < devc->num_timebases; i++) {
937 rational[0] = g_variant_new_uint64(devc->timebases[i][0]);
938 rational[1] = g_variant_new_uint64(devc->timebases[i][1]);
939 tuple = g_variant_new_tuple(rational, 2);
940 g_variant_builder_add_value(&gvb, tuple);
941 }
942 *data = g_variant_builder_end(&gvb);
943 break;
944 case SR_CONF_TRIGGER_SOURCE:
945 if (!devc)
946 /* Can't know this until we have the exact model. */
947 return SR_ERR_ARG;
948 *data = g_variant_new_strv(trigger_sources,
949 devc->model->has_digital ? ARRAY_SIZE(trigger_sources) : 4);
950 break;
951 case SR_CONF_TRIGGER_SLOPE:
952 *data = g_variant_new_strv(trigger_slopes, ARRAY_SIZE(trigger_slopes));
953 break;
954 case SR_CONF_DATA_SOURCE:
955 if (!devc)
956 /* Can't know this until we have the exact model. */
957 return SR_ERR_ARG;
958 switch (devc->model->series->protocol) {
959 case PROTOCOL_V1:
960 *data = g_variant_new_strv(data_sources, ARRAY_SIZE(data_sources) - 2);
961 break;
962 case PROTOCOL_V2:
963 *data = g_variant_new_strv(data_sources, ARRAY_SIZE(data_sources) - 1);
964 break;
965 default:
966 *data = g_variant_new_strv(data_sources, ARRAY_SIZE(data_sources));
967 break;
968 }
969 break;
970 default:
971 return SR_ERR_NA;
972 }
973
974 return SR_OK;
975}
976
977static int dev_acquisition_start(const struct sr_dev_inst *sdi)
978{
979 struct sr_scpi_dev_inst *scpi;
980 struct dev_context *devc;
981 struct sr_channel *ch;
982 struct sr_datafeed_packet packet;
983 gboolean some_digital;
984 GSList *l;
985
986 scpi = sdi->conn;
987 devc = sdi->priv;
988
989 devc->num_frames = 0;
990
991 some_digital = FALSE;
992 for (l = sdi->channels; l; l = l->next) {
993 ch = l->data;
994 sr_dbg("handling channel %s", ch->name);
995 if (ch->type == SR_CHANNEL_ANALOG) {
996 if (ch->enabled)
997 devc->enabled_channels = g_slist_append(
998 devc->enabled_channels, ch);
999 if (ch->enabled != devc->analog_channels[ch->index]) {
1000 /* Enabled channel is currently disabled, or vice versa. */
1001 if (rigol_ds_config_set(sdi, ":CHAN%d:DISP %s", ch->index + 1,
1002 ch->enabled ? "ON" : "OFF") != SR_OK)
1003 return SR_ERR;
1004 devc->analog_channels[ch->index] = ch->enabled;
1005 }
1006 } else if (ch->type == SR_CHANNEL_LOGIC) {
1007 /* Only one list entry for older protocols. All channels are
1008 * retrieved together when this entry is processed. */
1009 if (ch->enabled && (
1010 devc->model->series->protocol > PROTOCOL_V3 ||
1011 !some_digital))
1012 devc->enabled_channels = g_slist_append(
1013 devc->enabled_channels, ch);
1014 if (ch->enabled) {
1015 some_digital = TRUE;
1016 /* Turn on LA module if currently off. */
1017 if (!devc->la_enabled) {
1018 if (rigol_ds_config_set(sdi,
1019 devc->model->series->protocol >= PROTOCOL_V3 ?
1020 ":LA:STAT ON" : ":LA:DISP ON") != SR_OK)
1021 return SR_ERR;
1022 devc->la_enabled = TRUE;
1023 }
1024 }
1025 if (ch->enabled != devc->digital_channels[ch->index]) {
1026 /* Enabled channel is currently disabled, or vice versa. */
1027 if (rigol_ds_config_set(sdi,
1028 devc->model->series->protocol >= PROTOCOL_V3 ?
1029 ":LA:DIG%d:DISP %s" : ":DIG%d:TURN %s", ch->index,
1030 ch->enabled ? "ON" : "OFF") != SR_OK)
1031 return SR_ERR;
1032 devc->digital_channels[ch->index] = ch->enabled;
1033 }
1034 }
1035 }
1036
1037 if (!devc->enabled_channels)
1038 return SR_ERR;
1039
1040 /* Turn off LA module if on and no digital channels selected. */
1041 if (devc->la_enabled && !some_digital)
1042 if (rigol_ds_config_set(sdi,
1043 devc->model->series->protocol >= PROTOCOL_V3 ?
1044 ":LA:STAT OFF" : ":LA:DISP OFF") != SR_OK)
1045 return SR_ERR;
1046
1047 /* Set memory mode. */
1048 if (devc->data_source == DATA_SOURCE_SEGMENTED) {
1049 sr_err("Data source 'Segmented' not yet supported");
1050 return SR_ERR;
1051 }
1052
1053 devc->analog_frame_size = analog_frame_size(sdi);
1054 devc->digital_frame_size = digital_frame_size(sdi);
1055
1056 switch (devc->model->series->protocol) {
1057 case PROTOCOL_V2:
1058 if (rigol_ds_config_set(sdi, ":ACQ:MEMD LONG") != SR_OK)
1059 return SR_ERR;
1060 break;
1061 case PROTOCOL_V3:
1062 /* Apparently for the DS2000 the memory
1063 * depth can only be set in Running state -
1064 * this matches the behaviour of the UI. */
1065 if (rigol_ds_config_set(sdi, ":RUN") != SR_OK)
1066 return SR_ERR;
1067 if (rigol_ds_config_set(sdi, ":ACQ:MDEP %d",
1068 devc->analog_frame_size) != SR_OK)
1069 return SR_ERR;
1070 if (rigol_ds_config_set(sdi, ":STOP") != SR_OK)
1071 return SR_ERR;
1072 break;
1073 default:
1074 break;
1075 }
1076
1077 if (devc->data_source == DATA_SOURCE_LIVE)
1078 if (rigol_ds_config_set(sdi, ":RUN") != SR_OK)
1079 return SR_ERR;
1080
1081 sr_scpi_source_add(sdi->session, scpi, G_IO_IN, 50,
1082 rigol_ds_receive, (void *)sdi);
1083
1084 std_session_send_df_header(sdi);
1085
1086 devc->channel_entry = devc->enabled_channels;
1087
1088 if (rigol_ds_capture_start(sdi) != SR_OK)
1089 return SR_ERR;
1090
1091 /* Start of first frame. */
1092 packet.type = SR_DF_FRAME_BEGIN;
1093 sr_session_send(sdi, &packet);
1094
1095 return SR_OK;
1096}
1097
1098static int dev_acquisition_stop(struct sr_dev_inst *sdi)
1099{
1100 struct dev_context *devc;
1101 struct sr_scpi_dev_inst *scpi;
1102
1103 devc = sdi->priv;
1104
1105 std_session_send_df_end(sdi);
1106
1107 g_slist_free(devc->enabled_channels);
1108 devc->enabled_channels = NULL;
1109 scpi = sdi->conn;
1110 sr_scpi_source_remove(sdi->session, scpi);
1111
1112 return SR_OK;
1113}
1114
1115static struct sr_dev_driver rigol_ds_driver_info = {
1116 .name = "rigol-ds",
1117 .longname = "Rigol DS",
1118 .api_version = 1,
1119 .init = std_init,
1120 .cleanup = std_cleanup,
1121 .scan = scan,
1122 .dev_list = std_dev_list,
1123 .dev_clear = dev_clear,
1124 .config_get = config_get,
1125 .config_set = config_set,
1126 .config_list = config_list,
1127 .dev_open = dev_open,
1128 .dev_close = dev_close,
1129 .dev_acquisition_start = dev_acquisition_start,
1130 .dev_acquisition_stop = dev_acquisition_stop,
1131 .context = NULL,
1132};
1133SR_REGISTER_DEV_DRIVER(rigol_ds_driver_info);
Hardware access and backend lib