]> 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: Release enabled channels when acquisition start fails
[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 *
6 * This program is free software: you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation, either version 3 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program. If not, see <http://www.gnu.org/licenses/>.
18 */
19
20#include <config.h>
21#include <math.h>
22#include <stdlib.h>
23#include "scpi.h"
24#include "protocol.h"
25
26static const char *hameg_scpi_dialect[] = {
27 [SCPI_CMD_GET_DIG_DATA] = ":FORM UINT,8;:POD%d:DATA?",
28 [SCPI_CMD_GET_TIMEBASE] = ":TIM:SCAL?",
29 [SCPI_CMD_SET_TIMEBASE] = ":TIM:SCAL %s",
30 [SCPI_CMD_GET_COUPLING] = ":CHAN%d:COUP?",
31 [SCPI_CMD_SET_COUPLING] = ":CHAN%d:COUP %s",
32 [SCPI_CMD_GET_SAMPLE_RATE] = ":ACQ:SRAT?",
33 [SCPI_CMD_GET_SAMPLE_RATE_LIVE] = ":%s:DATA:POINTS?",
34 [SCPI_CMD_GET_ANALOG_DATA] = ":FORM REAL,32;:CHAN%d:DATA?",
35 [SCPI_CMD_GET_VERTICAL_DIV] = ":CHAN%d:SCAL?",
36 [SCPI_CMD_SET_VERTICAL_DIV] = ":CHAN%d:SCAL %s",
37 [SCPI_CMD_GET_DIG_POD_STATE] = ":POD%d:STAT?",
38 [SCPI_CMD_SET_DIG_POD_STATE] = ":POD%d:STAT %d",
39 [SCPI_CMD_GET_TRIGGER_SLOPE] = ":TRIG:A:EDGE:SLOP?",
40 [SCPI_CMD_SET_TRIGGER_SLOPE] = ":TRIG:A:EDGE:SLOP %s",
41 [SCPI_CMD_GET_TRIGGER_SOURCE] = ":TRIG:A:SOUR?",
42 [SCPI_CMD_SET_TRIGGER_SOURCE] = ":TRIG:A:SOUR %s",
43 [SCPI_CMD_GET_DIG_CHAN_STATE] = ":LOG%d:STAT?",
44 [SCPI_CMD_SET_DIG_CHAN_STATE] = ":LOG%d:STAT %d",
45 [SCPI_CMD_GET_VERTICAL_OFFSET] = ":CHAN%d:POS?",
46 [SCPI_CMD_GET_HORIZ_TRIGGERPOS] = ":TIM:POS?",
47 [SCPI_CMD_SET_HORIZ_TRIGGERPOS] = ":TIM:POS %s",
48 [SCPI_CMD_GET_ANALOG_CHAN_STATE] = ":CHAN%d:STAT?",
49 [SCPI_CMD_SET_ANALOG_CHAN_STATE] = ":CHAN%d:STAT %d",
50 [SCPI_CMD_GET_PROBE_UNIT] = ":PROB%d:SET:ATT:UNIT?",
51};
52
53static const uint32_t hmo_devopts[] = {
54 SR_CONF_OSCILLOSCOPE,
55 SR_CONF_LIMIT_FRAMES | SR_CONF_GET | SR_CONF_SET,
56 SR_CONF_TRIGGER_SOURCE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
57 SR_CONF_TIMEBASE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
58 SR_CONF_NUM_HDIV | SR_CONF_GET,
59 SR_CONF_TRIGGER_SLOPE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
60 SR_CONF_HORIZ_TRIGGERPOS | SR_CONF_GET | SR_CONF_SET,
61 SR_CONF_SAMPLERATE | SR_CONF_GET,
62};
63
64static const uint32_t hmo_analog_devopts[] = {
65 SR_CONF_NUM_VDIV | SR_CONF_GET,
66 SR_CONF_COUPLING | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
67 SR_CONF_VDIV | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
68};
69
70static const char *hmo_coupling_options[] = {
71 "AC", // AC with 50 Ohm termination (152x, 202x, 30xx, 1202)
72 "ACL", // AC with 1 MOhm termination
73 "DC", // DC with 50 Ohm termination
74 "DCL", // DC with 1 MOhm termination
75 "GND",
76 NULL,
77};
78
79static const char *scope_trigger_slopes[] = {
80 "POS",
81 "NEG",
82 "EITH",
83 NULL,
84};
85
86static const char *hmo_compact2_trigger_sources[] = {
87 "CH1",
88 "CH2",
89 "LINE",
90 "EXT",
91 "PATT",
92 "BUS1",
93 "BUS2",
94 "D0",
95 "D1",
96 "D2",
97 "D3",
98 "D4",
99 "D5",
100 "D6",
101 "D7",
102 NULL,
103};
104
105static const char *hmo_compact4_trigger_sources[] = {
106 "CH1",
107 "CH2",
108 "CH3",
109 "CH4",
110 "LINE",
111 "EXT",
112 "PATT",
113 "BUS1",
114 "BUS2",
115 "D0",
116 "D1",
117 "D2",
118 "D3",
119 "D4",
120 "D5",
121 "D6",
122 "D7",
123 NULL,
124};
125
126static const uint64_t hmo_timebases[][2] = {
127 /* nanoseconds */
128 { 2, 1000000000 },
129 { 5, 1000000000 },
130 { 10, 1000000000 },
131 { 20, 1000000000 },
132 { 50, 1000000000 },
133 { 100, 1000000000 },
134 { 200, 1000000000 },
135 { 500, 1000000000 },
136 /* microseconds */
137 { 1, 1000000 },
138 { 2, 1000000 },
139 { 5, 1000000 },
140 { 10, 1000000 },
141 { 20, 1000000 },
142 { 50, 1000000 },
143 { 100, 1000000 },
144 { 200, 1000000 },
145 { 500, 1000000 },
146 /* milliseconds */
147 { 1, 1000 },
148 { 2, 1000 },
149 { 5, 1000 },
150 { 10, 1000 },
151 { 20, 1000 },
152 { 50, 1000 },
153 { 100, 1000 },
154 { 200, 1000 },
155 { 500, 1000 },
156 /* seconds */
157 { 1, 1 },
158 { 2, 1 },
159 { 5, 1 },
160 { 10, 1 },
161 { 20, 1 },
162 { 50, 1 },
163};
164
165static const uint64_t hmo_vdivs[][2] = {
166 /* millivolts */
167 { 1, 1000 },
168 { 2, 1000 },
169 { 5, 1000 },
170 { 10, 1000 },
171 { 20, 1000 },
172 { 50, 1000 },
173 { 100, 1000 },
174 { 200, 1000 },
175 { 500, 1000 },
176 /* volts */
177 { 1, 1 },
178 { 2, 1 },
179 { 5, 1 },
180 { 10, 1 },
181 { 20, 1 },
182 { 50, 1 },
183};
184
185static const char *scope_analog_channel_names[] = {
186 "CH1",
187 "CH2",
188 "CH3",
189 "CH4",
190};
191
192static const char *scope_digital_channel_names[] = {
193 "D0",
194 "D1",
195 "D2",
196 "D3",
197 "D4",
198 "D5",
199 "D6",
200 "D7",
201 "D8",
202 "D9",
203 "D10",
204 "D11",
205 "D12",
206 "D13",
207 "D14",
208 "D15",
209};
210
211static const struct scope_config scope_models[] = {
212 {
213 /* HMO2522/3032/3042/3052 support 16 digital channels but they're not supported yet. */
214 .name = {"HMO1002", "HMO722", "HMO1022", "HMO1522", "HMO2022", "HMO2522",
215 "HMO3032", "HMO3042", "HMO3052", NULL},
216 .analog_channels = 2,
217 .digital_channels = 8,
218 .digital_pods = 1,
219
220 .analog_names = &scope_analog_channel_names,
221 .digital_names = &scope_digital_channel_names,
222
223 .devopts = &hmo_devopts,
224 .num_devopts = ARRAY_SIZE(hmo_devopts),
225
226 .analog_devopts = &hmo_analog_devopts,
227 .num_analog_devopts = ARRAY_SIZE(hmo_analog_devopts),
228
229 .coupling_options = &hmo_coupling_options,
230 .trigger_sources = &hmo_compact2_trigger_sources,
231 .trigger_slopes = &scope_trigger_slopes,
232
233 .timebases = &hmo_timebases,
234 .num_timebases = ARRAY_SIZE(hmo_timebases),
235
236 .vdivs = &hmo_vdivs,
237 .num_vdivs = ARRAY_SIZE(hmo_vdivs),
238
239 .num_xdivs = 12,
240 .num_ydivs = 8,
241
242 .scpi_dialect = &hameg_scpi_dialect,
243 },
244 {
245 /* HMO2524/3034/3044/3054 support 16 digital channels but they're not supported yet. */
246 .name = {"HMO724", "HMO1024", "HMO1524", "HMO2024", "HMO2524",
247 "HMO3034", "HMO3044", "HMO3054", NULL},
248 .analog_channels = 4,
249 .digital_channels = 8,
250 .digital_pods = 1,
251
252 .analog_names = &scope_analog_channel_names,
253 .digital_names = &scope_digital_channel_names,
254
255 .devopts = &hmo_devopts,
256 .num_devopts = ARRAY_SIZE(hmo_devopts),
257
258 .analog_devopts = &hmo_analog_devopts,
259 .num_analog_devopts = ARRAY_SIZE(hmo_analog_devopts),
260
261 .coupling_options = &hmo_coupling_options,
262 .trigger_sources = &hmo_compact4_trigger_sources,
263 .trigger_slopes = &scope_trigger_slopes,
264
265 .timebases = &hmo_timebases,
266 .num_timebases = ARRAY_SIZE(hmo_timebases),
267
268 .vdivs = &hmo_vdivs,
269 .num_vdivs = ARRAY_SIZE(hmo_vdivs),
270
271 .num_xdivs = 12,
272 .num_ydivs = 8,
273
274 .scpi_dialect = &hameg_scpi_dialect,
275 },
276};
277
278static void scope_state_dump(const struct scope_config *config,
279 struct scope_state *state)
280{
281 unsigned int i;
282 char *tmp;
283
284 for (i = 0; i < config->analog_channels; i++) {
285 tmp = sr_voltage_string((*config->vdivs)[state->analog_channels[i].vdiv][0],
286 (*config->vdivs)[state->analog_channels[i].vdiv][1]);
287 sr_info("State of analog channel %d -> %s : %s (coupling) %s (vdiv) %2.2e (offset)",
288 i + 1, state->analog_channels[i].state ? "On" : "Off",
289 (*config->coupling_options)[state->analog_channels[i].coupling],
290 tmp, state->analog_channels[i].vertical_offset);
291 }
292
293 for (i = 0; i < config->digital_channels; i++) {
294 sr_info("State of digital channel %d -> %s", i,
295 state->digital_channels[i] ? "On" : "Off");
296 }
297
298 for (i = 0; i < config->digital_pods; i++) {
299 sr_info("State of digital POD %d -> %s", i,
300 state->digital_pods[i] ? "On" : "Off");
301 }
302
303 tmp = sr_period_string((*config->timebases)[state->timebase][0] *
304 (*config->timebases)[state->timebase][1]);
305 sr_info("Current timebase: %s", tmp);
306 g_free(tmp);
307
308 tmp = sr_samplerate_string(state->sample_rate);
309 sr_info("Current samplerate: %s", tmp);
310 g_free(tmp);
311
312 sr_info("Current trigger: %s (source), %s (slope) %.2f (offset)",
313 (*config->trigger_sources)[state->trigger_source],
314 (*config->trigger_slopes)[state->trigger_slope],
315 state->horiz_triggerpos);
316}
317
318static int scope_state_get_array_option(struct sr_scpi_dev_inst *scpi,
319 const char *command, const char *(*array)[], int *result)
320{
321 char *tmp;
322 unsigned int i;
323
324 if (sr_scpi_get_string(scpi, command, &tmp) != SR_OK) {
325 g_free(tmp);
326 return SR_ERR;
327 }
328
329 for (i = 0; (*array)[i]; i++) {
330 if (!g_strcmp0(tmp, (*array)[i])) {
331 *result = i;
332 g_free(tmp);
333 tmp = NULL;
334 break;
335 }
336 }
337
338 if (tmp) {
339 g_free(tmp);
340 return SR_ERR;
341 }
342
343 return SR_OK;
344}
345
346/**
347 * This function takes a value of the form "2.000E-03" and returns the index
348 * of an array where a matching pair was found.
349 *
350 * @param value The string to be parsed.
351 * @param array The array of s/f pairs.
352 * @param array_len The number of pairs in the array.
353 * @param result The index at which a matching pair was found.
354 *
355 * @return SR_ERR on any parsing error, SR_OK otherwise.
356 */
357static int array_float_get(gchar *value, const uint64_t array[][2],
358 int array_len, unsigned int *result)
359{
360 struct sr_rational rval;
361 struct sr_rational aval;
362
363 if (sr_parse_rational(value, &rval) != SR_OK)
364 return SR_ERR;
365
366 for (int i = 0; i < array_len; i++) {
367 sr_rational_set(&aval, array[i][0], array[i][1]);
368 if (sr_rational_eq(&rval, &aval)) {
369 *result = i;
370 return SR_OK;
371 }
372 }
373
374 return SR_ERR;
375}
376
377static int analog_channel_state_get(struct sr_scpi_dev_inst *scpi,
378 const struct scope_config *config,
379 struct scope_state *state)
380{
381 unsigned int i, j;
382 char command[MAX_COMMAND_SIZE];
383 char *tmp_str;
384
385 for (i = 0; i < config->analog_channels; i++) {
386 g_snprintf(command, sizeof(command),
387 (*config->scpi_dialect)[SCPI_CMD_GET_ANALOG_CHAN_STATE],
388 i + 1);
389
390 if (sr_scpi_get_bool(scpi, command,
391 &state->analog_channels[i].state) != SR_OK)
392 return SR_ERR;
393
394 g_snprintf(command, sizeof(command),
395 (*config->scpi_dialect)[SCPI_CMD_GET_VERTICAL_DIV],
396 i + 1);
397
398 if (sr_scpi_get_string(scpi, command, &tmp_str) != SR_OK)
399 return SR_ERR;
400
401 if (array_float_get(tmp_str, hmo_vdivs, ARRAY_SIZE(hmo_vdivs),
402 &j) != SR_OK) {
403 g_free(tmp_str);
404 sr_err("Could not determine array index for vertical div scale.");
405 return SR_ERR;
406 }
407
408 g_free(tmp_str);
409 state->analog_channels[i].vdiv = j;
410
411 g_snprintf(command, sizeof(command),
412 (*config->scpi_dialect)[SCPI_CMD_GET_VERTICAL_OFFSET],
413 i + 1);
414
415 if (sr_scpi_get_float(scpi, command,
416 &state->analog_channels[i].vertical_offset) != SR_OK)
417 return SR_ERR;
418
419 g_snprintf(command, sizeof(command),
420 (*config->scpi_dialect)[SCPI_CMD_GET_COUPLING],
421 i + 1);
422
423 if (scope_state_get_array_option(scpi, command, config->coupling_options,
424 &state->analog_channels[i].coupling) != SR_OK)
425 return SR_ERR;
426
427 g_snprintf(command, sizeof(command),
428 (*config->scpi_dialect)[SCPI_CMD_GET_PROBE_UNIT],
429 i + 1);
430
431 if (sr_scpi_get_string(scpi, command, &tmp_str) != SR_OK)
432 return SR_ERR;
433
434 if (tmp_str[0] == 'A')
435 state->analog_channels[i].probe_unit = 'A';
436 else
437 state->analog_channels[i].probe_unit = 'V';
438 g_free(tmp_str);
439 }
440
441 return SR_OK;
442}
443
444static int digital_channel_state_get(struct sr_scpi_dev_inst *scpi,
445 const struct scope_config *config,
446 struct scope_state *state)
447{
448 unsigned int i;
449 char command[MAX_COMMAND_SIZE];
450
451 for (i = 0; i < config->digital_channels; i++) {
452 g_snprintf(command, sizeof(command),
453 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_CHAN_STATE],
454 i);
455
456 if (sr_scpi_get_bool(scpi, command,
457 &state->digital_channels[i]) != SR_OK)
458 return SR_ERR;
459 }
460
461 for (i = 0; i < config->digital_pods; i++) {
462 g_snprintf(command, sizeof(command),
463 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_STATE],
464 i + 1);
465
466 if (sr_scpi_get_bool(scpi, command,
467 &state->digital_pods[i]) != SR_OK)
468 return SR_ERR;
469 }
470
471 return SR_OK;
472}
473
474SR_PRIV int hmo_update_sample_rate(const struct sr_dev_inst *sdi)
475{
476 struct dev_context *devc;
477 struct scope_state *state;
478 const struct scope_config *config;
479
480 int tmp;
481 unsigned int i;
482 float tmp_float;
483 gboolean channel_found;
484 char tmp_str[MAX_COMMAND_SIZE];
485 char chan_name[20];
486
487 devc = sdi->priv;
488 config = devc->model_config;
489 state = devc->model_state;
490 channel_found = FALSE;
491
492 for (i = 0; i < config->analog_channels; i++) {
493 if (state->analog_channels[i].state) {
494 g_snprintf(chan_name, sizeof(chan_name), "CHAN%d", i + 1);
495 g_snprintf(tmp_str, sizeof(tmp_str),
496 (*config->scpi_dialect)[SCPI_CMD_GET_SAMPLE_RATE_LIVE],
497 chan_name);
498 channel_found = TRUE;
499 break;
500 }
501 }
502
503 if (!channel_found) {
504 for (i = 0; i < config->digital_pods; i++) {
505 if (state->digital_pods[i]) {
506 g_snprintf(chan_name, sizeof(chan_name), "POD%d", i);
507 g_snprintf(tmp_str, sizeof(tmp_str),
508 (*config->scpi_dialect)[SCPI_CMD_GET_SAMPLE_RATE_LIVE],
509 chan_name);
510 channel_found = TRUE;
511 break;
512 }
513 }
514 }
515
516 /* No channel is active, ask the instrument for the sample rate
517 * in single shot mode */
518 if (!channel_found) {
519 if (sr_scpi_get_float(sdi->conn,
520 (*config->scpi_dialect)[SCPI_CMD_GET_SAMPLE_RATE],
521 &tmp_float) != SR_OK)
522 return SR_ERR;
523
524 state->sample_rate = tmp_float;
525 } else {
526 if (sr_scpi_get_int(sdi->conn, tmp_str, &tmp) != SR_OK)
527 return SR_ERR;
528 state->sample_rate = tmp / (((float) (*config->timebases)[state->timebase][0] /
529 (*config->timebases)[state->timebase][1]) *
530 config->num_xdivs);
531 }
532
533 return SR_OK;
534}
535
536SR_PRIV int hmo_scope_state_get(struct sr_dev_inst *sdi)
537{
538 struct dev_context *devc;
539 struct scope_state *state;
540 const struct scope_config *config;
541 float tmp_float;
542 unsigned int i;
543 char *tmp_str;
544
545 devc = sdi->priv;
546 config = devc->model_config;
547 state = devc->model_state;
548
549 sr_info("Fetching scope state");
550
551 if (analog_channel_state_get(sdi->conn, config, state) != SR_OK)
552 return SR_ERR;
553
554 if (digital_channel_state_get(sdi->conn, config, state) != SR_OK)
555 return SR_ERR;
556
557 if (sr_scpi_get_float(sdi->conn,
558 (*config->scpi_dialect)[SCPI_CMD_GET_TIMEBASE],
559 &tmp_float) != SR_OK)
560 return SR_ERR;
561
562 if (sr_scpi_get_string(sdi->conn,
563 (*config->scpi_dialect)[SCPI_CMD_GET_TIMEBASE],
564 &tmp_str) != SR_OK)
565 return SR_ERR;
566
567 if (array_float_get(tmp_str, hmo_timebases, ARRAY_SIZE(hmo_timebases),
568 &i) != SR_OK) {
569 g_free(tmp_str);
570 sr_err("Could not determine array index for time base.");
571 return SR_ERR;
572 }
573 g_free(tmp_str);
574
575 state->timebase = i;
576
577 if (sr_scpi_get_float(sdi->conn,
578 (*config->scpi_dialect)[SCPI_CMD_GET_HORIZ_TRIGGERPOS],
579 &tmp_float) != SR_OK)
580 return SR_ERR;
581 state->horiz_triggerpos = tmp_float /
582 (((double) (*config->timebases)[state->timebase][0] /
583 (*config->timebases)[state->timebase][1]) * config->num_xdivs);
584 state->horiz_triggerpos -= 0.5;
585 state->horiz_triggerpos *= -1;
586
587 if (scope_state_get_array_option(sdi->conn,
588 (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_SOURCE],
589 config->trigger_sources, &state->trigger_source) != SR_OK)
590 return SR_ERR;
591
592 if (scope_state_get_array_option(sdi->conn,
593 (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_SLOPE],
594 config->trigger_slopes, &state->trigger_slope) != SR_OK)
595 return SR_ERR;
596
597 if (hmo_update_sample_rate(sdi) != SR_OK)
598 return SR_ERR;
599
600 sr_info("Fetching finished.");
601
602 scope_state_dump(config, state);
603
604 return SR_OK;
605}
606
607static struct scope_state *scope_state_new(const struct scope_config *config)
608{
609 struct scope_state *state;
610
611 state = g_malloc0(sizeof(struct scope_state));
612 state->analog_channels = g_malloc0_n(config->analog_channels,
613 sizeof(struct analog_channel_state));
614 state->digital_channels = g_malloc0_n(
615 config->digital_channels, sizeof(gboolean));
616 state->digital_pods = g_malloc0_n(config->digital_pods,
617 sizeof(gboolean));
618
619 return state;
620}
621
622SR_PRIV void hmo_scope_state_free(struct scope_state *state)
623{
624 g_free(state->analog_channels);
625 g_free(state->digital_channels);
626 g_free(state->digital_pods);
627 g_free(state);
628}
629
630SR_PRIV int hmo_init_device(struct sr_dev_inst *sdi)
631{
632 char tmp[25];
633 int model_index;
634 unsigned int i, j, group;
635 struct sr_channel *ch;
636 struct dev_context *devc;
637
638 devc = sdi->priv;
639 model_index = -1;
640
641 /* Find the exact model. */
642 for (i = 0; i < ARRAY_SIZE(scope_models); i++) {
643 for (j = 0; scope_models[i].name[j]; j++) {
644 if (!strcmp(sdi->model, scope_models[i].name[j])) {
645 model_index = i;
646 break;
647 }
648 }
649 if (model_index != -1)
650 break;
651 }
652
653 if (model_index == -1) {
654 sr_dbg("Unsupported HMO device.");
655 return SR_ERR_NA;
656 }
657
658 devc->analog_groups = g_malloc0(sizeof(struct sr_channel_group*) *
659 scope_models[model_index].analog_channels);
660
661 devc->digital_groups = g_malloc0(sizeof(struct sr_channel_group*) *
662 scope_models[model_index].digital_pods);
663
664 /* Add analog channels. */
665 for (i = 0; i < scope_models[model_index].analog_channels; i++) {
666 ch = sr_channel_new(sdi, i, SR_CHANNEL_ANALOG, TRUE,
667 (*scope_models[model_index].analog_names)[i]);
668
669 devc->analog_groups[i] = g_malloc0(sizeof(struct sr_channel_group));
670
671 devc->analog_groups[i]->name = g_strdup(
672 (char *)(*scope_models[model_index].analog_names)[i]);
673 devc->analog_groups[i]->channels = g_slist_append(NULL, ch);
674
675 sdi->channel_groups = g_slist_append(sdi->channel_groups,
676 devc->analog_groups[i]);
677 }
678
679 /* Add digital channel groups. */
680 for (i = 0; i < scope_models[model_index].digital_pods; i++) {
681 g_snprintf(tmp, 25, "POD%d", i);
682
683 devc->digital_groups[i] = g_malloc0(sizeof(struct sr_channel_group));
684
685 devc->digital_groups[i]->name = g_strdup(tmp);
686 sdi->channel_groups = g_slist_append(sdi->channel_groups,
687 devc->digital_groups[i]);
688 }
689
690 /* Add digital channels. */
691 for (i = 0; i < scope_models[model_index].digital_channels; i++) {
692 ch = sr_channel_new(sdi, i, SR_CHANNEL_LOGIC, TRUE,
693 (*scope_models[model_index].digital_names)[i]);
694
695 group = i / 8;
696 devc->digital_groups[group]->channels = g_slist_append(
697 devc->digital_groups[group]->channels, ch);
698 }
699
700 devc->model_config = &scope_models[model_index];
701 devc->frame_limit = 0;
702
703 if (!(devc->model_state = scope_state_new(devc->model_config)))
704 return SR_ERR_MALLOC;
705
706 return SR_OK;
707}
708
709SR_PRIV int hmo_receive_data(int fd, int revents, void *cb_data)
710{
711 struct sr_channel *ch;
712 struct sr_dev_inst *sdi;
713 struct dev_context *devc;
714 struct scope_state *state;
715 struct sr_datafeed_packet packet;
716 GByteArray *data;
717 struct sr_datafeed_analog analog;
718 struct sr_analog_encoding encoding;
719 struct sr_analog_meaning meaning;
720 struct sr_analog_spec spec;
721 struct sr_datafeed_logic logic;
722
723 (void)fd;
724 (void)revents;
725
726 data = NULL;
727
728 if (!(sdi = cb_data))
729 return TRUE;
730
731 if (!(devc = sdi->priv))
732 return TRUE;
733
734 /* Although this is correct in general, the USBTMC libusb implementation
735 * currently does not generate an event prior to the first read. Often
736 * it is ok to start reading just after the 50ms timeout. See bug #785.
737 if (revents != G_IO_IN)
738 return TRUE;
739 */
740
741 ch = devc->current_channel->data;
742 state = devc->model_state;
743
744 switch (ch->type) {
745 case SR_CHANNEL_ANALOG:
746 if (sr_scpi_get_block(sdi->conn, NULL, &data) != SR_OK) {
747 if (data)
748 g_byte_array_free(data, TRUE);
749
750 return TRUE;
751 }
752
753 packet.type = SR_DF_FRAME_BEGIN;
754 sr_session_send(sdi, &packet);
755
756 packet.type = SR_DF_ANALOG;
757
758 analog.data = data->data;
759 analog.num_samples = data->len / sizeof(float);
760 analog.encoding = &encoding;
761 analog.meaning = &meaning;
762 analog.spec = &spec;
763
764 encoding.unitsize = sizeof(float);
765 encoding.is_signed = TRUE;
766 encoding.is_float = TRUE;
767 encoding.is_bigendian = FALSE;
768 /* TODO: Use proper 'digits' value for this device (and its modes). */
769 encoding.digits = 2;
770 encoding.is_digits_decimal = FALSE;
771 encoding.scale.p = 1;
772 encoding.scale.q = 1;
773 encoding.offset.p = 0;
774 encoding.offset.q = 1;
775 if (state->analog_channels[ch->index].probe_unit == 'V') {
776 meaning.mq = SR_MQ_VOLTAGE;
777 meaning.unit = SR_UNIT_VOLT;
778 } else {
779 meaning.mq = SR_MQ_CURRENT;
780 meaning.unit = SR_UNIT_AMPERE;
781 }
782 meaning.mqflags = 0;
783 meaning.channels = g_slist_append(NULL, ch);
784 /* TODO: Use proper 'digits' value for this device (and its modes). */
785 spec.spec_digits = 2;
786 packet.payload = &analog;
787 sr_session_send(sdi, &packet);
788 g_slist_free(meaning.channels);
789 g_byte_array_free(data, TRUE);
790 data = NULL;
791 break;
792 case SR_CHANNEL_LOGIC:
793 if (sr_scpi_get_block(sdi->conn, NULL, &data) != SR_OK) {
794 g_free(data);
795 return TRUE;
796 }
797
798 packet.type = SR_DF_FRAME_BEGIN;
799 sr_session_send(sdi, &packet);
800
801 logic.length = data->len;
802 logic.unitsize = 1;
803 logic.data = data->data;
804 packet.type = SR_DF_LOGIC;
805 packet.payload = &logic;
806 sr_session_send(sdi, &packet);
807 g_byte_array_free(data, TRUE);
808 data = NULL;
809 break;
810 default:
811 sr_err("Invalid channel type.");
812 break;
813 }
814
815 packet.type = SR_DF_FRAME_END;
816 sr_session_send(sdi, &packet);
817
818 if (devc->current_channel->next) {
819 devc->current_channel = devc->current_channel->next;
820 hmo_request_data(sdi);
821 } else if (++devc->num_frames == devc->frame_limit) {
822 sdi->driver->dev_acquisition_stop(sdi);
823 } else {
824 devc->current_channel = devc->enabled_channels;
825 hmo_request_data(sdi);
826 }
827
828 return TRUE;
829}
Hardware access and backend lib