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