]> sigrok.org Git - libsigrok.git/blame_incremental - src/hardware/hameg-hmo/protocol.c
projects / libsigrok.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
hameg-hmo: Initial R&S RTC1000 MSO support attempt.
[libsigrok.git] / src / hardware / hameg-hmo / protocol.c
... / ...
CommitLineData
1/*
2 * This file is part of the libsigrok project.
3 *
4 * Copyright (C) 2013 poljar (Damir Jelić) <poljarinho@gmail.com>
5 * Copyright (C) 2018 Guido Trentalancia <guido@trentalancia.com>
6 *
7 * This program is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program. If not, see <http://www.gnu.org/licenses/>.
19 */
20
21#include <config.h>
22#include <math.h>
23#include <stdlib.h>
24#include "scpi.h"
25#include "protocol.h"
26
27SR_PRIV void hmo_queue_logic_data(struct dev_context *devc,
28 size_t group, GByteArray *pod_data);
29SR_PRIV void hmo_send_logic_packet(struct sr_dev_inst *sdi,
30 struct dev_context *devc);
31SR_PRIV void hmo_cleanup_logic_data(struct dev_context *devc);
32
33static const char *hameg_scpi_dialect[] = {
34 [SCPI_CMD_GET_DIG_DATA] = ":FORM UINT,8;:POD%d:DATA?",
35 [SCPI_CMD_GET_TIMEBASE] = ":TIM:SCAL?",
36 [SCPI_CMD_SET_TIMEBASE] = ":TIM:SCAL %s",
37 [SCPI_CMD_GET_COUPLING] = ":CHAN%d:COUP?",
38 [SCPI_CMD_SET_COUPLING] = ":CHAN%d:COUP %s",
39 [SCPI_CMD_GET_SAMPLE_RATE] = ":ACQ:SRAT?",
40 [SCPI_CMD_GET_SAMPLE_RATE_LIVE] = ":%s:DATA:POINTS?",
41 [SCPI_CMD_GET_ANALOG_DATA] = ":FORM:BORD %s;" \
42 ":FORM REAL,32;:CHAN%d:DATA?",
43 [SCPI_CMD_GET_VERTICAL_DIV] = ":CHAN%d:SCAL?",
44 [SCPI_CMD_SET_VERTICAL_DIV] = ":CHAN%d:SCAL %s",
45 [SCPI_CMD_GET_DIG_POD_STATE] = ":POD%d:STAT?",
46 [SCPI_CMD_SET_DIG_POD_STATE] = ":POD%d:STAT %d",
47 [SCPI_CMD_GET_TRIGGER_SLOPE] = ":TRIG:A:EDGE:SLOP?",
48 [SCPI_CMD_SET_TRIGGER_SLOPE] = ":TRIG:A:EDGE:SLOP %s",
49 [SCPI_CMD_GET_TRIGGER_SOURCE] = ":TRIG:A:SOUR?",
50 [SCPI_CMD_SET_TRIGGER_SOURCE] = ":TRIG:A:SOUR %s",
51 [SCPI_CMD_GET_DIG_CHAN_STATE] = ":LOG%d:STAT?",
52 [SCPI_CMD_SET_DIG_CHAN_STATE] = ":LOG%d:STAT %d",
53 [SCPI_CMD_GET_VERTICAL_OFFSET] = ":CHAN%d:POS?",
54 [SCPI_CMD_GET_HORIZ_TRIGGERPOS] = ":TIM:POS?",
55 [SCPI_CMD_SET_HORIZ_TRIGGERPOS] = ":TIM:POS %s",
56 [SCPI_CMD_GET_ANALOG_CHAN_STATE] = ":CHAN%d:STAT?",
57 [SCPI_CMD_SET_ANALOG_CHAN_STATE] = ":CHAN%d:STAT %d",
58 [SCPI_CMD_GET_PROBE_UNIT] = ":PROB%d:SET:ATT:UNIT?",
59 [SCPI_CMD_GET_DIG_POD_THRESHOLD] = ":POD%d:THR?",
60 [SCPI_CMD_SET_DIG_POD_THRESHOLD] = ":POD%d:THR %s",
61 [SCPI_CMD_GET_DIG_POD_USER_THRESHOLD] = ":POD%d:THR:UDL%d?",
62 [SCPI_CMD_SET_DIG_POD_USER_THRESHOLD] = ":POD%d:THR:UDL%d %s",
63};
64
65static const uint32_t devopts[] = {
66 SR_CONF_OSCILLOSCOPE,
67 SR_CONF_LIMIT_SAMPLES | SR_CONF_GET | SR_CONF_SET,
68 SR_CONF_LIMIT_FRAMES | SR_CONF_GET | SR_CONF_SET,
69 SR_CONF_SAMPLERATE | SR_CONF_GET,
70 SR_CONF_TIMEBASE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
71 SR_CONF_NUM_HDIV | SR_CONF_GET,
72 SR_CONF_HORIZ_TRIGGERPOS | SR_CONF_GET | SR_CONF_SET,
73 SR_CONF_TRIGGER_SOURCE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
74 SR_CONF_TRIGGER_SLOPE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
75};
76
77static const uint32_t devopts_cg_analog[] = {
78 SR_CONF_NUM_VDIV | SR_CONF_GET,
79 SR_CONF_VDIV | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
80 SR_CONF_COUPLING | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
81};
82
83static const uint32_t devopts_cg_digital[] = {
84 SR_CONF_LOGIC_THRESHOLD | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
85 SR_CONF_LOGIC_THRESHOLD_CUSTOM | SR_CONF_GET | SR_CONF_SET,
86};
87
88static const char *coupling_options[] = {
89 "AC", // AC with 50 Ohm termination (152x, 202x, 30xx, 1202)
90 "ACL", // AC with 1 MOhm termination
91 "DC", // DC with 50 Ohm termination
92 "DCL", // DC with 1 MOhm termination
93 "GND",
94};
95
96static const char *scope_trigger_slopes[] = {
97 "POS",
98 "NEG",
99 "EITH",
100};
101
102/* Predefined logic thresholds. */
103static const char *logic_threshold[] = {
104 "TTL",
105 "ECL",
106 "CMOS",
107 "USER1",
108 "USER2", // overwritten by logic_threshold_custom, use USER1 for permanent setting
109};
110
111/* RTC1002 and HMO compact2 */
112static const char *an2_dig8_trigger_sources[] = {
113 "CH1", "CH2",
114 "LINE", "EXT", "PATT", "BUS1", "BUS2",
115 "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
116};
117
118/* HMO xxx2 */
119static const char *an2_dig16_trigger_sources[] = {
120 "CH1", "CH2",
121 "LINE", "EXT", "PATT", "BUS1", "BUS2",
122 "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
123 "D8", "D9", "D10", "D11", "D12", "D13", "D14", "D15",
124};
125
126/* HMO compact4 */
127static const char *an4_dig8_trigger_sources[] = {
128 "CH1", "CH2", "CH3", "CH4",
129 "LINE", "EXT", "PATT", "BUS1", "BUS2",
130 "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
131};
132
133/* HMO xxx4 */
134static const char *an4_dig16_trigger_sources[] = {
135 "CH1", "CH2", "CH3", "CH4",
136 "LINE", "EXT", "PATT", "BUS1", "BUS2",
137 "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
138 "D8", "D9", "D10", "D11", "D12", "D13", "D14", "D15",
139};
140
141static const uint64_t timebases[][2] = {
142 /* nanoseconds */
143 { 2, 1000000000 },
144 { 5, 1000000000 },
145 { 10, 1000000000 },
146 { 20, 1000000000 },
147 { 50, 1000000000 },
148 { 100, 1000000000 },
149 { 200, 1000000000 },
150 { 500, 1000000000 },
151 /* microseconds */
152 { 1, 1000000 },
153 { 2, 1000000 },
154 { 5, 1000000 },
155 { 10, 1000000 },
156 { 20, 1000000 },
157 { 50, 1000000 },
158 { 100, 1000000 },
159 { 200, 1000000 },
160 { 500, 1000000 },
161 /* milliseconds */
162 { 1, 1000 },
163 { 2, 1000 },
164 { 5, 1000 },
165 { 10, 1000 },
166 { 20, 1000 },
167 { 50, 1000 },
168 { 100, 1000 },
169 { 200, 1000 },
170 { 500, 1000 },
171 /* seconds */
172 { 1, 1 },
173 { 2, 1 },
174 { 5, 1 },
175 { 10, 1 },
176 { 20, 1 },
177 { 50, 1 },
178};
179
180static const uint64_t vdivs[][2] = {
181 /* millivolts */
182 { 1, 1000 },
183 { 2, 1000 },
184 { 5, 1000 },
185 { 10, 1000 },
186 { 20, 1000 },
187 { 50, 1000 },
188 { 100, 1000 },
189 { 200, 1000 },
190 { 500, 1000 },
191 /* volts */
192 { 1, 1 },
193 { 2, 1 },
194 { 5, 1 },
195 { 10, 1 },
196 { 20, 1 },
197 { 50, 1 },
198};
199
200static const char *scope_analog_channel_names[] = {
201 "CH1", "CH2", "CH3", "CH4",
202};
203
204static const char *scope_digital_channel_names[] = {
205 "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
206 "D8", "D9", "D10", "D11", "D12", "D13", "D14", "D15",
207};
208
209static const struct scope_config scope_models[] = {
210 {
211 /* RTC1002 and HMO722/1002/1022/1522/2022 support only 8 digital channels. */
212 .name = {"RTC1002", "HMO722", "HMO1002", "HMO1022", "HMO1522", "HMO2022", NULL},
213 .analog_channels = 2,
214 .digital_channels = 8,
215 .digital_pods = 1,
216
217 .analog_names = &scope_analog_channel_names,
218 .digital_names = &scope_digital_channel_names,
219
220 .devopts = &devopts,
221 .num_devopts = ARRAY_SIZE(devopts),
222
223 .devopts_cg_analog = &devopts_cg_analog,
224 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
225
226 .devopts_cg_digital = &devopts_cg_digital,
227 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
228
229 .coupling_options = &coupling_options,
230 .num_coupling_options = ARRAY_SIZE(coupling_options),
231
232 .logic_threshold = &logic_threshold,
233 .num_logic_threshold = ARRAY_SIZE(logic_threshold),
234
235 .trigger_sources = &an2_dig8_trigger_sources,
236 .num_trigger_sources = ARRAY_SIZE(an2_dig8_trigger_sources),
237
238 .trigger_slopes = &scope_trigger_slopes,
239 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
240
241 .timebases = &timebases,
242 .num_timebases = ARRAY_SIZE(timebases),
243
244 .vdivs = &vdivs,
245 .num_vdivs = ARRAY_SIZE(vdivs),
246
247 .num_xdivs = 12,
248 .num_ydivs = 8,
249
250 .scpi_dialect = &hameg_scpi_dialect,
251 },
252 {
253 /* HMO3032/3042/3052/3522 support 16 digital channels. */
254 .name = {"HMO3032", "HMO3042", "HMO3052", "HMO3522", NULL},
255 .analog_channels = 2,
256 .digital_channels = 16,
257 .digital_pods = 2,
258
259 .analog_names = &scope_analog_channel_names,
260 .digital_names = &scope_digital_channel_names,
261
262 .devopts = &devopts,
263 .num_devopts = ARRAY_SIZE(devopts),
264
265 .devopts_cg_analog = &devopts_cg_analog,
266 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
267
268 .devopts_cg_digital = &devopts_cg_digital,
269 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
270
271 .coupling_options = &coupling_options,
272 .num_coupling_options = ARRAY_SIZE(coupling_options),
273
274 .logic_threshold = &logic_threshold,
275 .num_logic_threshold = ARRAY_SIZE(logic_threshold),
276
277 .trigger_sources = &an2_dig16_trigger_sources,
278 .num_trigger_sources = ARRAY_SIZE(an2_dig16_trigger_sources),
279
280 .trigger_slopes = &scope_trigger_slopes,
281 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
282
283 .timebases = &timebases,
284 .num_timebases = ARRAY_SIZE(timebases),
285
286 .vdivs = &vdivs,
287 .num_vdivs = ARRAY_SIZE(vdivs),
288
289 .num_xdivs = 12,
290 .num_ydivs = 8,
291
292 .scpi_dialect = &hameg_scpi_dialect,
293 },
294 {
295 .name = {"HMO724", "HMO1024", "HMO1524", "HMO2024", NULL},
296 .analog_channels = 4,
297 .digital_channels = 8,
298 .digital_pods = 1,
299
300 .analog_names = &scope_analog_channel_names,
301 .digital_names = &scope_digital_channel_names,
302
303 .devopts = &devopts,
304 .num_devopts = ARRAY_SIZE(devopts),
305
306 .devopts_cg_analog = &devopts_cg_analog,
307 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
308
309 .devopts_cg_digital = &devopts_cg_digital,
310 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
311
312 .coupling_options = &coupling_options,
313 .num_coupling_options = ARRAY_SIZE(coupling_options),
314
315 .logic_threshold = &logic_threshold,
316 .num_logic_threshold = ARRAY_SIZE(logic_threshold),
317
318 .trigger_sources = &an4_dig8_trigger_sources,
319 .num_trigger_sources = ARRAY_SIZE(an4_dig8_trigger_sources),
320
321 .trigger_slopes = &scope_trigger_slopes,
322 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
323
324 .timebases = &timebases,
325 .num_timebases = ARRAY_SIZE(timebases),
326
327 .vdivs = &vdivs,
328 .num_vdivs = ARRAY_SIZE(vdivs),
329
330 .num_xdivs = 12,
331 .num_ydivs = 8,
332
333 .scpi_dialect = &hameg_scpi_dialect,
334 },
335 {
336 .name = {"HMO2524", "HMO3034", "HMO3044", "HMO3054", "HMO3524", NULL},
337 .analog_channels = 4,
338 .digital_channels = 16,
339 .digital_pods = 2,
340
341 .analog_names = &scope_analog_channel_names,
342 .digital_names = &scope_digital_channel_names,
343
344 .devopts = &devopts,
345 .num_devopts = ARRAY_SIZE(devopts),
346
347 .devopts_cg_analog = &devopts_cg_analog,
348 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
349
350 .devopts_cg_digital = &devopts_cg_digital,
351 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
352
353 .coupling_options = &coupling_options,
354 .num_coupling_options = ARRAY_SIZE(coupling_options),
355
356 .logic_threshold = &logic_threshold,
357 .num_logic_threshold = ARRAY_SIZE(logic_threshold),
358
359 .trigger_sources = &an4_dig16_trigger_sources,
360 .num_trigger_sources = ARRAY_SIZE(an4_dig16_trigger_sources),
361
362 .trigger_slopes = &scope_trigger_slopes,
363 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
364
365 .timebases = &timebases,
366 .num_timebases = ARRAY_SIZE(timebases),
367
368 .vdivs = &vdivs,
369 .num_vdivs = ARRAY_SIZE(vdivs),
370
371 .num_xdivs = 12,
372 .num_ydivs = 8,
373
374 .scpi_dialect = &hameg_scpi_dialect,
375 },
376};
377
378static void scope_state_dump(const struct scope_config *config,
379 struct scope_state *state)
380{
381 unsigned int i;
382 char *tmp;
383
384 for (i = 0; i < config->analog_channels; i++) {
385 tmp = sr_voltage_string((*config->vdivs)[state->analog_channels[i].vdiv][0],
386 (*config->vdivs)[state->analog_channels[i].vdiv][1]);
387 sr_info("State of analog channel %d -> %s : %s (coupling) %s (vdiv) %2.2e (offset)",
388 i + 1, state->analog_channels[i].state ? "On" : "Off",
389 (*config->coupling_options)[state->analog_channels[i].coupling],
390 tmp, state->analog_channels[i].vertical_offset);
391 }
392
393 for (i = 0; i < config->digital_channels; i++) {
394 sr_info("State of digital channel %d -> %s", i,
395 state->digital_channels[i] ? "On" : "Off");
396 }
397
398 for (i = 0; i < config->digital_pods; i++) {
399 if (strncmp("USER", (*config->logic_threshold)[state->digital_pods[i].threshold], 4))
400 sr_info("State of digital POD %d -> %s : %s (threshold)", i,
401 state->digital_pods[i].state ? "On" : "Off",
402 (*config->logic_threshold)[state->digital_pods[i].threshold]);
403 else // user-defined or custom logic threshold
404 sr_info("State of digital POD %d -> %s : %E (threshold)", i,
405 state->digital_pods[i].state ? "On" : "Off",
406 state->digital_pods[i].user_threshold);
407 }
408
409 tmp = sr_period_string((*config->timebases)[state->timebase][0],
410 (*config->timebases)[state->timebase][1]);
411 sr_info("Current timebase: %s", tmp);
412 g_free(tmp);
413
414 tmp = sr_samplerate_string(state->sample_rate);
415 sr_info("Current samplerate: %s", tmp);
416 g_free(tmp);
417
418 sr_info("Current trigger: %s (source), %s (slope) %.2f (offset)",
419 (*config->trigger_sources)[state->trigger_source],
420 (*config->trigger_slopes)[state->trigger_slope],
421 state->horiz_triggerpos);
422}
423
424static int scope_state_get_array_option(struct sr_scpi_dev_inst *scpi,
425 const char *command, const char *(*array)[], unsigned int n, int *result)
426{
427 char *tmp;
428 int idx;
429
430 if (sr_scpi_get_string(scpi, command, &tmp) != SR_OK) {
431 g_free(tmp);
432 return SR_ERR;
433 }
434
435 if ((idx = std_str_idx_s(tmp, *array, n)) < 0) {
436 g_free(tmp);
437 return SR_ERR_ARG;
438 }
439
440 *result = idx;
441
442 g_free(tmp);
443
444 return SR_OK;
445}
446
447/**
448 * This function takes a value of the form "2.000E-03" and returns the index
449 * of an array where a matching pair was found.
450 *
451 * @param value The string to be parsed.
452 * @param array The array of s/f pairs.
453 * @param array_len The number of pairs in the array.
454 * @param result The index at which a matching pair was found.
455 *
456 * @return SR_ERR on any parsing error, SR_OK otherwise.
457 */
458static int array_float_get(gchar *value, const uint64_t array[][2],
459 int array_len, unsigned int *result)
460{
461 struct sr_rational rval;
462 struct sr_rational aval;
463
464 if (sr_parse_rational(value, &rval) != SR_OK)
465 return SR_ERR;
466
467 for (int i = 0; i < array_len; i++) {
468 sr_rational_set(&aval, array[i][0], array[i][1]);
469 if (sr_rational_eq(&rval, &aval)) {
470 *result = i;
471 return SR_OK;
472 }
473 }
474
475 return SR_ERR;
476}
477
478static struct sr_channel *get_channel_by_index_and_type(GSList *channel_lhead,
479 int index, int type)
480{
481 while (channel_lhead) {
482 struct sr_channel *ch = channel_lhead->data;
483 if (ch->index == index && ch->type == type)
484 return ch;
485
486 channel_lhead = channel_lhead->next;
487 }
488
489 return 0;
490}
491
492static int analog_channel_state_get(struct sr_dev_inst *sdi,
493 const struct scope_config *config,
494 struct scope_state *state)
495{
496 unsigned int i, j;
497 char command[MAX_COMMAND_SIZE];
498 char *tmp_str;
499 struct sr_channel *ch;
500 struct sr_scpi_dev_inst *scpi = sdi->conn;
501
502 for (i = 0; i < config->analog_channels; i++) {
503 g_snprintf(command, sizeof(command),
504 (*config->scpi_dialect)[SCPI_CMD_GET_ANALOG_CHAN_STATE],
505 i + 1);
506
507 if (sr_scpi_get_bool(scpi, command,
508 &state->analog_channels[i].state) != SR_OK)
509 return SR_ERR;
510
511 ch = get_channel_by_index_and_type(sdi->channels, i, SR_CHANNEL_ANALOG);
512 if (ch)
513 ch->enabled = state->analog_channels[i].state;
514
515 g_snprintf(command, sizeof(command),
516 (*config->scpi_dialect)[SCPI_CMD_GET_VERTICAL_DIV],
517 i + 1);
518
519 if (sr_scpi_get_string(scpi, command, &tmp_str) != SR_OK)
520 return SR_ERR;
521
522 if (array_float_get(tmp_str, ARRAY_AND_SIZE(vdivs), &j) != SR_OK) {
523 g_free(tmp_str);
524 sr_err("Could not determine array index for vertical div scale.");
525 return SR_ERR;
526 }
527
528 g_free(tmp_str);
529 state->analog_channels[i].vdiv = j;
530
531 g_snprintf(command, sizeof(command),
532 (*config->scpi_dialect)[SCPI_CMD_GET_VERTICAL_OFFSET],
533 i + 1);
534
535 if (sr_scpi_get_float(scpi, command,
536 &state->analog_channels[i].vertical_offset) != SR_OK)
537 return SR_ERR;
538
539 g_snprintf(command, sizeof(command),
540 (*config->scpi_dialect)[SCPI_CMD_GET_COUPLING],
541 i + 1);
542
543 if (scope_state_get_array_option(scpi, command, config->coupling_options,
544 config->num_coupling_options,
545 &state->analog_channels[i].coupling) != SR_OK)
546 return SR_ERR;
547
548 g_snprintf(command, sizeof(command),
549 (*config->scpi_dialect)[SCPI_CMD_GET_PROBE_UNIT],
550 i + 1);
551
552 if (sr_scpi_get_string(scpi, command, &tmp_str) != SR_OK)
553 return SR_ERR;
554
555 if (tmp_str[0] == 'A')
556 state->analog_channels[i].probe_unit = 'A';
557 else
558 state->analog_channels[i].probe_unit = 'V';
559 g_free(tmp_str);
560 }
561
562 return SR_OK;
563}
564
565static int digital_channel_state_get(struct sr_dev_inst *sdi,
566 const struct scope_config *config,
567 struct scope_state *state)
568{
569 unsigned int i;
570 int result = SR_ERR;
571 static char *logic_threshold_short[] = {};
572 char command[MAX_COMMAND_SIZE];
573 struct sr_channel *ch;
574 struct sr_scpi_dev_inst *scpi = sdi->conn;
575
576 for (i = 0; i < config->digital_channels; i++) {
577 g_snprintf(command, sizeof(command),
578 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_CHAN_STATE],
579 i);
580
581 if (sr_scpi_get_bool(scpi, command,
582 &state->digital_channels[i]) != SR_OK)
583 return SR_ERR;
584
585 ch = get_channel_by_index_and_type(sdi->channels, i, SR_CHANNEL_LOGIC);
586 if (ch)
587 ch->enabled = state->digital_channels[i];
588 }
589
590 /* According to the SCPI standard, the response to the command
591 * SCPI_CMD_GET_DIG_POD_THRESHOLD might return "USER" instead of
592 * "USER1".
593 *
594 * This makes more difficult to validate the response when the logic
595 * threshold is set to "USER1" and therefore we need to prevent device
596 * opening failures in such configuration case...
597 */
598 for (i = 0; i < config->num_logic_threshold; i++) {
599 logic_threshold_short[i] = g_strdup((*config->logic_threshold)[i]);
600 if (!strcmp("USER1", (*config->logic_threshold)[i]))
601 g_strlcpy(logic_threshold_short[i],
602 (*config->logic_threshold)[i], strlen((*config->logic_threshold)[i]));
603 }
604
605 for (i = 0; i < config->digital_pods; i++) {
606 g_snprintf(command, sizeof(command),
607 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_STATE],
608 i + 1);
609
610 if (sr_scpi_get_bool(scpi, command,
611 &state->digital_pods[i].state) != SR_OK)
612 goto exit;
613
614 g_snprintf(command, sizeof(command),
615 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_THRESHOLD],
616 i + 1);
617
618 /* Check for both standard and shortened responses. */
619 if (scope_state_get_array_option(scpi, command, config->logic_threshold,
620 config->num_logic_threshold,
621 &state->digital_pods[i].threshold) != SR_OK)
622 if (scope_state_get_array_option(scpi, command, (const char * (*)[]) &logic_threshold_short,
623 config->num_logic_threshold,
624 &state->digital_pods[i].threshold) != SR_OK)
625 goto exit;
626
627 if (!strcmp("USER1", (*config->logic_threshold)[state->digital_pods[i].threshold]))
628 g_snprintf(command, sizeof(command),
629 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_USER_THRESHOLD],
630 i + 1, 1); // USER1 logic threshold setting
631
632 if (!strcmp("USER2", (*config->logic_threshold)[state->digital_pods[i].threshold]))
633 g_snprintf(command, sizeof(command),
634 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_USER_THRESHOLD],
635 i + 1, 2); // USER2 for custom logic_threshold setting
636
637 if (!strcmp("USER1", (*config->logic_threshold)[state->digital_pods[i].threshold]) ||
638 !strcmp("USER2", (*config->logic_threshold)[state->digital_pods[i].threshold]))
639 if (sr_scpi_get_float(scpi, command,
640 &state->digital_pods[i].user_threshold) != SR_OK)
641 goto exit;
642 }
643
644 result = SR_OK;
645
646exit:
647 for (i = 0; i < config->num_logic_threshold; i++)
648 g_free(logic_threshold_short[i]);
649
650 return result;
651}
652
653SR_PRIV int hmo_update_sample_rate(const struct sr_dev_inst *sdi)
654{
655 struct dev_context *devc;
656 struct scope_state *state;
657 const struct scope_config *config;
658 int tmp;
659 unsigned int i;
660 float tmp_float;
661 gboolean channel_found;
662 char tmp_str[MAX_COMMAND_SIZE];
663 char chan_name[20];
664
665 devc = sdi->priv;
666 config = devc->model_config;
667 state = devc->model_state;
668 channel_found = FALSE;
669
670 for (i = 0; i < config->analog_channels; i++) {
671 if (!state->analog_channels[i].state)
672 continue;
673 g_snprintf(chan_name, sizeof(chan_name), "CHAN%d", i + 1);
674 g_snprintf(tmp_str, sizeof(tmp_str),
675 (*config->scpi_dialect)[SCPI_CMD_GET_SAMPLE_RATE_LIVE],
676 chan_name);
677 channel_found = TRUE;
678 break;
679 }
680
681 if (!channel_found) {
682 for (i = 0; i < config->digital_pods; i++) {
683 if (!state->digital_pods[i].state)
684 continue;
685 g_snprintf(chan_name, sizeof(chan_name), "POD%d", i);
686 g_snprintf(tmp_str, sizeof(tmp_str),
687 (*config->scpi_dialect)[SCPI_CMD_GET_SAMPLE_RATE_LIVE],
688 chan_name);
689 channel_found = TRUE;
690 break;
691 }
692 }
693
694 /* No channel is active, ask the instrument for the sample rate
695 * in single shot mode */
696 if (!channel_found) {
697 if (sr_scpi_get_float(sdi->conn,
698 (*config->scpi_dialect)[SCPI_CMD_GET_SAMPLE_RATE],
699 &tmp_float) != SR_OK)
700 return SR_ERR;
701
702 state->sample_rate = tmp_float;
703 } else {
704 if (sr_scpi_get_int(sdi->conn, tmp_str, &tmp) != SR_OK)
705 return SR_ERR;
706 state->sample_rate = tmp / (((float) (*config->timebases)[state->timebase][0] /
707 (*config->timebases)[state->timebase][1]) *
708 config->num_xdivs);
709 }
710
711 return SR_OK;
712}
713
714SR_PRIV int hmo_scope_state_get(struct sr_dev_inst *sdi)
715{
716 struct dev_context *devc;
717 struct scope_state *state;
718 const struct scope_config *config;
719 float tmp_float;
720 unsigned int i;
721 char *tmp_str;
722
723 devc = sdi->priv;
724 config = devc->model_config;
725 state = devc->model_state;
726
727 sr_info("Fetching scope state");
728
729 if (analog_channel_state_get(sdi, config, state) != SR_OK)
730 return SR_ERR;
731
732 if (digital_channel_state_get(sdi, config, state) != SR_OK)
733 return SR_ERR;
734
735 if (sr_scpi_get_float(sdi->conn,
736 (*config->scpi_dialect)[SCPI_CMD_GET_TIMEBASE],
737 &tmp_float) != SR_OK)
738 return SR_ERR;
739
740 if (sr_scpi_get_string(sdi->conn,
741 (*config->scpi_dialect)[SCPI_CMD_GET_TIMEBASE],
742 &tmp_str) != SR_OK)
743 return SR_ERR;
744
745 if (array_float_get(tmp_str, ARRAY_AND_SIZE(timebases), &i) != SR_OK) {
746 g_free(tmp_str);
747 sr_err("Could not determine array index for time base.");
748 return SR_ERR;
749 }
750 g_free(tmp_str);
751
752 state->timebase = i;
753
754 if (sr_scpi_get_float(sdi->conn,
755 (*config->scpi_dialect)[SCPI_CMD_GET_HORIZ_TRIGGERPOS],
756 &tmp_float) != SR_OK)
757 return SR_ERR;
758 state->horiz_triggerpos = tmp_float /
759 (((double) (*config->timebases)[state->timebase][0] /
760 (*config->timebases)[state->timebase][1]) * config->num_xdivs);
761 state->horiz_triggerpos -= 0.5;
762 state->horiz_triggerpos *= -1;
763
764 if (scope_state_get_array_option(sdi->conn,
765 (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_SOURCE],
766 config->trigger_sources, config->num_trigger_sources,
767 &state->trigger_source) != SR_OK)
768 return SR_ERR;
769
770 if (scope_state_get_array_option(sdi->conn,
771 (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_SLOPE],
772 config->trigger_slopes, config->num_trigger_slopes,
773 &state->trigger_slope) != SR_OK)
774 return SR_ERR;
775
776 if (hmo_update_sample_rate(sdi) != SR_OK)
777 return SR_ERR;
778
779 sr_info("Fetching finished.");
780
781 scope_state_dump(config, state);
782
783 return SR_OK;
784}
785
786static struct scope_state *scope_state_new(const struct scope_config *config)
787{
788 struct scope_state *state;
789
790 state = g_malloc0(sizeof(struct scope_state));
791 state->analog_channels = g_malloc0_n(config->analog_channels,
792 sizeof(struct analog_channel_state));
793 state->digital_channels = g_malloc0_n(
794 config->digital_channels, sizeof(gboolean));
795 state->digital_pods = g_malloc0_n(config->digital_pods,
796 sizeof(struct digital_pod_state));
797
798 return state;
799}
800
801SR_PRIV void hmo_scope_state_free(struct scope_state *state)
802{
803 g_free(state->analog_channels);
804 g_free(state->digital_channels);
805 g_free(state->digital_pods);
806 g_free(state);
807}
808
809SR_PRIV int hmo_init_device(struct sr_dev_inst *sdi)
810{
811 int model_index;
812 unsigned int i, j, group;
813 struct sr_channel *ch;
814 struct dev_context *devc;
815 int ret;
816
817 devc = sdi->priv;
818 model_index = -1;
819
820 /* Find the exact model. */
821 for (i = 0; i < ARRAY_SIZE(scope_models); i++) {
822 for (j = 0; scope_models[i].name[j]; j++) {
823 if (!strcmp(sdi->model, scope_models[i].name[j])) {
824 model_index = i;
825 break;
826 }
827 }
828 if (model_index != -1)
829 break;
830 }
831
832 if (model_index == -1) {
833 sr_dbg("Unsupported device.");
834 return SR_ERR_NA;
835 }
836
837 devc->analog_groups = g_malloc0(sizeof(struct sr_channel_group*) *
838 scope_models[model_index].analog_channels);
839 devc->digital_groups = g_malloc0(sizeof(struct sr_channel_group*) *
840 scope_models[model_index].digital_pods);
841 if (!devc->analog_groups || !devc->digital_groups) {
842 g_free(devc->analog_groups);
843 g_free(devc->digital_groups);
844 return SR_ERR_MALLOC;
845 }
846
847 /* Add analog channels. */
848 for (i = 0; i < scope_models[model_index].analog_channels; i++) {
849 ch = sr_channel_new(sdi, i, SR_CHANNEL_ANALOG, TRUE,
850 (*scope_models[model_index].analog_names)[i]);
851
852 devc->analog_groups[i] = g_malloc0(sizeof(struct sr_channel_group));
853
854 devc->analog_groups[i]->name = g_strdup(
855 (char *)(*scope_models[model_index].analog_names)[i]);
856 devc->analog_groups[i]->channels = g_slist_append(NULL, ch);
857
858 sdi->channel_groups = g_slist_append(sdi->channel_groups,
859 devc->analog_groups[i]);
860 }
861
862 /* Add digital channel groups. */
863 ret = SR_OK;
864 for (i = 0; i < scope_models[model_index].digital_pods; i++) {
865 devc->digital_groups[i] = g_malloc0(sizeof(struct sr_channel_group));
866 if (!devc->digital_groups[i]) {
867 ret = SR_ERR_MALLOC;
868 break;
869 }
870 devc->digital_groups[i]->name = g_strdup_printf("POD%d", i);
871 sdi->channel_groups = g_slist_append(sdi->channel_groups,
872 devc->digital_groups[i]);
873 }
874 if (ret != SR_OK)
875 return ret;
876
877 /* Add digital channels. */
878 for (i = 0; i < scope_models[model_index].digital_channels; i++) {
879 ch = sr_channel_new(sdi, i, SR_CHANNEL_LOGIC, TRUE,
880 (*scope_models[model_index].digital_names)[i]);
881
882 group = i / 8;
883 devc->digital_groups[group]->channels = g_slist_append(
884 devc->digital_groups[group]->channels, ch);
885 }
886
887 devc->model_config = &scope_models[model_index];
888 devc->samples_limit = 0;
889 devc->frame_limit = 0;
890
891 if (!(devc->model_state = scope_state_new(devc->model_config)))
892 return SR_ERR_MALLOC;
893
894 return SR_OK;
895}
896
897/* Queue data of one channel group, for later submission. */
898SR_PRIV void hmo_queue_logic_data(struct dev_context *devc,
899 size_t group, GByteArray *pod_data)
900{
901 size_t size;
902 GByteArray *store;
903 uint8_t *logic_data;
904 size_t idx, logic_step;
905
906 /*
907 * Upon first invocation, allocate the array which can hold the
908 * combined logic data for all channels. Assume that each channel
909 * will yield an identical number of samples per receive call.
910 *
911 * As a poor man's safety measure: (Silently) skip processing
912 * for unexpected sample counts, and ignore samples for
913 * unexpected channel groups. Don't bother with complicated
914 * resize logic, considering that many models only support one
915 * pod, and the most capable supported models have two pods of
916 * identical size. We haven't yet seen any "odd" configuration.
917 */
918 if (!devc->logic_data) {
919 size = pod_data->len * devc->pod_count;
920 store = g_byte_array_sized_new(size);
921 memset(store->data, 0, size);
922 store = g_byte_array_set_size(store, size);
923 devc->logic_data = store;
924 } else {
925 store = devc->logic_data;
926 size = store->len / devc->pod_count;
927 if (group >= devc->pod_count)
928 return;
929 }
930
931 /*
932 * Fold the data of the most recently received channel group into
933 * the storage, where data resides for all channels combined.
934 */
935 logic_data = store->data;
936 logic_data += group;
937 logic_step = devc->pod_count;
938 for (idx = 0; idx < pod_data->len; idx++) {
939 *logic_data = pod_data->data[idx];
940 logic_data += logic_step;
941 }
942
943 /* Truncate acquisition if a smaller number of samples has been requested. */
944 if (devc->samples_limit > 0 && devc->logic_data->len > devc->samples_limit * devc->pod_count)
945 devc->logic_data->len = devc->samples_limit * devc->pod_count;
946}
947
948/* Submit data for all channels, after the individual groups got collected. */
949SR_PRIV void hmo_send_logic_packet(struct sr_dev_inst *sdi,
950 struct dev_context *devc)
951{
952 struct sr_datafeed_packet packet;
953 struct sr_datafeed_logic logic;
954
955 if (!devc->logic_data)
956 return;
957
958 logic.data = devc->logic_data->data;
959 logic.length = devc->logic_data->len;
960 logic.unitsize = devc->pod_count;
961
962 packet.type = SR_DF_LOGIC;
963 packet.payload = &logic;
964
965 sr_session_send(sdi, &packet);
966}
967
968/* Undo previous resource allocation. */
969SR_PRIV void hmo_cleanup_logic_data(struct dev_context *devc)
970{
971
972 if (devc->logic_data) {
973 g_byte_array_free(devc->logic_data, TRUE);
974 devc->logic_data = NULL;
975 }
976 /*
977 * Keep 'pod_count'! It's required when more frames will be
978 * received, and does not harm when kept after acquisition.
979 */
980}
981
982SR_PRIV int hmo_receive_data(int fd, int revents, void *cb_data)
983{
984 struct sr_channel *ch;
985 struct sr_dev_inst *sdi;
986 struct dev_context *devc;
987 struct scope_state *state;
988 struct sr_datafeed_packet packet;
989 GByteArray *data;
990 struct sr_datafeed_analog analog;
991 struct sr_analog_encoding encoding;
992 struct sr_analog_meaning meaning;
993 struct sr_analog_spec spec;
994 struct sr_datafeed_logic logic;
995 size_t group;
996
997 (void)fd;
998 (void)revents;
999
1000 data = NULL;
1001
1002 if (!(sdi = cb_data))
1003 return TRUE;
1004
1005 if (!(devc = sdi->priv))
1006 return TRUE;
1007
1008 /* Although this is correct in general, the USBTMC libusb implementation
1009 * currently does not generate an event prior to the first read. Often
1010 * it is ok to start reading just after the 50ms timeout. See bug #785.
1011 if (revents != G_IO_IN)
1012 return TRUE;
1013 */
1014
1015 ch = devc->current_channel->data;
1016 state = devc->model_state;
1017
1018 /*
1019 * Send "frame begin" packet upon reception of data for the
1020 * first enabled channel.
1021 */
1022 if (devc->current_channel == devc->enabled_channels) {
1023 packet.type = SR_DF_FRAME_BEGIN;
1024 sr_session_send(sdi, &packet);
1025 }
1026
1027 /*
1028 * Pass on the received data of the channel(s).
1029 */
1030 switch (ch->type) {
1031 case SR_CHANNEL_ANALOG:
1032 if (sr_scpi_get_block(sdi->conn, NULL, &data) != SR_OK) {
1033 if (data)
1034 g_byte_array_free(data, TRUE);
1035 return TRUE;
1036 }
1037
1038 packet.type = SR_DF_ANALOG;
1039
1040 analog.data = data->data;
1041 analog.num_samples = data->len / sizeof(float);
1042 /* Truncate acquisition if a smaller number of samples has been requested. */
1043 if (devc->samples_limit > 0 && analog.num_samples > devc->samples_limit)
1044 analog.num_samples = devc->samples_limit;
1045 analog.encoding = &encoding;
1046 analog.meaning = &meaning;
1047 analog.spec = &spec;
1048
1049 encoding.unitsize = sizeof(float);
1050 encoding.is_signed = TRUE;
1051 encoding.is_float = TRUE;
1052#ifdef WORDS_BIGENDIAN
1053 encoding.is_bigendian = TRUE;
1054#else
1055 encoding.is_bigendian = FALSE;
1056#endif
1057 /* TODO: Use proper 'digits' value for this device (and its modes). */
1058 encoding.digits = 2;
1059 encoding.is_digits_decimal = FALSE;
1060 encoding.scale.p = 1;
1061 encoding.scale.q = 1;
1062 encoding.offset.p = 0;
1063 encoding.offset.q = 1;
1064 if (state->analog_channels[ch->index].probe_unit == 'V') {
1065 meaning.mq = SR_MQ_VOLTAGE;
1066 meaning.unit = SR_UNIT_VOLT;
1067 } else {
1068 meaning.mq = SR_MQ_CURRENT;
1069 meaning.unit = SR_UNIT_AMPERE;
1070 }
1071 meaning.mqflags = 0;
1072 meaning.channels = g_slist_append(NULL, ch);
1073 /* TODO: Use proper 'digits' value for this device (and its modes). */
1074 spec.spec_digits = 2;
1075 packet.payload = &analog;
1076 sr_session_send(sdi, &packet);
1077 devc->num_samples = data->len / sizeof(float);
1078 g_slist_free(meaning.channels);
1079 g_byte_array_free(data, TRUE);
1080 data = NULL;
1081 break;
1082 case SR_CHANNEL_LOGIC:
1083 if (sr_scpi_get_block(sdi->conn, NULL, &data) != SR_OK) {
1084 if (data)
1085 g_byte_array_free(data, TRUE);
1086 return TRUE;
1087 }
1088
1089 /*
1090 * If only data from the first pod is involved in the
1091 * acquisition, then the raw input bytes can get passed
1092 * forward for performance reasons. When the second pod
1093 * is involved (either alone, or in combination with the
1094 * first pod), then the received bytes need to be put
1095 * into memory in such a layout that all channel groups
1096 * get combined, and a unitsize larger than a single byte
1097 * applies. The "queue" logic transparently copes with
1098 * any such configuration. This works around the lack
1099 * of support for "meaning" to logic data, which is used
1100 * above for analog data.
1101 */
1102 if (devc->pod_count == 1) {
1103 packet.type = SR_DF_LOGIC;
1104 logic.data = data->data;
1105 logic.length = data->len;
1106 /* Truncate acquisition if a smaller number of samples has been requested. */
1107 if (devc->samples_limit > 0 && logic.length > devc->samples_limit)
1108 logic.length = devc->samples_limit;
1109 logic.unitsize = 1;
1110 packet.payload = &logic;
1111 sr_session_send(sdi, &packet);
1112 } else {
1113 group = ch->index / 8;
1114 hmo_queue_logic_data(devc, group, data);
1115 }
1116
1117 devc->num_samples = data->len / devc->pod_count;
1118 g_byte_array_free(data, TRUE);
1119 data = NULL;
1120 break;
1121 default:
1122 sr_err("Invalid channel type.");
1123 break;
1124 }
1125
1126 /*
1127 * Advance to the next enabled channel. When data for all enabled
1128 * channels was received, then flush potentially queued logic data,
1129 * and send the "frame end" packet.
1130 */
1131 if (devc->current_channel->next) {
1132 devc->current_channel = devc->current_channel->next;
1133 hmo_request_data(sdi);
1134 return TRUE;
1135 }
1136 hmo_send_logic_packet(sdi, devc);
1137
1138 /*
1139 * Release the logic data storage after each frame. This copes
1140 * with sample counts that differ in length per frame. -- Is
1141 * this a real constraint when acquiring multiple frames with
1142 * identical device settings?
1143 */
1144 hmo_cleanup_logic_data(devc);
1145
1146 packet.type = SR_DF_FRAME_END;
1147 sr_session_send(sdi, &packet);
1148
1149 /*
1150 * End of frame was reached. Stop acquisition after the specified
1151 * number of frames or after the specified number of samples, or
1152 * continue reception by starting over at the first enabled channel.
1153 */
1154 if (++devc->num_frames >= devc->frame_limit || devc->num_samples >= devc->samples_limit) {
1155 sr_dev_acquisition_stop(sdi);
1156 hmo_cleanup_logic_data(devc);
1157 } else {
1158 devc->current_channel = devc->enabled_channels;
1159 hmo_request_data(sdi);
1160 }
1161
1162 return TRUE;
1163}
Hardware access and backend lib