]> sigrok.org Git - libsigrok.git/blame_incremental - hardware/rigol-ds/api.c
projects / libsigrok.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Create & use new sr_usbtmc_dev_inst for Rigol DS driver.
[libsigrok.git] / 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 <fcntl.h>
23#include <unistd.h>
24#include <stdlib.h>
25#include <string.h>
26#include <glib.h>
27#include "libsigrok.h"
28#include "libsigrok-internal.h"
29#include "protocol.h"
30
31static const int32_t hwopts[] = {
32 SR_CONF_CONN,
33};
34
35static const int32_t hwcaps[] = {
36 SR_CONF_OSCILLOSCOPE,
37 SR_CONF_TIMEBASE,
38 SR_CONF_TRIGGER_SOURCE,
39 SR_CONF_TRIGGER_SLOPE,
40 SR_CONF_HORIZ_TRIGGERPOS,
41 SR_CONF_NUM_TIMEBASE,
42};
43
44static const int32_t analog_hwcaps[] = {
45 SR_CONF_NUM_VDIV,
46 SR_CONF_VDIV,
47 SR_CONF_COUPLING,
48 SR_CONF_DATA_SOURCE,
49};
50
51static const uint64_t timebases[][2] = {
52 /* nanoseconds */
53 { 2, 1000000000 },
54 { 5, 1000000000 },
55 { 10, 1000000000 },
56 { 20, 1000000000 },
57 { 50, 1000000000 },
58 { 100, 1000000000 },
59 { 500, 1000000000 },
60 /* microseconds */
61 { 1, 1000000 },
62 { 2, 1000000 },
63 { 5, 1000000 },
64 { 10, 1000000 },
65 { 20, 1000000 },
66 { 50, 1000000 },
67 { 100, 1000000 },
68 { 200, 1000000 },
69 { 500, 1000000 },
70 /* milliseconds */
71 { 1, 1000 },
72 { 2, 1000 },
73 { 5, 1000 },
74 { 10, 1000 },
75 { 20, 1000 },
76 { 50, 1000 },
77 { 100, 1000 },
78 { 200, 1000 },
79 { 500, 1000 },
80 /* seconds */
81 { 1, 1 },
82 { 2, 1 },
83 { 5, 1 },
84 { 10, 1 },
85 { 20, 1 },
86 { 50, 1 },
87 { 100, 1 },
88 { 200, 1 },
89 { 500, 1 },
90 /* { 1000, 1 }, Confuses other code? */
91};
92
93static const uint64_t vdivs[][2] = {
94 /* microvolts */
95 { 500, 1000000 },
96 /* millivolts */
97 { 1, 1000 },
98 { 2, 1000 },
99 { 5, 1000 },
100 { 10, 1000 },
101 { 20, 1000 },
102 { 50, 1000 },
103 { 100, 1000 },
104 { 200, 1000 },
105 { 500, 1000 },
106 /* volts */
107 { 1, 1 },
108 { 2, 1 },
109 { 5, 1 },
110 { 10, 1 },
111};
112
113#define NUM_TIMEBASE ARRAY_SIZE(timebases)
114#define NUM_VDIV ARRAY_SIZE(vdivs)
115
116static const char *trigger_sources[] = {
117 "CH1",
118 "CH2",
119 "EXT",
120 "AC Line",
121 "D0",
122 "D1",
123 "D2",
124 "D3",
125 "D4",
126 "D5",
127 "D6",
128 "D7",
129 "D8",
130 "D9",
131 "D10",
132 "D11",
133 "D12",
134 "D13",
135 "D14",
136 "D15",
137};
138
139static const char *coupling[] = {
140 "AC",
141 "DC",
142 "GND",
143};
144
145/* Do not change the order of entries */
146static const char *data_sources[] = {
147 "Live",
148 "Memory",
149 "Segmented",
150};
151
152/*
153 * name, series, protocol flavor, min timebase, max timebase, min vdiv,
154 * digital channels, number of horizontal divs
155 */
156static const struct rigol_ds_model supported_models[] = {
157 {"DS1052E", RIGOL_DS1000, PROTOCOL_LEGACY, {5, 1000000000}, {50, 1}, {2, 1000}, false, 12},
158 {"DS1102E", RIGOL_DS1000, PROTOCOL_LEGACY, {2, 1000000000}, {50, 1}, {2, 1000}, false, 12},
159 {"DS1152E", RIGOL_DS1000, PROTOCOL_LEGACY, {2, 1000000000}, {50, 1}, {2, 1000}, false, 12},
160 {"DS1052D", RIGOL_DS1000, PROTOCOL_LEGACY, {5, 1000000000}, {50, 1}, {2, 1000}, true, 12},
161 {"DS1102D", RIGOL_DS1000, PROTOCOL_LEGACY, {2, 1000000000}, {50, 1}, {2, 1000}, true, 12},
162 {"DS1152D", RIGOL_DS1000, PROTOCOL_LEGACY, {2, 1000000000}, {50, 1}, {2, 1000}, true, 12},
163 {"DS2072", RIGOL_DS2000, PROTOCOL_IEEE488_2, {5, 1000000000}, {500, 1}, {500, 1000000}, false, 14},
164 {"DS2102", RIGOL_DS2000, PROTOCOL_IEEE488_2, {5, 1000000000}, {500, 1}, {500, 1000000}, false, 14},
165 {"DS2202", RIGOL_DS2000, PROTOCOL_IEEE488_2, {2, 1000000000}, {500, 1}, {500, 1000000}, false, 14},
166};
167
168SR_PRIV struct sr_dev_driver rigol_ds_driver_info;
169static struct sr_dev_driver *di = &rigol_ds_driver_info;
170
171static void clear_helper(void *priv)
172{
173 struct dev_context *devc;
174
175 devc = priv;
176 g_free(devc->data);
177 g_free(devc->buffer);
178 g_free(devc->coupling[0]);
179 g_free(devc->coupling[1]);
180 g_free(devc->trigger_source);
181 g_free(devc->trigger_slope);
182 g_slist_free(devc->analog_groups[0].probes);
183 g_slist_free(devc->analog_groups[1].probes);
184 g_slist_free(devc->digital_group.probes);
185}
186
187static int dev_clear(void)
188{
189 return std_dev_clear(di, clear_helper);
190}
191
192static int set_cfg(const struct sr_dev_inst *sdi, const char *format, ...)
193{
194 va_list args;
195 char buf[256];
196
197 va_start(args, format);
198 vsnprintf(buf, 255, format, args);
199 va_end(args);
200 if (rigol_ds_send(sdi, buf) != SR_OK)
201 return SR_ERR;
202
203 /* When setting a bunch of parameters in a row, the DS1052E scrambles
204 * some of them unless there is at least 100ms delay in between. */
205 sr_spew("delay %dms", 100);
206 g_usleep(100000);
207
208 return SR_OK;
209}
210
211static int init(struct sr_context *sr_ctx)
212{
213 return std_init(sr_ctx, di, LOG_PREFIX);
214}
215
216static int probe_port(const char *port, GSList **devices)
217{
218 struct dev_context *devc;
219 struct sr_dev_inst *sdi;
220 struct sr_usbtmc_dev_inst *usbtmc;
221 struct sr_probe *probe;
222 unsigned int i;
223 int len, num_tokens;
224 const char *manufacturer, *model_name, *version;
225 const struct rigol_ds_model *model = NULL;
226 char buf[256];
227 gchar **tokens, *channel_name;
228
229 *devices = NULL;
230 if (!(usbtmc = sr_usbtmc_dev_inst_new(port)))
231 return SR_ERR_MALLOC;
232
233 if ((usbtmc->fd = open(usbtmc->device, O_RDWR)) < 0)
234 return SR_ERR;
235 len = write(usbtmc->fd, "*IDN?", 5);
236 len = read(usbtmc->fd, buf, sizeof(buf));
237 if (close(usbtmc->fd) < 0)
238 return SR_ERR;
239
240 sr_usbtmc_dev_inst_free(usbtmc);
241
242 if (len == 0)
243 return SR_ERR_NA;
244
245 buf[len] = 0;
246 tokens = g_strsplit(buf, ",", 0);
247 sr_dbg("response: %s [%s]", port, buf);
248
249 for (num_tokens = 0; tokens[num_tokens] != NULL; num_tokens++);
250
251 if (num_tokens < 4) {
252 g_strfreev(tokens);
253 return SR_ERR_NA;
254 }
255
256 manufacturer = tokens[0];
257 model_name = tokens[1];
258 version = tokens[3];
259
260 if (strcasecmp(manufacturer, "Rigol Technologies")) {
261 g_strfreev(tokens);
262 return SR_ERR_NA;
263 }
264
265 for (i = 0; i < ARRAY_SIZE(supported_models); i++) {
266 if (!strcmp(model_name, supported_models[i].name)) {
267 model = &supported_models[i];
268 break;
269 }
270 }
271
272 if (!model || !(sdi = sr_dev_inst_new(0, SR_ST_ACTIVE,
273 manufacturer, model_name, version))) {
274 g_strfreev(tokens);
275 return SR_ERR_NA;
276 }
277
278 g_strfreev(tokens);
279
280 if (!(sdi->conn = sr_usbtmc_dev_inst_new(port)))
281 return SR_ERR_MALLOC;
282 sdi->driver = di;
283 sdi->inst_type = SR_INST_USBTMC;
284
285 if (!(devc = g_try_malloc0(sizeof(struct dev_context))))
286 return SR_ERR_MALLOC;
287 devc->limit_frames = 0;
288 devc->model = model;
289
290 for (i = 0; i < 2; i++) {
291 channel_name = (i == 0 ? "CH1" : "CH2");
292 if (!(probe = sr_probe_new(i, SR_PROBE_ANALOG, TRUE, channel_name)))
293 return SR_ERR_MALLOC;
294 sdi->probes = g_slist_append(sdi->probes, probe);
295 devc->analog_groups[i].name = channel_name;
296 devc->analog_groups[i].probes = g_slist_append(NULL, probe);
297 sdi->probe_groups = g_slist_append(sdi->probe_groups,
298 &devc->analog_groups[i]);
299 }
300
301 if (devc->model->has_digital) {
302 for (i = 0; i < 16; i++) {
303 if (!(channel_name = g_strdup_printf("D%d", i)))
304 return SR_ERR_MALLOC;
305 probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE, channel_name);
306 g_free(channel_name);
307 if (!probe)
308 return SR_ERR_MALLOC;
309 sdi->probes = g_slist_append(sdi->probes, probe);
310 devc->digital_group.probes = g_slist_append(
311 devc->digital_group.probes, probe);
312 devc->digital_group.name = "LA";
313 sdi->probe_groups = g_slist_append(sdi->probe_groups,
314 &devc->digital_group);
315 }
316 }
317
318 for (i = 0; i < NUM_TIMEBASE; i++) {
319 if (!memcmp(&devc->model->min_timebase, &timebases[i], sizeof(uint64_t[2])))
320 devc->timebases = &timebases[i];
321 if (!memcmp(&devc->model->max_timebase, &timebases[i], sizeof(uint64_t[2])))
322 devc->num_timebases = &timebases[i] - devc->timebases + 1;
323 }
324
325 for (i = 0; i < NUM_VDIV; i++) {
326 if (!memcmp(&devc->model->min_vdiv, &vdivs[i], sizeof(uint64_t[2]))) {
327 devc->vdivs = &vdivs[i];
328 devc->num_vdivs = NUM_VDIV - (&vdivs[i] - &vdivs[0]);
329 }
330 }
331
332 if (!(devc->buffer = g_try_malloc(ACQ_BUFFER_SIZE)))
333 return SR_ERR_MALLOC;
334 if (!(devc->data = g_try_malloc(ACQ_BUFFER_SIZE * sizeof(float))))
335 return SR_ERR_MALLOC;
336
337 devc->data_source = DATA_SOURCE_LIVE;
338
339 sdi->priv = devc;
340
341 *devices = g_slist_append(NULL, sdi);
342
343 return SR_OK;
344}
345
346static GSList *scan(GSList *options)
347{
348 struct drv_context *drvc;
349 struct sr_config *src;
350 GSList *l, *devices;
351 GDir *dir;
352 int ret;
353 const gchar *dev_name;
354 gchar *port = NULL;
355
356 drvc = di->priv;
357
358 for (l = options; l; l = l->next) {
359 src = l->data;
360 if (src->key == SR_CONF_CONN) {
361 port = (char *)g_variant_get_string(src->data, NULL);
362 break;
363 }
364 }
365
366 devices = NULL;
367 if (port) {
368 if (probe_port(port, &devices) == SR_ERR_MALLOC)
369 return NULL;
370 } else {
371 if (!(dir = g_dir_open("/sys/class/usbmisc/", 0, NULL)))
372 if (!(dir = g_dir_open("/sys/class/usb/", 0, NULL)))
373 return NULL;
374 while ((dev_name = g_dir_read_name(dir))) {
375 if (strncmp(dev_name, "usbtmc", 6))
376 continue;
377 port = g_strconcat("/dev/", dev_name, NULL);
378 ret = probe_port(port, &devices);
379 g_free(port);
380 if (ret == SR_ERR_MALLOC) {
381 g_dir_close(dir);
382 return NULL;
383 }
384 }
385 g_dir_close(dir);
386 }
387
388 /* Tack a copy of the newly found devices onto the driver list. */
389 l = g_slist_copy(devices);
390 drvc->instances = g_slist_concat(drvc->instances, l);
391
392 return devices;
393}
394
395static GSList *dev_list(void)
396{
397 return ((struct drv_context *)(di->priv))->instances;
398}
399
400static int dev_open(struct sr_dev_inst *sdi)
401{
402 struct sr_usbtmc_dev_inst *usbtmc = sdi->conn;
403
404 if ((usbtmc->fd = open(usbtmc->device, O_RDWR)) < 0)
405 return SR_ERR;
406
407 if (rigol_ds_get_dev_cfg(sdi) != SR_OK)
408 return SR_ERR;
409
410 sdi->status = SR_ST_ACTIVE;
411
412 return SR_OK;
413}
414
415static int dev_close(struct sr_dev_inst *sdi)
416{
417 struct sr_usbtmc_dev_inst *usbtmc;
418
419 usbtmc = sdi->conn;
420 if (usbtmc && usbtmc->fd != -1) {
421 close(usbtmc->fd);
422 usbtmc->fd = -1;
423 sdi->status = SR_ST_INACTIVE;
424 }
425
426 return SR_OK;
427}
428
429static int cleanup(void)
430{
431 return dev_clear();
432}
433
434static int config_get(int id, GVariant **data, const struct sr_dev_inst *sdi,
435 const struct sr_probe_group *probe_group)
436{
437 struct dev_context *devc;
438 unsigned int i;
439
440 if (!sdi || !(devc = sdi->priv))
441 return SR_ERR_ARG;
442
443 /* If a probe group is specified, it must be a valid one. */
444 if (probe_group) {
445 if (probe_group != &devc->analog_groups[0]
446 && probe_group != &devc->analog_groups[1]) {
447 sr_err("Invalid probe group specified.");
448 return SR_ERR;
449 }
450 }
451
452 switch (id) {
453 case SR_CONF_NUM_TIMEBASE:
454 *data = g_variant_new_int32(devc->num_timebases);
455 break;
456 case SR_CONF_NUM_VDIV:
457 if (!probe_group) {
458 sr_err("No probe group specified.");
459 return SR_ERR_PROBE_GROUP;
460 }
461 for (i = 0; i < 2; i++) {
462 if (probe_group == &devc->analog_groups[i]) {
463 *data = g_variant_new_int32(devc->num_vdivs);
464 return SR_OK;
465 }
466 }
467 return SR_ERR_NA;
468 case SR_CONF_DATA_SOURCE:
469 if (devc->data_source == DATA_SOURCE_LIVE)
470 *data = g_variant_new_string("Live");
471 else if (devc->data_source == DATA_SOURCE_MEMORY)
472 *data = g_variant_new_string("Memory");
473 else
474 *data = g_variant_new_string("Segmented");
475 break;
476 default:
477 return SR_ERR_NA;
478 }
479
480 return SR_OK;
481}
482
483static int config_set(int id, GVariant *data, const struct sr_dev_inst *sdi,
484 const struct sr_probe_group *probe_group)
485{
486 struct dev_context *devc;
487 uint64_t tmp_u64, p, q;
488 double t_dbl;
489 unsigned int i, j;
490 int ret;
491 const char *tmp_str;
492
493 if (!(devc = sdi->priv))
494 return SR_ERR_ARG;
495
496 if (sdi->status != SR_ST_ACTIVE)
497 return SR_ERR_DEV_CLOSED;
498
499 /* If a probe group is specified, it must be a valid one. */
500 if (probe_group) {
501 if (probe_group != &devc->analog_groups[0]
502 && probe_group != &devc->analog_groups[1]) {
503 sr_err("Invalid probe group specified.");
504 return SR_ERR;
505 }
506 }
507
508 ret = SR_OK;
509 switch (id) {
510 case SR_CONF_LIMIT_FRAMES:
511 devc->limit_frames = g_variant_get_uint64(data);
512 break;
513 case SR_CONF_TRIGGER_SLOPE:
514 tmp_u64 = g_variant_get_uint64(data);
515 if (tmp_u64 != 0 && tmp_u64 != 1)
516 return SR_ERR;
517 g_free(devc->trigger_slope);
518 devc->trigger_slope = g_strdup(tmp_u64 ? "POS" : "NEG");
519 ret = set_cfg(sdi, ":TRIG:EDGE:SLOP %s", devc->trigger_slope);
520 break;
521 case SR_CONF_HORIZ_TRIGGERPOS:
522 t_dbl = g_variant_get_double(data);
523 if (t_dbl < 0.0 || t_dbl > 1.0)
524 return SR_ERR;
525 devc->horiz_triggerpos = t_dbl;
526 /* We have the trigger offset as a percentage of the frame, but
527 * need to express this in seconds. */
528 t_dbl = -(devc->horiz_triggerpos - 0.5) * devc->timebase * devc->num_timebases;
529 ret = set_cfg(sdi, ":TIM:OFFS %.6f", t_dbl);
530 break;
531 case SR_CONF_TIMEBASE:
532 g_variant_get(data, "(tt)", &p, &q);
533 for (i = 0; i < devc->num_timebases; i++) {
534 if (devc->timebases[i][0] == p && devc->timebases[i][1] == q) {
535 devc->timebase = (float)p / q;
536 ret = set_cfg(sdi, ":TIM:SCAL %.9f", devc->timebase);
537 break;
538 }
539 }
540 if (i == devc->num_timebases)
541 ret = SR_ERR_ARG;
542 break;
543 case SR_CONF_TRIGGER_SOURCE:
544 tmp_str = g_variant_get_string(data, NULL);
545 for (i = 0; i < ARRAY_SIZE(trigger_sources); i++) {
546 if (!strcmp(trigger_sources[i], tmp_str)) {
547 g_free(devc->trigger_source);
548 devc->trigger_source = g_strdup(trigger_sources[i]);
549 if (!strcmp(devc->trigger_source, "AC Line"))
550 tmp_str = "ACL";
551 else if (!strcmp(devc->trigger_source, "CH1"))
552 tmp_str = "CHAN1";
553 else if (!strcmp(devc->trigger_source, "CH2"))
554 tmp_str = "CHAN2";
555 else
556 tmp_str = (char *)devc->trigger_source;
557 ret = set_cfg(sdi, ":TRIG:EDGE:SOUR %s", tmp_str);
558 break;
559 }
560 }
561 if (i == ARRAY_SIZE(trigger_sources))
562 ret = SR_ERR_ARG;
563 break;
564 case SR_CONF_VDIV:
565 if (!probe_group) {
566 sr_err("No probe group specified.");
567 return SR_ERR_PROBE_GROUP;
568 }
569 g_variant_get(data, "(tt)", &p, &q);
570 for (i = 0; i < 2; i++) {
571 if (probe_group == &devc->analog_groups[i]) {
572 for (j = 0; j < ARRAY_SIZE(vdivs); j++) {
573 if (vdivs[j][0] != p || vdivs[j][1] != q)
574 continue;
575 devc->vdiv[i] = (float)p / q;
576 return set_cfg(sdi, ":CHAN%d:SCAL %.3f", i + 1,
577 devc->vdiv[i]);
578 }
579 return SR_ERR_ARG;
580 }
581 }
582 return SR_ERR_NA;
583 case SR_CONF_COUPLING:
584 if (!probe_group) {
585 sr_err("No probe group specified.");
586 return SR_ERR_PROBE_GROUP;
587 }
588 tmp_str = g_variant_get_string(data, NULL);
589 for (i = 0; i < 2; i++) {
590 if (probe_group == &devc->analog_groups[i]) {
591 for (j = 0; j < ARRAY_SIZE(coupling); j++) {
592 if (!strcmp(tmp_str, coupling[j])) {
593 g_free(devc->coupling[i]);
594 devc->coupling[i] = g_strdup(coupling[j]);
595 return set_cfg(sdi, ":CHAN%d:COUP %s", i + 1,
596 devc->coupling[i]);
597 }
598 }
599 return SR_ERR_ARG;
600 }
601 }
602 return SR_ERR_NA;
603 case SR_CONF_DATA_SOURCE:
604 tmp_str = g_variant_get_string(data, NULL);
605 if (!strcmp(tmp_str, "Live"))
606 devc->data_source = DATA_SOURCE_LIVE;
607 else if (!strcmp(tmp_str, "Memory"))
608 devc->data_source = DATA_SOURCE_MEMORY;
609 else if (devc->model->protocol == PROTOCOL_IEEE488_2
610 && !strcmp(tmp_str, "Segmented"))
611 devc->data_source = DATA_SOURCE_SEGMENTED;
612 else
613 return SR_ERR;
614 break;
615 default:
616 ret = SR_ERR_NA;
617 break;
618 }
619
620 return ret;
621}
622
623static int config_list(int key, GVariant **data, const struct sr_dev_inst *sdi,
624 const struct sr_probe_group *probe_group)
625{
626 GVariant *tuple, *rational[2];
627 GVariantBuilder gvb;
628 unsigned int i;
629 struct dev_context *devc = NULL;
630
631 if (sdi)
632 devc = sdi->priv;
633
634 if (key == SR_CONF_SCAN_OPTIONS) {
635 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
636 hwopts, ARRAY_SIZE(hwopts), sizeof(int32_t));
637 return SR_OK;
638 } else if (key == SR_CONF_DEVICE_OPTIONS && probe_group == NULL) {
639 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
640 hwcaps, ARRAY_SIZE(hwcaps), sizeof(int32_t));
641 return SR_OK;
642 }
643
644 /* Every other option requires a valid device instance. */
645 if (!sdi || !(devc = sdi->priv))
646 return SR_ERR_ARG;
647
648 /* If a probe group is specified, it must be a valid one. */
649 if (probe_group) {
650 if (probe_group != &devc->analog_groups[0]
651 && probe_group != &devc->analog_groups[1]) {
652 sr_err("Invalid probe group specified.");
653 return SR_ERR;
654 }
655 }
656
657 switch (key) {
658 break;
659 case SR_CONF_DEVICE_OPTIONS:
660 if (!probe_group) {
661 sr_err("No probe group specified.");
662 return SR_ERR_PROBE_GROUP;
663 }
664 if (probe_group == &devc->digital_group) {
665 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
666 NULL, 0, sizeof(int32_t));
667 return SR_OK;
668 } else {
669 for (i = 0; i < 2; i++) {
670 if (probe_group == &devc->analog_groups[i]) {
671 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
672 analog_hwcaps, ARRAY_SIZE(analog_hwcaps), sizeof(int32_t));
673 return SR_OK;
674 }
675 }
676 return SR_ERR_NA;
677 }
678 break;
679 case SR_CONF_COUPLING:
680 if (!probe_group) {
681 sr_err("No probe group specified.");
682 return SR_ERR_PROBE_GROUP;
683 }
684 *data = g_variant_new_strv(coupling, ARRAY_SIZE(coupling));
685 break;
686 case SR_CONF_VDIV:
687 if (!devc)
688 /* Can't know this until we have the exact model. */
689 return SR_ERR_ARG;
690 if (!probe_group) {
691 sr_err("No probe group specified.");
692 return SR_ERR_PROBE_GROUP;
693 }
694 g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
695 for (i = 0; i < devc->num_vdivs; i++) {
696 rational[0] = g_variant_new_uint64(devc->vdivs[i][0]);
697 rational[1] = g_variant_new_uint64(devc->vdivs[i][1]);
698 tuple = g_variant_new_tuple(rational, 2);
699 g_variant_builder_add_value(&gvb, tuple);
700 }
701 *data = g_variant_builder_end(&gvb);
702 break;
703 case SR_CONF_TIMEBASE:
704 if (!devc)
705 /* Can't know this until we have the exact model. */
706 return SR_ERR_ARG;
707 g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
708 for (i = 0; i < devc->num_timebases; i++) {
709 rational[0] = g_variant_new_uint64(devc->timebases[i][0]);
710 rational[1] = g_variant_new_uint64(devc->timebases[i][1]);
711 tuple = g_variant_new_tuple(rational, 2);
712 g_variant_builder_add_value(&gvb, tuple);
713 }
714 *data = g_variant_builder_end(&gvb);
715 break;
716 case SR_CONF_TRIGGER_SOURCE:
717 if (!devc)
718 /* Can't know this until we have the exact model. */
719 return SR_ERR_ARG;
720 *data = g_variant_new_strv(trigger_sources,
721 devc->model->has_digital ? ARRAY_SIZE(trigger_sources) : 4);
722 break;
723 case SR_CONF_DATA_SOURCE:
724 if (!devc)
725 /* Can't know this until we have the exact model. */
726 return SR_ERR_ARG;
727 /* This needs tweaking by series/model! */
728 if (devc->model->series == RIGOL_DS2000)
729 *data = g_variant_new_strv(data_sources, ARRAY_SIZE(data_sources));
730 else
731 *data = g_variant_new_strv(data_sources, ARRAY_SIZE(data_sources) - 1);
732 break;
733 default:
734 return SR_ERR_NA;
735 }
736
737 return SR_OK;
738}
739
740static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
741{
742 struct sr_usbtmc_dev_inst *usbtmc;
743 struct dev_context *devc;
744 struct sr_probe *probe;
745 GSList *l;
746 char cmd[256];
747
748 if (sdi->status != SR_ST_ACTIVE)
749 return SR_ERR_DEV_CLOSED;
750
751 usbtmc = sdi->conn;
752 devc = sdi->priv;
753
754 if (devc->data_source == DATA_SOURCE_LIVE) {
755 if (rigol_ds_send(sdi, ":RUN") != SR_OK)
756 return SR_ERR;
757 } else if (devc->data_source == DATA_SOURCE_MEMORY) {
758 if (devc->model->series != RIGOL_DS2000) {
759 sr_err("Data source 'Memory' not supported for this device");
760 return SR_ERR;
761 }
762 } else if (devc->data_source == DATA_SOURCE_SEGMENTED) {
763 sr_err("Data source 'Segmented' not yet supported");
764 return SR_ERR;
765 }
766
767 for (l = sdi->probes; l; l = l->next) {
768 probe = l->data;
769 sr_dbg("handling probe %s", probe->name);
770 if (probe->type == SR_PROBE_ANALOG) {
771 if (probe->enabled)
772 devc->enabled_analog_probes = g_slist_append(
773 devc->enabled_analog_probes, probe);
774 if (probe->enabled != devc->analog_channels[probe->index]) {
775 /* Enabled channel is currently disabled, or vice versa. */
776 sprintf(cmd, ":CHAN%d:DISP %s", probe->index + 1,
777 probe->enabled ? "ON" : "OFF");
778 if (rigol_ds_send(sdi, cmd) != SR_OK)
779 return SR_ERR;
780 }
781 } else if (probe->type == SR_PROBE_LOGIC) {
782 if (probe->enabled)
783 devc->enabled_digital_probes = g_slist_append(
784 devc->enabled_digital_probes, probe);
785 if (probe->enabled != devc->digital_channels[probe->index]) {
786 /* Enabled channel is currently disabled, or vice versa. */
787 sprintf(cmd, ":DIG%d:TURN %s", probe->index,
788 probe->enabled ? "ON" : "OFF");
789 if (rigol_ds_send(sdi, cmd) != SR_OK)
790 return SR_ERR;
791 }
792 }
793 }
794 if (!devc->enabled_analog_probes && !devc->enabled_digital_probes)
795 return SR_ERR;
796
797 sr_source_add(usbtmc->fd, G_IO_IN, 50, rigol_ds_receive, (void *)sdi);
798
799 /* Send header packet to the session bus. */
800 std_session_send_df_header(cb_data, LOG_PREFIX);
801
802 if (devc->model->protocol == PROTOCOL_LEGACY) {
803 /* Fetch the first frame. */
804 if (devc->enabled_analog_probes) {
805 devc->analog_frame_size = DS1000_ANALOG_LIVE_WAVEFORM_SIZE;
806 devc->channel_frame = devc->enabled_analog_probes->data;
807 if (rigol_ds_send(sdi, ":WAV:DATA? CHAN%d",
808 devc->channel_frame->index + 1) != SR_OK)
809 return SR_ERR;
810 } else {
811 devc->channel_frame = devc->enabled_digital_probes->data;
812 if (rigol_ds_send(sdi, ":WAV:DATA? DIG") != SR_OK)
813 return SR_ERR;
814 }
815
816 devc->num_frame_bytes = 0;
817 } else {
818 if (devc->enabled_analog_probes) {
819 if (devc->data_source == DATA_SOURCE_MEMORY)
820 {
821 if (g_slist_length(devc->enabled_analog_probes) == 1)
822 devc->analog_frame_size = DS2000_ANALOG_MEM_WAVEFORM_SIZE_1C;
823 else
824 devc->analog_frame_size = DS2000_ANALOG_MEM_WAVEFORM_SIZE_2C;
825 /* Apparently for the DS2000 the memory
826 * depth can only be set in Running state -
827 * this matches the behaviour of the UI. */
828 if (rigol_ds_send(sdi, ":RUN") != SR_OK)
829 return SR_ERR;
830 if (rigol_ds_send(sdi, "ACQ:MDEP %d", devc->analog_frame_size) != SR_OK)
831 return SR_ERR;
832 if (rigol_ds_send(sdi, ":STOP") != SR_OK)
833 return SR_ERR;
834 } else
835 devc->analog_frame_size = DS2000_ANALOG_LIVE_WAVEFORM_SIZE;
836 devc->channel_frame = devc->enabled_analog_probes->data;
837 if (rigol_ds_capture_start(sdi) != SR_OK)
838 return SR_ERR;
839 }
840 }
841
842 return SR_OK;
843}
844
845static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
846{
847 struct dev_context *devc;
848 struct sr_usbtmc_dev_inst *usbtmc;
849
850 (void)cb_data;
851
852 devc = sdi->priv;
853
854 if (sdi->status != SR_ST_ACTIVE) {
855 sr_err("Device inactive, can't stop acquisition.");
856 return SR_ERR;
857 }
858
859 g_slist_free(devc->enabled_analog_probes);
860 g_slist_free(devc->enabled_digital_probes);
861 devc->enabled_analog_probes = NULL;
862 devc->enabled_digital_probes = NULL;
863 usbtmc = sdi->conn;
864 sr_source_remove(usbtmc->fd);
865
866 return SR_OK;
867}
868
869SR_PRIV struct sr_dev_driver rigol_ds_driver_info = {
870 .name = "rigol-ds",
871 .longname = "Rigol DS",
872 .api_version = 1,
873 .init = init,
874 .cleanup = cleanup,
875 .scan = scan,
876 .dev_list = dev_list,
877 .dev_clear = dev_clear,
878 .config_get = config_get,
879 .config_set = config_set,
880 .config_list = config_list,
881 .dev_open = dev_open,
882 .dev_close = dev_close,
883 .dev_acquisition_start = dev_acquisition_start,
884 .dev_acquisition_stop = dev_acquisition_stop,
885 .priv = NULL,
886};
Hardware access and backend lib