]> 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
drivers: Consistently name SCPI helper functions 'probe_device'.
[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
26SR_PRIV void hmo_queue_logic_data(struct dev_context *devc,
27 size_t group, GByteArray *pod_data);
28SR_PRIV void hmo_send_logic_packet(struct sr_dev_inst *sdi,
29 struct dev_context *devc);
30SR_PRIV void hmo_cleanup_logic_data(struct dev_context *devc);
31
32static const char *hameg_scpi_dialect[] = {
33 [SCPI_CMD_GET_DIG_DATA] = ":FORM UINT,8;:POD%d:DATA?",
34 [SCPI_CMD_GET_TIMEBASE] = ":TIM:SCAL?",
35 [SCPI_CMD_SET_TIMEBASE] = ":TIM:SCAL %s",
36 [SCPI_CMD_GET_COUPLING] = ":CHAN%d:COUP?",
37 [SCPI_CMD_SET_COUPLING] = ":CHAN%d:COUP %s",
38 [SCPI_CMD_GET_SAMPLE_RATE] = ":ACQ:SRAT?",
39 [SCPI_CMD_GET_SAMPLE_RATE_LIVE] = ":%s:DATA:POINTS?",
40 [SCPI_CMD_GET_ANALOG_DATA] = ":FORM:BORD %s;" \
41 ":FORM REAL,32;:CHAN%d:DATA?",
42 [SCPI_CMD_GET_VERTICAL_DIV] = ":CHAN%d:SCAL?",
43 [SCPI_CMD_SET_VERTICAL_DIV] = ":CHAN%d:SCAL %s",
44 [SCPI_CMD_GET_DIG_POD_STATE] = ":POD%d:STAT?",
45 [SCPI_CMD_SET_DIG_POD_STATE] = ":POD%d:STAT %d",
46 [SCPI_CMD_GET_TRIGGER_SLOPE] = ":TRIG:A:EDGE:SLOP?",
47 [SCPI_CMD_SET_TRIGGER_SLOPE] = ":TRIG:A:EDGE:SLOP %s",
48 [SCPI_CMD_GET_TRIGGER_SOURCE] = ":TRIG:A:SOUR?",
49 [SCPI_CMD_SET_TRIGGER_SOURCE] = ":TRIG:A:SOUR %s",
50 [SCPI_CMD_GET_DIG_CHAN_STATE] = ":LOG%d:STAT?",
51 [SCPI_CMD_SET_DIG_CHAN_STATE] = ":LOG%d:STAT %d",
52 [SCPI_CMD_GET_VERTICAL_OFFSET] = ":CHAN%d:POS?",
53 [SCPI_CMD_GET_HORIZ_TRIGGERPOS] = ":TIM:POS?",
54 [SCPI_CMD_SET_HORIZ_TRIGGERPOS] = ":TIM:POS %s",
55 [SCPI_CMD_GET_ANALOG_CHAN_STATE] = ":CHAN%d:STAT?",
56 [SCPI_CMD_SET_ANALOG_CHAN_STATE] = ":CHAN%d:STAT %d",
57 [SCPI_CMD_GET_PROBE_UNIT] = ":PROB%d:SET:ATT:UNIT?",
58};
59
60static const uint32_t devopts[] = {
61 SR_CONF_OSCILLOSCOPE,
62 SR_CONF_LIMIT_FRAMES | SR_CONF_GET | SR_CONF_SET,
63 SR_CONF_SAMPLERATE | SR_CONF_GET,
64 SR_CONF_TIMEBASE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
65 SR_CONF_NUM_HDIV | SR_CONF_GET,
66 SR_CONF_HORIZ_TRIGGERPOS | SR_CONF_GET | SR_CONF_SET,
67 SR_CONF_TRIGGER_SOURCE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
68 SR_CONF_TRIGGER_SLOPE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
69};
70
71static const uint32_t devopts_cg_analog[] = {
72 SR_CONF_NUM_VDIV | SR_CONF_GET,
73 SR_CONF_VDIV | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
74 SR_CONF_COUPLING | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
75};
76
77static const char *coupling_options[] = {
78 "AC", // AC with 50 Ohm termination (152x, 202x, 30xx, 1202)
79 "ACL", // AC with 1 MOhm termination
80 "DC", // DC with 50 Ohm termination
81 "DCL", // DC with 1 MOhm termination
82 "GND",
83 NULL,
84};
85
86static const char *scope_trigger_slopes[] = {
87 "POS",
88 "NEG",
89 "EITH",
90 NULL,
91};
92
93static const char *compact2_trigger_sources[] = {
94 "CH1", "CH2",
95 "LINE", "EXT", "PATT", "BUS1", "BUS2",
96 "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
97 NULL,
98};
99
100static const char *compact4_trigger_sources[] = {
101 "CH1", "CH2", "CH3", "CH4",
102 "LINE", "EXT", "PATT", "BUS1", "BUS2",
103 "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
104 NULL,
105};
106
107static const char *compact4_dig16_trigger_sources[] = {
108 "CH1", "CH2", "CH3", "CH4",
109 "LINE", "EXT", "PATT", "BUS1", "BUS2",
110 "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
111 "D8", "D9", "D10", "D11", "D12", "D13", "D14", "D15",
112 NULL,
113};
114
115static const uint64_t timebases[][2] = {
116 /* nanoseconds */
117 { 2, 1000000000 },
118 { 5, 1000000000 },
119 { 10, 1000000000 },
120 { 20, 1000000000 },
121 { 50, 1000000000 },
122 { 100, 1000000000 },
123 { 200, 1000000000 },
124 { 500, 1000000000 },
125 /* microseconds */
126 { 1, 1000000 },
127 { 2, 1000000 },
128 { 5, 1000000 },
129 { 10, 1000000 },
130 { 20, 1000000 },
131 { 50, 1000000 },
132 { 100, 1000000 },
133 { 200, 1000000 },
134 { 500, 1000000 },
135 /* milliseconds */
136 { 1, 1000 },
137 { 2, 1000 },
138 { 5, 1000 },
139 { 10, 1000 },
140 { 20, 1000 },
141 { 50, 1000 },
142 { 100, 1000 },
143 { 200, 1000 },
144 { 500, 1000 },
145 /* seconds */
146 { 1, 1 },
147 { 2, 1 },
148 { 5, 1 },
149 { 10, 1 },
150 { 20, 1 },
151 { 50, 1 },
152};
153
154static const uint64_t vdivs[][2] = {
155 /* millivolts */
156 { 1, 1000 },
157 { 2, 1000 },
158 { 5, 1000 },
159 { 10, 1000 },
160 { 20, 1000 },
161 { 50, 1000 },
162 { 100, 1000 },
163 { 200, 1000 },
164 { 500, 1000 },
165 /* volts */
166 { 1, 1 },
167 { 2, 1 },
168 { 5, 1 },
169 { 10, 1 },
170 { 20, 1 },
171 { 50, 1 },
172};
173
174static const char *scope_analog_channel_names[] = {
175 "CH1", "CH2", "CH3", "CH4",
176};
177
178static const char *scope_digital_channel_names[] = {
179 "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
180 "D8", "D9", "D10", "D11", "D12", "D13", "D14", "D15",
181};
182
183static const struct scope_config scope_models[] = {
184 {
185 /* HMO2522/3032/3042/3052 support 16 digital channels but they're not supported yet. */
186 .name = {"HMO1002", "HMO722", "HMO1022", "HMO1522", "HMO2022", "HMO2522",
187 "HMO3032", "HMO3042", "HMO3052", NULL},
188 .analog_channels = 2,
189 .digital_channels = 8,
190 .digital_pods = 1,
191
192 .analog_names = &scope_analog_channel_names,
193 .digital_names = &scope_digital_channel_names,
194
195 .devopts = &devopts,
196 .num_devopts = ARRAY_SIZE(devopts),
197
198 .devopts_cg_analog = &devopts_cg_analog,
199 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
200
201 .coupling_options = &coupling_options,
202 .trigger_sources = &compact2_trigger_sources,
203 .trigger_slopes = &scope_trigger_slopes,
204
205 .timebases = &timebases,
206 .num_timebases = ARRAY_SIZE(timebases),
207
208 .vdivs = &vdivs,
209 .num_vdivs = ARRAY_SIZE(vdivs),
210
211 .num_xdivs = 12,
212 .num_ydivs = 8,
213
214 .scpi_dialect = &hameg_scpi_dialect,
215 },
216 {
217 .name = {"HMO724", "HMO1024", "HMO1524", "HMO2024", NULL},
218 .analog_channels = 4,
219 .digital_channels = 8,
220 .digital_pods = 1,
221
222 .analog_names = &scope_analog_channel_names,
223 .digital_names = &scope_digital_channel_names,
224
225 .devopts = &devopts,
226 .num_devopts = ARRAY_SIZE(devopts),
227
228 .devopts_cg_analog = &devopts_cg_analog,
229 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
230
231 .coupling_options = &coupling_options,
232 .trigger_sources = &compact4_trigger_sources,
233 .trigger_slopes = &scope_trigger_slopes,
234
235 .timebases = &timebases,
236 .num_timebases = ARRAY_SIZE(timebases),
237
238 .vdivs = &vdivs,
239 .num_vdivs = ARRAY_SIZE(vdivs),
240
241 .num_xdivs = 12,
242 .num_ydivs = 8,
243
244 .scpi_dialect = &hameg_scpi_dialect,
245 },
246 {
247 .name = {"HMO2524", "HMO3034", "HMO3044", "HMO3054", "HMO3524", NULL},
248 .analog_channels = 4,
249 .digital_channels = 16,
250 .digital_pods = 2,
251
252 .analog_names = &scope_analog_channel_names,
253 .digital_names = &scope_digital_channel_names,
254
255 .devopts = &devopts,
256 .num_devopts = ARRAY_SIZE(devopts),
257
258 .devopts_cg_analog = &devopts_cg_analog,
259 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
260
261 .coupling_options = &coupling_options,
262 .trigger_sources = &compact4_dig16_trigger_sources,
263 .trigger_slopes = &scope_trigger_slopes,
264
265 .timebases = &timebases,
266 .num_timebases = ARRAY_SIZE(timebases),
267
268 .vdivs = &vdivs,
269 .num_vdivs = ARRAY_SIZE(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, ARRAY_AND_SIZE(vdivs), &j) != SR_OK) {
402 g_free(tmp_str);
403 sr_err("Could not determine array index for vertical div scale.");
404 return SR_ERR;
405 }
406
407 g_free(tmp_str);
408 state->analog_channels[i].vdiv = j;
409
410 g_snprintf(command, sizeof(command),
411 (*config->scpi_dialect)[SCPI_CMD_GET_VERTICAL_OFFSET],
412 i + 1);
413
414 if (sr_scpi_get_float(scpi, command,
415 &state->analog_channels[i].vertical_offset) != SR_OK)
416 return SR_ERR;
417
418 g_snprintf(command, sizeof(command),
419 (*config->scpi_dialect)[SCPI_CMD_GET_COUPLING],
420 i + 1);
421
422 if (scope_state_get_array_option(scpi, command, config->coupling_options,
423 &state->analog_channels[i].coupling) != SR_OK)
424 return SR_ERR;
425
426 g_snprintf(command, sizeof(command),
427 (*config->scpi_dialect)[SCPI_CMD_GET_PROBE_UNIT],
428 i + 1);
429
430 if (sr_scpi_get_string(scpi, command, &tmp_str) != SR_OK)
431 return SR_ERR;
432
433 if (tmp_str[0] == 'A')
434 state->analog_channels[i].probe_unit = 'A';
435 else
436 state->analog_channels[i].probe_unit = 'V';
437 g_free(tmp_str);
438 }
439
440 return SR_OK;
441}
442
443static int digital_channel_state_get(struct sr_scpi_dev_inst *scpi,
444 const struct scope_config *config,
445 struct scope_state *state)
446{
447 unsigned int i;
448 char command[MAX_COMMAND_SIZE];
449
450 for (i = 0; i < config->digital_channels; i++) {
451 g_snprintf(command, sizeof(command),
452 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_CHAN_STATE],
453 i);
454
455 if (sr_scpi_get_bool(scpi, command,
456 &state->digital_channels[i]) != SR_OK)
457 return SR_ERR;
458 }
459
460 for (i = 0; i < config->digital_pods; i++) {
461 g_snprintf(command, sizeof(command),
462 (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_STATE],
463 i + 1);
464
465 if (sr_scpi_get_bool(scpi, command,
466 &state->digital_pods[i]) != SR_OK)
467 return SR_ERR;
468 }
469
470 return SR_OK;
471}
472
473SR_PRIV int hmo_update_sample_rate(const struct sr_dev_inst *sdi)
474{
475 struct dev_context *devc;
476 struct scope_state *state;
477 const struct scope_config *config;
478
479 int tmp;
480 unsigned int i;
481 float tmp_float;
482 gboolean channel_found;
483 char tmp_str[MAX_COMMAND_SIZE];
484 char chan_name[20];
485
486 devc = sdi->priv;
487 config = devc->model_config;
488 state = devc->model_state;
489 channel_found = FALSE;
490
491 for (i = 0; i < config->analog_channels; i++) {
492 if (state->analog_channels[i].state) {
493 g_snprintf(chan_name, sizeof(chan_name), "CHAN%d", i + 1);
494 g_snprintf(tmp_str, sizeof(tmp_str),
495 (*config->scpi_dialect)[SCPI_CMD_GET_SAMPLE_RATE_LIVE],
496 chan_name);
497 channel_found = TRUE;
498 break;
499 }
500 }
501
502 if (!channel_found) {
503 for (i = 0; i < config->digital_pods; i++) {
504 if (state->digital_pods[i]) {
505 g_snprintf(chan_name, sizeof(chan_name), "POD%d", i);
506 g_snprintf(tmp_str, sizeof(tmp_str),
507 (*config->scpi_dialect)[SCPI_CMD_GET_SAMPLE_RATE_LIVE],
508 chan_name);
509 channel_found = TRUE;
510 break;
511 }
512 }
513 }
514
515 /* No channel is active, ask the instrument for the sample rate
516 * in single shot mode */
517 if (!channel_found) {
518 if (sr_scpi_get_float(sdi->conn,
519 (*config->scpi_dialect)[SCPI_CMD_GET_SAMPLE_RATE],
520 &tmp_float) != SR_OK)
521 return SR_ERR;
522
523 state->sample_rate = tmp_float;
524 } else {
525 if (sr_scpi_get_int(sdi->conn, tmp_str, &tmp) != SR_OK)
526 return SR_ERR;
527 state->sample_rate = tmp / (((float) (*config->timebases)[state->timebase][0] /
528 (*config->timebases)[state->timebase][1]) *
529 config->num_xdivs);
530 }
531
532 return SR_OK;
533}
534
535SR_PRIV int hmo_scope_state_get(struct sr_dev_inst *sdi)
536{
537 struct dev_context *devc;
538 struct scope_state *state;
539 const struct scope_config *config;
540 float tmp_float;
541 unsigned int i;
542 char *tmp_str;
543
544 devc = sdi->priv;
545 config = devc->model_config;
546 state = devc->model_state;
547
548 sr_info("Fetching scope state");
549
550 if (analog_channel_state_get(sdi->conn, config, state) != SR_OK)
551 return SR_ERR;
552
553 if (digital_channel_state_get(sdi->conn, config, state) != SR_OK)
554 return SR_ERR;
555
556 if (sr_scpi_get_float(sdi->conn,
557 (*config->scpi_dialect)[SCPI_CMD_GET_TIMEBASE],
558 &tmp_float) != SR_OK)
559 return SR_ERR;
560
561 if (sr_scpi_get_string(sdi->conn,
562 (*config->scpi_dialect)[SCPI_CMD_GET_TIMEBASE],
563 &tmp_str) != SR_OK)
564 return SR_ERR;
565
566 if (array_float_get(tmp_str, ARRAY_AND_SIZE(timebases), &i) != SR_OK) {
567 g_free(tmp_str);
568 sr_err("Could not determine array index for time base.");
569 return SR_ERR;
570 }
571 g_free(tmp_str);
572
573 state->timebase = i;
574
575 if (sr_scpi_get_float(sdi->conn,
576 (*config->scpi_dialect)[SCPI_CMD_GET_HORIZ_TRIGGERPOS],
577 &tmp_float) != SR_OK)
578 return SR_ERR;
579 state->horiz_triggerpos = tmp_float /
580 (((double) (*config->timebases)[state->timebase][0] /
581 (*config->timebases)[state->timebase][1]) * config->num_xdivs);
582 state->horiz_triggerpos -= 0.5;
583 state->horiz_triggerpos *= -1;
584
585 if (scope_state_get_array_option(sdi->conn,
586 (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_SOURCE],
587 config->trigger_sources, &state->trigger_source) != SR_OK)
588 return SR_ERR;
589
590 if (scope_state_get_array_option(sdi->conn,
591 (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_SLOPE],
592 config->trigger_slopes, &state->trigger_slope) != SR_OK)
593 return SR_ERR;
594
595 if (hmo_update_sample_rate(sdi) != SR_OK)
596 return SR_ERR;
597
598 sr_info("Fetching finished.");
599
600 scope_state_dump(config, state);
601
602 return SR_OK;
603}
604
605static struct scope_state *scope_state_new(const struct scope_config *config)
606{
607 struct scope_state *state;
608
609 state = g_malloc0(sizeof(struct scope_state));
610 state->analog_channels = g_malloc0_n(config->analog_channels,
611 sizeof(struct analog_channel_state));
612 state->digital_channels = g_malloc0_n(
613 config->digital_channels, sizeof(gboolean));
614 state->digital_pods = g_malloc0_n(config->digital_pods,
615 sizeof(gboolean));
616
617 return state;
618}
619
620SR_PRIV void hmo_scope_state_free(struct scope_state *state)
621{
622 g_free(state->analog_channels);
623 g_free(state->digital_channels);
624 g_free(state->digital_pods);
625 g_free(state);
626}
627
628SR_PRIV int hmo_init_device(struct sr_dev_inst *sdi)
629{
630 char tmp[25];
631 int model_index;
632 unsigned int i, j, group;
633 struct sr_channel *ch;
634 struct dev_context *devc;
635
636 devc = sdi->priv;
637 model_index = -1;
638
639 /* Find the exact model. */
640 for (i = 0; i < ARRAY_SIZE(scope_models); i++) {
641 for (j = 0; scope_models[i].name[j]; j++) {
642 if (!strcmp(sdi->model, scope_models[i].name[j])) {
643 model_index = i;
644 break;
645 }
646 }
647 if (model_index != -1)
648 break;
649 }
650
651 if (model_index == -1) {
652 sr_dbg("Unsupported HMO device.");
653 return SR_ERR_NA;
654 }
655
656 devc->analog_groups = g_malloc0(sizeof(struct sr_channel_group*) *
657 scope_models[model_index].analog_channels);
658
659 devc->digital_groups = g_malloc0(sizeof(struct sr_channel_group*) *
660 scope_models[model_index].digital_pods);
661
662 /* Add analog channels. */
663 for (i = 0; i < scope_models[model_index].analog_channels; i++) {
664 ch = sr_channel_new(sdi, i, SR_CHANNEL_ANALOG, TRUE,
665 (*scope_models[model_index].analog_names)[i]);
666
667 devc->analog_groups[i] = g_malloc0(sizeof(struct sr_channel_group));
668
669 devc->analog_groups[i]->name = g_strdup(
670 (char *)(*scope_models[model_index].analog_names)[i]);
671 devc->analog_groups[i]->channels = g_slist_append(NULL, ch);
672
673 sdi->channel_groups = g_slist_append(sdi->channel_groups,
674 devc->analog_groups[i]);
675 }
676
677 /* Add digital channel groups. */
678 for (i = 0; i < scope_models[model_index].digital_pods; i++) {
679 g_snprintf(tmp, 25, "POD%d", i);
680
681 devc->digital_groups[i] = g_malloc0(sizeof(struct sr_channel_group));
682
683 devc->digital_groups[i]->name = g_strdup(tmp);
684 sdi->channel_groups = g_slist_append(sdi->channel_groups,
685 devc->digital_groups[i]);
686 }
687
688 /* Add digital channels. */
689 for (i = 0; i < scope_models[model_index].digital_channels; i++) {
690 ch = sr_channel_new(sdi, i, SR_CHANNEL_LOGIC, TRUE,
691 (*scope_models[model_index].digital_names)[i]);
692
693 group = i / 8;
694 devc->digital_groups[group]->channels = g_slist_append(
695 devc->digital_groups[group]->channels, ch);
696 }
697
698 devc->model_config = &scope_models[model_index];
699 devc->frame_limit = 0;
700
701 if (!(devc->model_state = scope_state_new(devc->model_config)))
702 return SR_ERR_MALLOC;
703
704 return SR_OK;
705}
706
707/* Queue data of one channel group, for later submission. */
708SR_PRIV void hmo_queue_logic_data(struct dev_context *devc,
709 size_t group, GByteArray *pod_data)
710{
711 size_t size;
712 GByteArray *store;
713 uint8_t *logic_data;
714 size_t idx, logic_step;
715
716 /*
717 * Upon first invocation, allocate the array which can hold the
718 * combined logic data for all channels. Assume that each channel
719 * will yield an identical number of samples per receive call.
720 *
721 * As a poor man's safety measure: (Silently) skip processing
722 * for unexpected sample counts, and ignore samples for
723 * unexpected channel groups. Don't bother with complicated
724 * resize logic, considering that many models only support one
725 * pod, and the most capable supported models have two pods of
726 * identical size. We haven't yet seen any "odd" configuration.
727 */
728 if (!devc->logic_data) {
729 size = pod_data->len * devc->pod_count;
730 store = g_byte_array_sized_new(size);
731 memset(store->data, 0, size);
732 store = g_byte_array_set_size(store, size);
733 devc->logic_data = store;
734 } else {
735 store = devc->logic_data;
736 size = store->len / devc->pod_count;
737 if (size != pod_data->len)
738 return;
739 if (group >= devc->pod_count)
740 return;
741 }
742
743 /*
744 * Fold the data of the most recently received channel group into
745 * the storage, where data resides for all channels combined.
746 */
747 logic_data = store->data;
748 logic_data += group;
749 logic_step = devc->pod_count;
750 for (idx = 0; idx < pod_data->len; idx++) {
751 *logic_data = pod_data->data[idx];
752 logic_data += logic_step;
753 }
754}
755
756/* Submit data for all channels, after the individual groups got collected. */
757SR_PRIV void hmo_send_logic_packet(struct sr_dev_inst *sdi,
758 struct dev_context *devc)
759{
760 struct sr_datafeed_packet packet;
761 struct sr_datafeed_logic logic;
762
763 if (!devc->logic_data)
764 return;
765
766 logic.data = devc->logic_data->data;
767 logic.length = devc->logic_data->len;
768 logic.unitsize = devc->pod_count;
769
770 packet.type = SR_DF_LOGIC;
771 packet.payload = &logic;
772
773 sr_session_send(sdi, &packet);
774}
775
776/* Undo previous resource allocation. */
777SR_PRIV void hmo_cleanup_logic_data(struct dev_context *devc)
778{
779
780 if (devc->logic_data) {
781 g_byte_array_free(devc->logic_data, TRUE);
782 devc->logic_data = NULL;
783 }
784 /*
785 * Keep 'pod_count'! It's required when more frames will be
786 * received, and does not harm when kept after acquisition.
787 */
788}
789
790SR_PRIV int hmo_receive_data(int fd, int revents, void *cb_data)
791{
792 struct sr_channel *ch;
793 struct sr_dev_inst *sdi;
794 struct dev_context *devc;
795 struct scope_state *state;
796 struct sr_datafeed_packet packet;
797 GByteArray *data;
798 struct sr_datafeed_analog analog;
799 struct sr_analog_encoding encoding;
800 struct sr_analog_meaning meaning;
801 struct sr_analog_spec spec;
802 struct sr_datafeed_logic logic;
803 size_t group;
804
805 (void)fd;
806 (void)revents;
807
808 data = NULL;
809
810 if (!(sdi = cb_data))
811 return TRUE;
812
813 if (!(devc = sdi->priv))
814 return TRUE;
815
816 /* Although this is correct in general, the USBTMC libusb implementation
817 * currently does not generate an event prior to the first read. Often
818 * it is ok to start reading just after the 50ms timeout. See bug #785.
819 if (revents != G_IO_IN)
820 return TRUE;
821 */
822
823 ch = devc->current_channel->data;
824 state = devc->model_state;
825
826 /*
827 * Send "frame begin" packet upon reception of data for the
828 * first enabled channel.
829 */
830 if (devc->current_channel == devc->enabled_channels) {
831 packet.type = SR_DF_FRAME_BEGIN;
832 sr_session_send(sdi, &packet);
833 }
834
835 /*
836 * Pass on the received data of the channel(s).
837 */
838 switch (ch->type) {
839 case SR_CHANNEL_ANALOG:
840 if (sr_scpi_get_block(sdi->conn, NULL, &data) != SR_OK) {
841 if (data)
842 g_byte_array_free(data, TRUE);
843
844 return TRUE;
845 }
846
847 packet.type = SR_DF_ANALOG;
848
849 analog.data = data->data;
850 analog.num_samples = data->len / sizeof(float);
851 analog.encoding = &encoding;
852 analog.meaning = &meaning;
853 analog.spec = &spec;
854
855 encoding.unitsize = sizeof(float);
856 encoding.is_signed = TRUE;
857 encoding.is_float = TRUE;
858#ifdef WORDS_BIGENDIAN
859 encoding.is_bigendian = TRUE;
860#else
861 encoding.is_bigendian = FALSE;
862#endif
863 /* TODO: Use proper 'digits' value for this device (and its modes). */
864 encoding.digits = 2;
865 encoding.is_digits_decimal = FALSE;
866 encoding.scale.p = 1;
867 encoding.scale.q = 1;
868 encoding.offset.p = 0;
869 encoding.offset.q = 1;
870 if (state->analog_channels[ch->index].probe_unit == 'V') {
871 meaning.mq = SR_MQ_VOLTAGE;
872 meaning.unit = SR_UNIT_VOLT;
873 } else {
874 meaning.mq = SR_MQ_CURRENT;
875 meaning.unit = SR_UNIT_AMPERE;
876 }
877 meaning.mqflags = 0;
878 meaning.channels = g_slist_append(NULL, ch);
879 /* TODO: Use proper 'digits' value for this device (and its modes). */
880 spec.spec_digits = 2;
881 packet.payload = &analog;
882 sr_session_send(sdi, &packet);
883 g_slist_free(meaning.channels);
884 g_byte_array_free(data, TRUE);
885 data = NULL;
886 break;
887 case SR_CHANNEL_LOGIC:
888 if (sr_scpi_get_block(sdi->conn, NULL, &data) != SR_OK) {
889 g_free(data);
890 return TRUE;
891 }
892
893 /*
894 * If only data from the first pod is involved in the
895 * acquisition, then the raw input bytes can get passed
896 * forward for performance reasons. When the second pod
897 * is involved (either alone, or in combination with the
898 * first pod), then the received bytes need to be put
899 * into memory in such a layout that all channel groups
900 * get combined, and a unitsize larger than a single byte
901 * applies. The "queue" logic transparently copes with
902 * any such configuration. This works around the lack
903 * of support for "meaning" to logic data, which is used
904 * above for analog data.
905 */
906 if (devc->pod_count == 1) {
907 packet.type = SR_DF_LOGIC;
908 logic.data = data->data;
909 logic.length = data->len;
910 logic.unitsize = 1;
911 packet.payload = &logic;
912 sr_session_send(sdi, &packet);
913 } else {
914 group = ch->index / 8;
915 hmo_queue_logic_data(devc, group, data);
916 }
917
918 g_byte_array_free(data, TRUE);
919 data = NULL;
920 break;
921 default:
922 sr_err("Invalid channel type.");
923 break;
924 }
925
926 /*
927 * Advance to the next enabled channel. When data for all enabled
928 * channels was received, then flush potentially queued logic data,
929 * and send the "frame end" packet.
930 */
931 if (devc->current_channel->next) {
932 devc->current_channel = devc->current_channel->next;
933 hmo_request_data(sdi);
934 return TRUE;
935 }
936 hmo_send_logic_packet(sdi, devc);
937
938 /*
939 * Release the logic data storage after each frame. This copes
940 * with sample counts that differ in length per frame. -- Is
941 * this a real constraint when acquiring multiple frames with
942 * identical device settings?
943 */
944 hmo_cleanup_logic_data(devc);
945
946 packet.type = SR_DF_FRAME_END;
947 sr_session_send(sdi, &packet);
948
949 /*
950 * End of frame was reached. Stop acquisition after the specified
951 * number of frames, or continue reception by starting over at
952 * the first enabled channel.
953 */
954 if (++devc->num_frames == devc->frame_limit) {
955 sr_dev_acquisition_stop(sdi);
956 hmo_cleanup_logic_data(devc);
957 } else {
958 devc->current_channel = devc->enabled_channels;
959 hmo_request_data(sdi);
960 }
961
962 return TRUE;
963}
Hardware access and backend lib