]> 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
Rename SR_CONF_NUM_TIMEBASE to SR_CONF_NUM_HDIV.
[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};
47
48static const uint32_t analog_devopts[] = {
49 SR_CONF_NUM_VDIV | SR_CONF_GET,
50 SR_CONF_VDIV | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
51 SR_CONF_COUPLING | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
52 SR_CONF_DATA_SOURCE | 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->digital_group);
254 g_free(devc);
255}
256
257static int dev_clear(void)
258{
259 return std_dev_clear(di, clear_helper);
260}
261
262static int init(struct sr_context *sr_ctx)
263{
264 return std_init(sr_ctx, di, LOG_PREFIX);
265}
266
267static struct sr_dev_inst *probe_device(struct sr_scpi_dev_inst *scpi)
268{
269 struct dev_context *devc;
270 struct sr_dev_inst *sdi;
271 struct sr_scpi_hw_info *hw_info;
272 struct sr_channel *ch;
273 long n[3];
274 unsigned int i;
275 const struct rigol_ds_model *model = NULL;
276 gchar *channel_name, **version;
277
278 if (sr_scpi_get_hw_id(scpi, &hw_info) != SR_OK) {
279 sr_info("Couldn't get IDN response, retrying.");
280 sr_scpi_close(scpi);
281 sr_scpi_open(scpi);
282 if (sr_scpi_get_hw_id(scpi, &hw_info) != SR_OK) {
283 sr_info("Couldn't get IDN response.");
284 return NULL;
285 }
286 }
287
288 for (i = 0; i < ARRAY_SIZE(supported_models); i++) {
289 if (!strcasecmp(hw_info->manufacturer,
290 supported_models[i].series->vendor->full_name) &&
291 !strcmp(hw_info->model, supported_models[i].name)) {
292 model = &supported_models[i];
293 break;
294 }
295 }
296
297 if (!model) {
298 sr_scpi_hw_info_free(hw_info);
299 return NULL;
300 }
301
302 sdi = g_malloc0(sizeof(struct sr_dev_inst));
303 sdi->status = SR_ST_ACTIVE;
304 sdi->vendor = g_strdup(model->series->vendor->name);
305 sdi->model = g_strdup(model->name);
306 sdi->version = g_strdup(hw_info->firmware_version);
307 sdi->conn = scpi;
308 sdi->driver = di;
309 sdi->inst_type = SR_INST_SCPI;
310 sdi->serial_num = g_strdup(hw_info->serial_number);
311 devc = g_malloc0(sizeof(struct dev_context));
312 devc->limit_frames = 0;
313 devc->model = model;
314 devc->format = model->series->format;
315
316 /* DS1000 models with firmware before 0.2.4 used the old data format. */
317 if (model->series == SERIES(DS1000)) {
318 version = g_strsplit(hw_info->firmware_version, ".", 0);
319 do {
320 if (!version[0] || !version[1] || !version[2])
321 break;
322 if (version[0][0] == 0 || version[1][0] == 0 || version[2][0] == 0)
323 break;
324 for (i = 0; i < 3; i++) {
325 if (sr_atol(version[i], &n[i]) != SR_OK)
326 break;
327 }
328 if (i != 3)
329 break;
330 if (n[0] != 0 || n[1] > 2)
331 break;
332 if (n[1] == 2 && n[2] > 3)
333 break;
334 sr_dbg("Found DS1000 firmware < 0.2.4, using raw data format.");
335 devc->format = FORMAT_RAW;
336 } while(0);
337 g_strfreev(version);
338 }
339
340 sr_scpi_hw_info_free(hw_info);
341
342 devc->analog_groups = g_malloc0(sizeof(struct sr_channel_group*) *
343 model->analog_channels);
344
345 for (i = 0; i < model->analog_channels; i++) {
346 if (!(channel_name = g_strdup_printf("CH%d", i + 1)))
347 return NULL;
348 ch = sr_channel_new(i, SR_CHANNEL_ANALOG, TRUE, channel_name);
349 sdi->channels = g_slist_append(sdi->channels, ch);
350
351 devc->analog_groups[i] = g_malloc0(sizeof(struct sr_channel_group));
352
353 devc->analog_groups[i]->name = channel_name;
354 devc->analog_groups[i]->channels = g_slist_append(NULL, ch);
355 sdi->channel_groups = g_slist_append(sdi->channel_groups,
356 devc->analog_groups[i]);
357 }
358
359 if (devc->model->has_digital) {
360 devc->digital_group = g_malloc0(sizeof(struct sr_channel_group*));
361
362 for (i = 0; i < ARRAY_SIZE(devc->digital_channels); i++) {
363 if (!(channel_name = g_strdup_printf("D%d", i)))
364 return NULL;
365 ch = sr_channel_new(i, SR_CHANNEL_LOGIC, TRUE, channel_name);
366 g_free(channel_name);
367 sdi->channels = g_slist_append(sdi->channels, ch);
368 devc->digital_group->channels = g_slist_append(
369 devc->digital_group->channels, ch);
370 }
371 devc->digital_group->name = g_strdup("LA");
372 sdi->channel_groups = g_slist_append(sdi->channel_groups,
373 devc->digital_group);
374 }
375
376 for (i = 0; i < NUM_TIMEBASE; i++) {
377 if (!memcmp(&devc->model->min_timebase, &timebases[i], sizeof(uint64_t[2])))
378 devc->timebases = &timebases[i];
379 if (!memcmp(&devc->model->series->max_timebase, &timebases[i], sizeof(uint64_t[2])))
380 devc->num_timebases = &timebases[i] - devc->timebases + 1;
381 }
382
383 for (i = 0; i < NUM_VDIV; i++)
384 if (!memcmp(&devc->model->series->min_vdiv, &vdivs[i], sizeof(uint64_t[2]))) {
385 devc->vdivs = &vdivs[i];
386 devc->num_vdivs = NUM_VDIV - i;
387 }
388
389 if (!(devc->buffer = g_try_malloc(ACQ_BUFFER_SIZE)))
390 return NULL;
391 if (!(devc->data = g_try_malloc(ACQ_BUFFER_SIZE * sizeof(float))))
392 return NULL;
393
394 devc->data_source = DATA_SOURCE_LIVE;
395
396 sdi->priv = devc;
397
398 return sdi;
399}
400
401static GSList *scan(GSList *options)
402{
403 return sr_scpi_scan(di->priv, options, probe_device);
404}
405
406static GSList *dev_list(void)
407{
408 return ((struct drv_context *)(di->priv))->instances;
409}
410
411static int dev_open(struct sr_dev_inst *sdi)
412{
413 int ret;
414 struct sr_scpi_dev_inst *scpi = sdi->conn;
415
416 if ((ret = sr_scpi_open(scpi)) < 0) {
417 sr_err("Failed to open SCPI device: %s.", sr_strerror(ret));
418 return SR_ERR;
419 }
420
421 if ((ret = rigol_ds_get_dev_cfg(sdi)) < 0) {
422 sr_err("Failed to get device config: %s.", sr_strerror(ret));
423 return SR_ERR;
424 }
425
426 sdi->status = SR_ST_ACTIVE;
427
428 return SR_OK;
429}
430
431static int dev_close(struct sr_dev_inst *sdi)
432{
433 struct sr_scpi_dev_inst *scpi;
434 struct dev_context *devc;
435
436 if (sdi->status != SR_ST_ACTIVE)
437 return SR_ERR_DEV_CLOSED;
438
439 scpi = sdi->conn;
440 devc = sdi->priv;
441
442 if (devc->model->series->protocol == PROTOCOL_V2)
443 rigol_ds_config_set(sdi, ":KEY:LOCK DISABLE");
444
445 if (scpi) {
446 if (sr_scpi_close(scpi) < 0)
447 return SR_ERR;
448 sdi->status = SR_ST_INACTIVE;
449 }
450
451 return SR_OK;
452}
453
454static int cleanup(void)
455{
456 return dev_clear();
457}
458
459static int analog_frame_size(const struct sr_dev_inst *sdi)
460{
461 struct dev_context *devc = sdi->priv;
462 struct sr_channel *ch;
463 int analog_channels = 0;
464 GSList *l;
465
466 for (l = sdi->channels; l; l = l->next) {
467 ch = l->data;
468 if (ch->type == SR_CHANNEL_ANALOG && ch->enabled)
469 analog_channels++;
470 }
471
472 if (analog_channels == 0)
473 return 0;
474
475 switch (devc->data_source) {
476 case DATA_SOURCE_LIVE:
477 return devc->model->series->live_samples;
478 case DATA_SOURCE_MEMORY:
479 return devc->model->series->buffer_samples / analog_channels;
480 default:
481 return 0;
482 }
483}
484
485static int digital_frame_size(const struct sr_dev_inst *sdi)
486{
487 struct dev_context *devc = sdi->priv;
488
489 switch (devc->data_source) {
490 case DATA_SOURCE_LIVE:
491 return devc->model->series->live_samples * 2;
492 case DATA_SOURCE_MEMORY:
493 return devc->model->series->buffer_samples * 2;
494 default:
495 return 0;
496 }
497}
498
499static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
500 const struct sr_channel_group *cg)
501{
502 struct dev_context *devc;
503 struct sr_channel *ch;
504 const char *tmp_str;
505 uint64_t samplerate;
506 int analog_channel = -1;
507 float smallest_diff = INFINITY;
508 int idx = -1;
509 unsigned i;
510
511 if (!sdi || !(devc = sdi->priv))
512 return SR_ERR_ARG;
513
514 /* If a channel group is specified, it must be a valid one. */
515 if (cg && !g_slist_find(sdi->channel_groups, cg)) {
516 sr_err("Invalid channel group specified.");
517 return SR_ERR;
518 }
519
520 if (cg) {
521 ch = g_slist_nth_data(cg->channels, 0);
522 if (!ch)
523 return SR_ERR;
524 if (ch->type == SR_CHANNEL_ANALOG) {
525 if (ch->name[2] < '1' || ch->name[2] > '4')
526 return SR_ERR;
527 analog_channel = ch->name[2] - '1';
528 }
529 }
530
531 switch (key) {
532 case SR_CONF_NUM_HDIV:
533 *data = g_variant_new_int32(devc->model->series->num_horizontal_divs);
534 break;
535 case SR_CONF_NUM_VDIV:
536 *data = g_variant_new_int32(devc->num_vdivs);
537 break;
538 case SR_CONF_DATA_SOURCE:
539 if (devc->data_source == DATA_SOURCE_LIVE)
540 *data = g_variant_new_string("Live");
541 else if (devc->data_source == DATA_SOURCE_MEMORY)
542 *data = g_variant_new_string("Memory");
543 else
544 *data = g_variant_new_string("Segmented");
545 break;
546 case SR_CONF_SAMPLERATE:
547 if (devc->data_source == DATA_SOURCE_LIVE) {
548 samplerate = analog_frame_size(sdi) /
549 (devc->timebase * devc->model->series->num_horizontal_divs);
550 *data = g_variant_new_uint64(samplerate);
551 } else {
552 sr_dbg("Unknown data source: %d.", devc->data_source);
553 return SR_ERR_NA;
554 }
555 break;
556 case SR_CONF_TRIGGER_SOURCE:
557 if (!strcmp(devc->trigger_source, "ACL"))
558 tmp_str = "AC Line";
559 else if (!strcmp(devc->trigger_source, "CHAN1"))
560 tmp_str = "CH1";
561 else if (!strcmp(devc->trigger_source, "CHAN2"))
562 tmp_str = "CH2";
563 else if (!strcmp(devc->trigger_source, "CHAN3"))
564 tmp_str = "CH3";
565 else if (!strcmp(devc->trigger_source, "CHAN4"))
566 tmp_str = "CH4";
567 else
568 tmp_str = devc->trigger_source;
569 *data = g_variant_new_string(tmp_str);
570 break;
571 case SR_CONF_TRIGGER_SLOPE:
572 if (!strncmp(devc->trigger_slope, "POS", 3)) {
573 tmp_str = "r";
574 } else if (!strncmp(devc->trigger_slope, "NEG", 3)) {
575 tmp_str = "f";
576 } else {
577 sr_dbg("Unknown trigger slope: '%s'.", devc->trigger_slope);
578 return SR_ERR_NA;
579 }
580 *data = g_variant_new_string(tmp_str);
581 break;
582 case SR_CONF_TIMEBASE:
583 for (i = 0; i < devc->num_timebases; i++) {
584 float tb = (float)devc->timebases[i][0] / devc->timebases[i][1];
585 float diff = fabs(devc->timebase - tb);
586 if (diff < smallest_diff) {
587 smallest_diff = diff;
588 idx = i;
589 }
590 }
591 if (idx < 0) {
592 sr_dbg("Negative timebase index: %d.", idx);
593 return SR_ERR_NA;
594 }
595 *data = g_variant_new("(tt)", devc->timebases[idx][0],
596 devc->timebases[idx][1]);
597 break;
598 case SR_CONF_VDIV:
599 if (analog_channel < 0) {
600 sr_dbg("Negative analog channel: %d.", analog_channel);
601 return SR_ERR_NA;
602 }
603 for (i = 0; i < ARRAY_SIZE(vdivs); i++) {
604 float vdiv = (float)vdivs[i][0] / vdivs[i][1];
605 float diff = fabs(devc->vdiv[analog_channel] - vdiv);
606 if (diff < smallest_diff) {
607 smallest_diff = diff;
608 idx = i;
609 }
610 }
611 if (idx < 0) {
612 sr_dbg("Negative vdiv index: %d.", idx);
613 return SR_ERR_NA;
614 }
615 *data = g_variant_new("(tt)", vdivs[idx][0], vdivs[idx][1]);
616 break;
617 case SR_CONF_COUPLING:
618 if (analog_channel < 0) {
619 sr_dbg("Negative analog channel: %d.", analog_channel);
620 return SR_ERR_NA;
621 }
622 *data = g_variant_new_string(devc->coupling[analog_channel]);
623 break;
624 default:
625 sr_dbg("Tried to get unknown config key: %d.", key);
626 return SR_ERR_NA;
627 }
628
629 return SR_OK;
630}
631
632static int config_set(uint32_t key, GVariant *data, const struct sr_dev_inst *sdi,
633 const struct sr_channel_group *cg)
634{
635 struct dev_context *devc;
636 uint64_t p, q;
637 double t_dbl;
638 unsigned int i, j;
639 int ret;
640 const char *tmp_str;
641 char buffer[16];
642
643 if (!(devc = sdi->priv))
644 return SR_ERR_ARG;
645
646 if (sdi->status != SR_ST_ACTIVE)
647 return SR_ERR_DEV_CLOSED;
648
649 /* If a channel group is specified, it must be a valid one. */
650 if (cg && !g_slist_find(sdi->channel_groups, cg)) {
651 sr_err("Invalid channel group specified.");
652 return SR_ERR;
653 }
654
655 ret = SR_OK;
656 switch (key) {
657 case SR_CONF_LIMIT_FRAMES:
658 devc->limit_frames = g_variant_get_uint64(data);
659 break;
660 case SR_CONF_TRIGGER_SLOPE:
661 tmp_str = g_variant_get_string(data, NULL);
662
663 if (!tmp_str || !(tmp_str[0] == 'f' || tmp_str[0] == 'r')) {
664 sr_err("Unknown trigger slope: '%s'.",
665 (tmp_str) ? tmp_str : "NULL");
666 return SR_ERR_ARG;
667 }
668
669 g_free(devc->trigger_slope);
670 devc->trigger_slope = g_strdup((tmp_str[0] == 'r') ? "POS" : "NEG");
671 ret = rigol_ds_config_set(sdi, ":TRIG:EDGE:SLOP %s", devc->trigger_slope);
672 break;
673 case SR_CONF_HORIZ_TRIGGERPOS:
674 t_dbl = g_variant_get_double(data);
675 if (t_dbl < 0.0 || t_dbl > 1.0) {
676 sr_err("Invalid horiz. trigger position: %g.", t_dbl);
677 return SR_ERR;
678 }
679 devc->horiz_triggerpos = t_dbl;
680 /* We have the trigger offset as a percentage of the frame, but
681 * need to express this in seconds. */
682 t_dbl = -(devc->horiz_triggerpos - 0.5) * devc->timebase * devc->num_timebases;
683 g_ascii_formatd(buffer, sizeof(buffer), "%.6f", t_dbl);
684 ret = rigol_ds_config_set(sdi, ":TIM:OFFS %s", buffer);
685 break;
686 case SR_CONF_TIMEBASE:
687 g_variant_get(data, "(tt)", &p, &q);
688 for (i = 0; i < devc->num_timebases; i++) {
689 if (devc->timebases[i][0] == p && devc->timebases[i][1] == q) {
690 devc->timebase = (float)p / q;
691 g_ascii_formatd(buffer, sizeof(buffer), "%.9f",
692 devc->timebase);
693 ret = rigol_ds_config_set(sdi, ":TIM:SCAL %s", buffer);
694 break;
695 }
696 }
697 if (i == devc->num_timebases) {
698 sr_err("Invalid timebase index: %d.", i);
699 ret = SR_ERR_ARG;
700 }
701 break;
702 case SR_CONF_TRIGGER_SOURCE:
703 tmp_str = g_variant_get_string(data, NULL);
704 for (i = 0; i < ARRAY_SIZE(trigger_sources); i++) {
705 if (!strcmp(trigger_sources[i], tmp_str)) {
706 g_free(devc->trigger_source);
707 devc->trigger_source = g_strdup(trigger_sources[i]);
708 if (!strcmp(devc->trigger_source, "AC Line"))
709 tmp_str = "ACL";
710 else if (!strcmp(devc->trigger_source, "CH1"))
711 tmp_str = "CHAN1";
712 else if (!strcmp(devc->trigger_source, "CH2"))
713 tmp_str = "CHAN2";
714 else if (!strcmp(devc->trigger_source, "CH3"))
715 tmp_str = "CHAN3";
716 else if (!strcmp(devc->trigger_source, "CH4"))
717 tmp_str = "CHAN4";
718 else
719 tmp_str = (char *)devc->trigger_source;
720 ret = rigol_ds_config_set(sdi, ":TRIG:EDGE:SOUR %s", tmp_str);
721 break;
722 }
723 }
724 if (i == ARRAY_SIZE(trigger_sources)) {
725 sr_err("Invalid trigger source index: %d.", i);
726 ret = SR_ERR_ARG;
727 }
728 break;
729 case SR_CONF_VDIV:
730 if (!cg) {
731 sr_err("No channel group specified.");
732 return SR_ERR_CHANNEL_GROUP;
733 }
734 g_variant_get(data, "(tt)", &p, &q);
735 for (i = 0; i < devc->model->analog_channels; i++) {
736 if (cg == devc->analog_groups[i]) {
737 for (j = 0; j < ARRAY_SIZE(vdivs); j++) {
738 if (vdivs[j][0] != p || vdivs[j][1] != q)
739 continue;
740 devc->vdiv[i] = (float)p / q;
741 g_ascii_formatd(buffer, sizeof(buffer), "%.3f",
742 devc->vdiv[i]);
743 return rigol_ds_config_set(sdi, ":CHAN%d:SCAL %s", i + 1,
744 buffer);
745 }
746 sr_err("Invalid vdiv index: %d.", j);
747 return SR_ERR_ARG;
748 }
749 }
750 sr_dbg("Didn't set vdiv, unknown channel(group).");
751 return SR_ERR_NA;
752 case SR_CONF_COUPLING:
753 if (!cg) {
754 sr_err("No channel group specified.");
755 return SR_ERR_CHANNEL_GROUP;
756 }
757 tmp_str = g_variant_get_string(data, NULL);
758 for (i = 0; i < devc->model->analog_channels; i++) {
759 if (cg == devc->analog_groups[i]) {
760 for (j = 0; j < ARRAY_SIZE(coupling); j++) {
761 if (!strcmp(tmp_str, coupling[j])) {
762 g_free(devc->coupling[i]);
763 devc->coupling[i] = g_strdup(coupling[j]);
764 return rigol_ds_config_set(sdi, ":CHAN%d:COUP %s", i + 1,
765 devc->coupling[i]);
766 }
767 }
768 sr_err("Invalid coupling index: %d.", j);
769 return SR_ERR_ARG;
770 }
771 }
772 sr_dbg("Didn't set coupling, unknown channel(group).");
773 return SR_ERR_NA;
774 case SR_CONF_DATA_SOURCE:
775 tmp_str = g_variant_get_string(data, NULL);
776 if (!strcmp(tmp_str, "Live"))
777 devc->data_source = DATA_SOURCE_LIVE;
778 else if (devc->model->series->protocol >= PROTOCOL_V2
779 && !strcmp(tmp_str, "Memory"))
780 devc->data_source = DATA_SOURCE_MEMORY;
781 else if (devc->model->series->protocol >= PROTOCOL_V3
782 && !strcmp(tmp_str, "Segmented"))
783 devc->data_source = DATA_SOURCE_SEGMENTED;
784 else {
785 sr_err("Unknown data source: '%s'.", tmp_str);
786 return SR_ERR;
787 }
788 break;
789 default:
790 sr_dbg("Tried to set unknown config key: %d.", key);
791 ret = SR_ERR_NA;
792 break;
793 }
794
795 return ret;
796}
797
798static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
799 const struct sr_channel_group *cg)
800{
801 GVariant *tuple, *rational[2];
802 GVariantBuilder gvb;
803 unsigned int i;
804 struct dev_context *devc = NULL;
805
806 if (sdi)
807 devc = sdi->priv;
808
809 if (key == SR_CONF_SCAN_OPTIONS) {
810 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
811 scanopts, ARRAY_SIZE(scanopts), sizeof(uint32_t));
812 return SR_OK;
813 } else if (key == SR_CONF_DEVICE_OPTIONS && cg == NULL) {
814 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
815 devopts, ARRAY_SIZE(devopts), sizeof(uint32_t));
816 return SR_OK;
817 }
818
819 /* Every other option requires a valid device instance. */
820 if (!sdi || !(devc = sdi->priv))
821 return SR_ERR_ARG;
822
823 /* If a channel group is specified, it must be a valid one. */
824 if (cg) {
825 for (i = 0; i < devc->model->analog_channels; i++)
826 if (cg == devc->analog_groups[i])
827 break;
828 if (i >= devc->model->analog_channels) {
829 sr_err("Invalid channel group specified.");
830 return SR_ERR;
831 }
832 }
833
834 switch (key) {
835 case SR_CONF_DEVICE_OPTIONS:
836 if (!cg) {
837 sr_err("No channel group specified.");
838 return SR_ERR_CHANNEL_GROUP;
839 }
840 if (cg == devc->digital_group) {
841 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
842 NULL, 0, sizeof(uint32_t));
843 return SR_OK;
844 } else {
845 for (i = 0; i < devc->model->analog_channels; i++) {
846 if (cg == devc->analog_groups[i]) {
847 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
848 analog_devopts, ARRAY_SIZE(analog_devopts), sizeof(uint32_t));
849 return SR_OK;
850 }
851 }
852 return SR_ERR_NA;
853 }
854 break;
855 case SR_CONF_COUPLING:
856 if (!cg) {
857 sr_err("No channel group specified.");
858 return SR_ERR_CHANNEL_GROUP;
859 }
860 *data = g_variant_new_strv(coupling, ARRAY_SIZE(coupling));
861 break;
862 case SR_CONF_VDIV:
863 if (!devc)
864 /* Can't know this until we have the exact model. */
865 return SR_ERR_ARG;
866 if (!cg) {
867 sr_err("No channel group specified.");
868 return SR_ERR_CHANNEL_GROUP;
869 }
870 g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
871 for (i = 0; i < devc->num_vdivs; i++) {
872 rational[0] = g_variant_new_uint64(devc->vdivs[i][0]);
873 rational[1] = g_variant_new_uint64(devc->vdivs[i][1]);
874 tuple = g_variant_new_tuple(rational, 2);
875 g_variant_builder_add_value(&gvb, tuple);
876 }
877 *data = g_variant_builder_end(&gvb);
878 break;
879 case SR_CONF_TIMEBASE:
880 if (!devc)
881 /* Can't know this until we have the exact model. */
882 return SR_ERR_ARG;
883 if (devc->num_timebases <= 0)
884 return SR_ERR_NA;
885 g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
886 for (i = 0; i < devc->num_timebases; i++) {
887 rational[0] = g_variant_new_uint64(devc->timebases[i][0]);
888 rational[1] = g_variant_new_uint64(devc->timebases[i][1]);
889 tuple = g_variant_new_tuple(rational, 2);
890 g_variant_builder_add_value(&gvb, tuple);
891 }
892 *data = g_variant_builder_end(&gvb);
893 break;
894 case SR_CONF_TRIGGER_SOURCE:
895 if (!devc)
896 /* Can't know this until we have the exact model. */
897 return SR_ERR_ARG;
898 *data = g_variant_new_strv(trigger_sources,
899 devc->model->has_digital ? ARRAY_SIZE(trigger_sources) : 4);
900 break;
901 case SR_CONF_TRIGGER_SLOPE:
902 *data = g_variant_new_strv(trigger_slopes, ARRAY_SIZE(trigger_slopes));
903 break;
904 case SR_CONF_DATA_SOURCE:
905 if (!devc)
906 /* Can't know this until we have the exact model. */
907 return SR_ERR_ARG;
908 switch (devc->model->series->protocol) {
909 case PROTOCOL_V1:
910 *data = g_variant_new_strv(data_sources, ARRAY_SIZE(data_sources) - 2);
911 break;
912 case PROTOCOL_V2:
913 *data = g_variant_new_strv(data_sources, ARRAY_SIZE(data_sources) - 1);
914 break;
915 default:
916 *data = g_variant_new_strv(data_sources, ARRAY_SIZE(data_sources));
917 break;
918 }
919 break;
920 default:
921 sr_dbg("Tried to list unknown config key: %d.", key);
922 return SR_ERR_NA;
923 }
924
925 return SR_OK;
926}
927
928static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
929{
930 struct sr_scpi_dev_inst *scpi;
931 struct dev_context *devc;
932 struct sr_channel *ch;
933 struct sr_datafeed_packet packet;
934 GSList *l;
935
936 if (sdi->status != SR_ST_ACTIVE)
937 return SR_ERR_DEV_CLOSED;
938
939 scpi = sdi->conn;
940 devc = sdi->priv;
941
942 devc->num_frames = 0;
943
944 for (l = sdi->channels; l; l = l->next) {
945 ch = l->data;
946 sr_dbg("handling channel %s", ch->name);
947 if (ch->type == SR_CHANNEL_ANALOG) {
948 if (ch->enabled)
949 devc->enabled_analog_channels = g_slist_append(
950 devc->enabled_analog_channels, ch);
951 if (ch->enabled != devc->analog_channels[ch->index]) {
952 /* Enabled channel is currently disabled, or vice versa. */
953 if (rigol_ds_config_set(sdi, ":CHAN%d:DISP %s", ch->index + 1,
954 ch->enabled ? "ON" : "OFF") != SR_OK)
955 return SR_ERR;
956 devc->analog_channels[ch->index] = ch->enabled;
957 }
958 } else if (ch->type == SR_CHANNEL_LOGIC) {
959 if (ch->enabled) {
960 devc->enabled_digital_channels = g_slist_append(
961 devc->enabled_digital_channels, ch);
962 /* Turn on LA module if currently off. */
963 if (!devc->la_enabled) {
964 if (rigol_ds_config_set(sdi, ":LA:DISP ON") != SR_OK)
965 return SR_ERR;
966 devc->la_enabled = TRUE;
967 }
968 }
969 if (ch->enabled != devc->digital_channels[ch->index]) {
970 /* Enabled channel is currently disabled, or vice versa. */
971 if (rigol_ds_config_set(sdi, ":DIG%d:TURN %s", ch->index,
972 ch->enabled ? "ON" : "OFF") != SR_OK)
973 return SR_ERR;
974 devc->digital_channels[ch->index] = ch->enabled;
975 }
976 }
977 }
978
979 if (!devc->enabled_analog_channels && !devc->enabled_digital_channels)
980 return SR_ERR;
981
982 /* Turn off LA module if on and no digital channels selected. */
983 if (devc->la_enabled && !devc->enabled_digital_channels)
984 if (rigol_ds_config_set(sdi, ":LA:DISP OFF") != SR_OK)
985 return SR_ERR;
986
987 /* Set memory mode. */
988 if (devc->data_source == DATA_SOURCE_SEGMENTED) {
989 sr_err("Data source 'Segmented' not yet supported");
990 return SR_ERR;
991 }
992
993 devc->analog_frame_size = analog_frame_size(sdi);
994 devc->digital_frame_size = digital_frame_size(sdi);
995
996 switch (devc->model->series->protocol) {
997 case PROTOCOL_V2:
998 if (rigol_ds_config_set(sdi, ":ACQ:MEMD LONG") != SR_OK)
999 return SR_ERR;
1000 break;
1001 case PROTOCOL_V3:
1002 /* Apparently for the DS2000 the memory
1003 * depth can only be set in Running state -
1004 * this matches the behaviour of the UI. */
1005 if (rigol_ds_config_set(sdi, ":RUN") != SR_OK)
1006 return SR_ERR;
1007 if (rigol_ds_config_set(sdi, ":ACQ:MDEP %d",
1008 devc->analog_frame_size) != SR_OK)
1009 return SR_ERR;
1010 if (rigol_ds_config_set(sdi, ":STOP") != SR_OK)
1011 return SR_ERR;
1012 break;
1013 default:
1014 break;
1015 }
1016
1017 if (devc->data_source == DATA_SOURCE_LIVE)
1018 if (rigol_ds_config_set(sdi, ":RUN") != SR_OK)
1019 return SR_ERR;
1020
1021 sr_scpi_source_add(sdi->session, scpi, G_IO_IN, 50,
1022 rigol_ds_receive, (void *)sdi);
1023
1024 /* Send header packet to the session bus. */
1025 std_session_send_df_header(cb_data, LOG_PREFIX);
1026
1027 if (devc->enabled_analog_channels)
1028 devc->channel_entry = devc->enabled_analog_channels;
1029 else
1030 devc->channel_entry = devc->enabled_digital_channels;
1031
1032 if (rigol_ds_capture_start(sdi) != SR_OK)
1033 return SR_ERR;
1034
1035 /* Start of first frame. */
1036 packet.type = SR_DF_FRAME_BEGIN;
1037 sr_session_send(cb_data, &packet);
1038
1039 return SR_OK;
1040}
1041
1042static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
1043{
1044 struct dev_context *devc;
1045 struct sr_scpi_dev_inst *scpi;
1046 struct sr_datafeed_packet packet;
1047
1048 (void)cb_data;
1049
1050 devc = sdi->priv;
1051
1052 if (sdi->status != SR_ST_ACTIVE) {
1053 sr_err("Device inactive, can't stop acquisition.");
1054 return SR_ERR;
1055 }
1056
1057 /* End of last frame. */
1058 packet.type = SR_DF_END;
1059 sr_session_send(sdi, &packet);
1060
1061 g_slist_free(devc->enabled_analog_channels);
1062 g_slist_free(devc->enabled_digital_channels);
1063 devc->enabled_analog_channels = NULL;
1064 devc->enabled_digital_channels = NULL;
1065 scpi = sdi->conn;
1066 sr_scpi_source_remove(sdi->session, scpi);
1067
1068 return SR_OK;
1069}
1070
1071SR_PRIV struct sr_dev_driver rigol_ds_driver_info = {
1072 .name = "rigol-ds",
1073 .longname = "Rigol DS",
1074 .api_version = 1,
1075 .init = init,
1076 .cleanup = cleanup,
1077 .scan = scan,
1078 .dev_list = dev_list,
1079 .dev_clear = dev_clear,
1080 .config_get = config_get,
1081 .config_set = config_set,
1082 .config_list = config_list,
1083 .dev_open = dev_open,
1084 .dev_close = dev_close,
1085 .dev_acquisition_start = dev_acquisition_start,
1086 .dev_acquisition_stop = dev_acquisition_stop,
1087 .priv = NULL,
1088};
Hardware access and backend lib