2 * This file is part of the libsigrok project.
4 * Copyright (C) 2016 Alexandru Gagniuc <mr.nuke.me@gmail.com>
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.
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.
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/>.
25 static const uint32_t scanopts[] = {
29 static const uint32_t drvopts[] = {
33 static const uint32_t devopts[] = {
35 SR_CONF_LIMIT_SAMPLES | SR_CONF_SET,
36 SR_CONF_MEASURED_QUANTITY | SR_CONF_SET,
37 SR_CONF_ADC_POWERLINE_CYCLES | SR_CONF_SET | SR_CONF_GET,
40 static struct sr_dev_driver hp_3457a_driver_info;
42 static int create_front_channel(struct sr_dev_inst *sdi, int chan_idx)
44 struct sr_channel *channel;
45 struct sr_channel_group *front;
46 struct channel_context *chanc;
48 chanc = g_malloc(sizeof(*chanc));
49 chanc->location = CONN_FRONT;
51 channel = sr_channel_new(sdi, chan_idx++, SR_CHANNEL_ANALOG,
53 channel->priv = chanc;
55 front = g_malloc0(sizeof(*front));
56 front->name = g_strdup("Front");
57 front->channels = g_slist_append(front->channels, channel);
59 sdi->channel_groups = g_slist_append(sdi->channel_groups, front);
64 static int create_rear_channels(struct sr_dev_inst *sdi, int chan_idx,
65 const struct rear_card_info *card)
68 struct sr_channel *channel;
69 struct sr_channel_group *group;
70 struct channel_context *chanc;
73 /* When card is NULL, we couldn't identify the type of card. */
77 group = g_malloc0(sizeof(*group));
79 group->name = g_strdup(card->cg_name);
80 sdi->channel_groups = g_slist_append(sdi->channel_groups, group);
82 for (i = 0; i < card->num_channels; i++) {
84 chanc = g_malloc(sizeof(*chanc));
85 chanc->location = CONN_REAR;
87 if (card->type == REAR_TERMINALS) {
89 g_snprintf(name, sizeof(name), "%s", card->cg_name);
92 g_snprintf(name, sizeof(name), "%s%u", card->cg_name, i);
95 channel = sr_channel_new(sdi, chan_idx++, SR_CHANNEL_ANALOG,
97 channel->priv = chanc;
98 group->channels = g_slist_append(group->channels, channel);
104 static gchar *get_revision(struct sr_scpi_dev_inst *scpi)
106 int ret, major, minor;
109 /* Report a version of '0.0' if we can't parse the response. */
112 ret = sr_scpi_get_floatv(scpi, "REV?", &rev_numbers);
113 if ((ret == SR_OK) && (rev_numbers->len >= 2)) {
114 major = (int)g_array_index(rev_numbers, float, 0);
115 minor = (int)g_array_index(rev_numbers, float, 1);
118 g_array_free(rev_numbers, TRUE);
120 return g_strdup_printf("%d.%d", major, minor);
123 static struct sr_dev_inst *probe_device(struct sr_scpi_dev_inst *scpi)
127 struct sr_dev_inst *sdi;
128 struct dev_context *devc;
131 * The device cannot get identified by means of SCPI queries.
132 * Neither shall non-SCPI requests get emitted before reliable
133 * identification of the device. Assume that we only get here
134 * when user specs led us to believe it's safe to communicate
135 * to the expected kind of device.
139 * This command ensures we receive an EOI after every response, so that
140 * we don't wait the entire timeout after the response is received.
142 if (sr_scpi_send(scpi, "END ALWAYS") != SR_OK)
145 ret = sr_scpi_get_string(scpi, "ID?", &response);
146 if ((ret != SR_OK) || !response)
149 if (strcmp(response, "HP3457A") != 0) {
156 devc = g_malloc0(sizeof(*devc));
157 sdi = g_malloc0(sizeof(*sdi));
158 sdi->vendor = g_strdup("Hewlett-Packard");
159 sdi->model = g_strdup("3457A");
160 sdi->version = get_revision(scpi);
162 sdi->driver = &hp_3457a_driver_info;
163 sdi->inst_type = SR_INST_SCPI;
166 /* There is no way to probe the measurement mode. It must be set. */
167 devc->measurement_mq = 0;
168 devc->measurement_unit = 0;
170 /* Probe rear card option and create channels accordingly (TODO). */
171 devc->rear_card = hp_3457a_probe_rear_card(scpi);
173 idx = create_front_channel(sdi, idx);
174 create_rear_channels(sdi, idx, devc->rear_card);
179 static GSList *scan(struct sr_dev_driver *di, GSList *options)
183 /* Only scan for a device when conn= was specified. */
185 (void)sr_serial_extract_options(options, &conn, NULL);
189 return sr_scpi_scan(di->context, options, probe_device);
193 * We need to set the HP 3457A to a known state, and there are quite a number
194 * of knobs to tweak. Here's a brief explanation of what's going on. For more
195 * details, print out and consult the user manual.
197 * Set the instrument to a pre-determined state. This is easier and faster
198 * than sending a few dozen commands. Some of the PRESET defaults include
199 * ASCII output format, and synchronous triggering. See user manual for
202 * After the PRESET command, the instrument is in a known state, and only those
203 * parameters for which the default is unsuitable are modified:
205 * Enable the HP-IB input buffer. This allows the instrument to release the
206 * HP-IB bus before processing the command, and increases throughput on
207 * GPIB buses with more than one device.
209 * Do not trigger new measurements until instructed to do so.
211 static int dev_open(struct sr_dev_inst *sdi)
213 struct sr_scpi_dev_inst *scpi = sdi->conn;
214 struct dev_context *devc;
216 if (sr_scpi_open(scpi) != SR_OK)
221 sr_scpi_send(scpi, "PRESET");
222 sr_scpi_send(scpi, "INBUF ON");
223 sr_scpi_send(scpi, "TRIG HOLD");
224 sr_scpi_get_float(scpi, "NPLC?", &devc->nplc);
229 static int dev_close(struct sr_dev_inst *sdi)
231 struct sr_scpi_dev_inst *scpi = sdi->conn;
233 /* Disable scan-advance (preserve relay life). */
234 sr_scpi_send(scpi, "SADV HOLD");
235 /* Switch back to auto-triggering. */
236 sr_scpi_send(scpi, "TRIG AUTO");
243 static int config_get(uint32_t key, GVariant **data,
244 const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
246 struct dev_context *devc;
253 case SR_CONF_ADC_POWERLINE_CYCLES:
254 *data = g_variant_new_double(devc->nplc);
263 static int config_set(uint32_t key, GVariant *data,
264 const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
267 enum sr_mqflag mq_flags;
268 struct dev_context *devc;
269 GVariant *tuple_child;
276 case SR_CONF_LIMIT_SAMPLES:
277 devc->limit_samples = g_variant_get_uint64(data);
279 case SR_CONF_MEASURED_QUANTITY:
280 tuple_child = g_variant_get_child_value(data, 0);
281 mq = g_variant_get_uint32(tuple_child);
282 tuple_child = g_variant_get_child_value(data, 1);
283 mq_flags = g_variant_get_uint64(tuple_child);
284 g_variant_unref(tuple_child);
285 return hp_3457a_set_mq(sdi, mq, mq_flags);
286 case SR_CONF_ADC_POWERLINE_CYCLES:
287 return hp_3457a_set_nplc(sdi, g_variant_get_double(data));
295 static int config_list(uint32_t key, GVariant **data,
296 const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
299 * TODO: Implement channel group configuration when adding support for
303 return STD_CONFIG_LIST(key, data, sdi, cg, scanopts, drvopts, devopts);
306 static void create_channel_index_list(GSList *channels, GArray **arr)
308 struct sr_channel *channel;
309 struct channel_context *chanc;
312 *arr = g_array_new(FALSE, FALSE, sizeof(unsigned int));
314 for (list_elem = channels; list_elem; list_elem = list_elem->next) {
315 channel = list_elem->data;
316 chanc = channel->priv;
317 g_array_append_val(*arr, chanc->index);
323 * Trigger the first measurement, then hold. We can't let the instrument
324 * auto-trigger because we read several registers to make a complete
325 * reading. If the instrument were auto-triggering, we could get the
326 * reading for sample N, but a new measurement is made and when we read the
327 * HIRES register, it contains data for sample N+1. This would produce
330 * Activate the scan-advance feature. This automatically connects the next
331 * channel in the scan list to the A/D converter. This way, we do not need to
332 * occupy the HP-IB bus to send channel select commands.
334 static int dev_acquisition_start(const struct sr_dev_inst *sdi)
337 gboolean front_selected, rear_selected;
338 struct sr_scpi_dev_inst *scpi;
339 struct sr_channel *channel;
340 struct dev_context *devc;
341 struct channel_context *chanc;
348 ret = sr_scpi_source_add(sdi->session, scpi, G_IO_IN, 100,
349 hp_3457a_receive_data, (void *)sdi);
353 std_session_send_df_header(sdi);
355 front_selected = rear_selected = FALSE;
356 devc->active_channels = NULL;
358 for (channels = sdi->channels; channels; channels = channels->next) {
359 channel = channels->data;
361 if (!channel->enabled)
364 chanc = channel->priv;
366 if (chanc->location == CONN_FRONT)
367 front_selected = TRUE;
368 if (chanc->location == CONN_REAR)
369 rear_selected = TRUE;
371 devc->active_channels = g_slist_append(devc->active_channels, channel);
374 if (front_selected && rear_selected) {
375 sr_err("Can not use front and rear channels at the same time!");
376 g_slist_free(devc->active_channels);
380 devc->num_active_channels = g_slist_length(devc->active_channels);
381 if (!devc->num_active_channels) {
382 sr_err("Need at least one active channel!");
383 g_slist_free(devc->active_channels);
386 devc->current_channel = devc->active_channels->data;
388 hp_3457a_select_input(sdi, front_selected ? CONN_FRONT : CONN_REAR);
390 /* For plug-in cards, use the scan-advance features to scan channels. */
391 if (rear_selected && (devc->rear_card->card_id != REAR_TERMINALS)) {
392 create_channel_index_list(devc->active_channels, &ch_list);
393 hp_3457a_send_scan_list(sdi, (void *)ch_list->data, ch_list->len);
394 sr_scpi_send(scpi, "SADV AUTO");
395 g_array_free(ch_list, TRUE);
398 /* Start first measurement. */
399 sr_scpi_send(scpi, "TRIG SGL");
400 devc->acq_state = ACQ_TRIGGERED_MEASUREMENT;
401 devc->num_samples = 0;
406 static int dev_acquisition_stop(struct sr_dev_inst *sdi)
408 struct dev_context *devc;
412 g_slist_free(devc->active_channels);
417 static struct sr_dev_driver hp_3457a_driver_info = {
419 .longname = "HP 3457A",
422 .cleanup = std_cleanup,
424 .dev_list = std_dev_list,
425 .dev_clear = std_dev_clear,
426 .config_get = config_get,
427 .config_set = config_set,
428 .config_list = config_list,
429 .dev_open = dev_open,
430 .dev_close = dev_close,
431 .dev_acquisition_start = dev_acquisition_start,
432 .dev_acquisition_stop = dev_acquisition_stop,
435 SR_REGISTER_DEV_DRIVER(hp_3457a_driver_info);