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