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 int set_mq_volt(struct sr_scpi_dev_inst *scpi, enum sr_mqflag flags);
26 static int set_mq_amp(struct sr_scpi_dev_inst *scpi, enum sr_mqflag flags);
27 static int set_mq_ohm(struct sr_scpi_dev_inst *scpi, enum sr_mqflag flags);
30 * The source for the frequency measurement can be either AC voltage, AC+DC
31 * voltage, AC current, or AC+DC current. Configuring this is not yet
32 * supported. For details, see "FSOURCE" command.
33 * The set_mode function is optional and can be set to NULL, but in that case
34 * a cmd string must be provided.
40 int (*set_mode)(struct sr_scpi_dev_inst *scpi, enum sr_mqflag flags);
41 } sr_mq_to_cmd_map[] = {
42 { SR_MQ_VOLTAGE, SR_UNIT_VOLT, "DCV", set_mq_volt },
43 { SR_MQ_CURRENT, SR_UNIT_AMPERE, "DCI", set_mq_amp },
44 { SR_MQ_RESISTANCE, SR_UNIT_OHM, "OHM", set_mq_ohm },
45 { SR_MQ_FREQUENCY, SR_UNIT_HERTZ, "FREQ", NULL },
48 static const struct rear_card_info rear_card_parameters[] = {
50 .type = REAR_TERMINALS,
52 .name = "Rear terminals",
58 .name = "44491A Armature Relay Multiplexer",
64 .name = "44492A Reed Relay Multiplexer",
70 static int send_mq_ac_dc(struct sr_scpi_dev_inst *scpi, const char *mode,
73 const char *ac_flag, *dc_flag;
75 if (flags & ~(SR_MQFLAG_AC | SR_MQFLAG_DC))
78 ac_flag = (flags & SR_MQFLAG_AC) ? "AC" : "";
80 /* Must specify DC measurement when AC flag is not given. */
81 if ((flags & SR_MQFLAG_DC) || !(flags & SR_MQFLAG_AC))
84 return sr_scpi_send(scpi, "%s%s%s", ac_flag, dc_flag, mode);
87 static int set_mq_volt(struct sr_scpi_dev_inst *scpi, enum sr_mqflag flags)
89 return send_mq_ac_dc(scpi, "V", flags);
92 static int set_mq_amp(struct sr_scpi_dev_inst *scpi, enum sr_mqflag flags)
94 return send_mq_ac_dc(scpi, "I", flags);
97 static int set_mq_ohm(struct sr_scpi_dev_inst *scpi, enum sr_mqflag flags)
101 if (flags & ~(SR_MQFLAG_FOUR_WIRE))
104 ohm_flag = (flags & SR_MQFLAG_FOUR_WIRE) ? "F" : "";
105 return sr_scpi_send(scpi, "OHM%s", ohm_flag);
108 SR_PRIV int hp_3457a_set_mq(const struct sr_dev_inst *sdi, enum sr_mq mq,
109 enum sr_mqflag mq_flags)
113 struct sr_scpi_dev_inst *scpi = sdi->conn;
114 struct dev_context *devc = sdi->priv;
116 /* No need to send command if we're not changing measurement type. */
117 if (devc->measurement_mq == mq)
120 for (i = 0; i < ARRAY_SIZE(sr_mq_to_cmd_map); i++) {
121 if (sr_mq_to_cmd_map[i].mq != mq)
123 if (sr_mq_to_cmd_map[i].set_mode) {
124 ret = sr_mq_to_cmd_map[i].set_mode(scpi, mq_flags);
126 ret = sr_scpi_send(scpi, sr_mq_to_cmd_map[i].cmd);
129 devc->measurement_mq = sr_mq_to_cmd_map[i].mq;
130 devc->measurement_mq_flags = mq_flags;
131 devc->measurement_unit = sr_mq_to_cmd_map[i].unit;
139 SR_PRIV const struct rear_card_info *hp_3457a_probe_rear_card(struct sr_scpi_dev_inst *scpi)
143 unsigned int card_id;
144 const struct rear_card_info *rear_card = NULL;
146 if (sr_scpi_get_float(scpi, "OPT?", &card_fval) != SR_OK)
149 card_id = (unsigned int)card_fval;
151 for (i = 0; i < ARRAY_SIZE(rear_card_parameters); i++) {
152 if (rear_card_parameters[i].card_id == card_id) {
153 rear_card = rear_card_parameters + i;
161 sr_info("Found %s.", rear_card->name);
166 SR_PRIV int hp_3457a_set_nplc(const struct sr_dev_inst *sdi, float nplc)
169 struct sr_scpi_dev_inst *scpi = sdi->conn;
170 struct dev_context *devc = sdi->priv;
172 if ((nplc < 1E-6) || (nplc > 100))
175 /* Only need one digit of precision here. */
176 ret = sr_scpi_send(scpi, "NPLC %.0E", nplc);
179 * The instrument only has a few valid NPLC setting, so get back the
180 * one which was selected.
182 sr_scpi_get_float(scpi, "NPLC?", &devc->nplc);
187 SR_PRIV int hp_3457a_select_input(const struct sr_dev_inst *sdi,
188 enum channel_conn loc)
191 struct sr_scpi_dev_inst *scpi = sdi->conn;
192 struct dev_context *devc = sdi->priv;
194 if (devc->input_loc == loc)
197 ret = sr_scpi_send(scpi, "TERM %s", (loc == CONN_FRONT) ? "FRONT": "REAR");
199 devc->input_loc = loc;
204 SR_PRIV int hp_3457a_send_scan_list(const struct sr_dev_inst *sdi,
205 unsigned int *channels, size_t len)
208 char chan[16], list_str[64] = "";
210 for (i = 0; i < len; i++) {
211 g_snprintf(chan, sizeof(chan), ",%u", channels[i]);
212 g_strlcat(list_str, chan, sizeof(list_str));
215 return sr_scpi_send(sdi->conn, "SLIST %s", list_str);
218 /* HIRES register only contains valid data with 10 or more powerline cycles. */
219 static int is_highres_enabled(struct dev_context *devc)
221 return (devc->nplc >= 10.0);
224 static void activate_next_channel(struct dev_context *devc)
227 struct sr_channel *chan;
229 list_elem = g_slist_find(devc->active_channels, devc->current_channel);
231 list_elem = list_elem->next;
233 list_elem = devc->active_channels;
235 chan = list_elem->data;
237 devc->current_channel = chan;
240 static void retrigger_measurement(struct sr_scpi_dev_inst *scpi,
241 struct dev_context *devc)
243 sr_scpi_send(scpi, "?");
244 devc->acq_state = ACQ_TRIGGERED_MEASUREMENT;
247 static void request_hires(struct sr_scpi_dev_inst *scpi,
248 struct dev_context *devc)
250 sr_scpi_send(scpi, "RMATH HIRES");
251 devc->acq_state = ACQ_REQUESTED_HIRES;
254 static void request_range(struct sr_scpi_dev_inst *scpi,
255 struct dev_context *devc)
257 sr_scpi_send(scpi, "RANGE?");
258 devc->acq_state = ACQ_REQUESTED_RANGE;
261 static void request_current_channel(struct sr_scpi_dev_inst *scpi,
262 struct dev_context *devc)
264 sr_scpi_send(scpi, "CHAN?");
265 devc->acq_state = ACQ_REQUESTED_CHANNEL_SYNC;
269 * Calculate the number of leading zeroes in the measurement.
271 * Depending on the range and measurement, a reading may not have eight digits
272 * of resolution. For example, on a 30V range:
273 * : 10.000000 V has 8 significant digits
274 * : 9.999999 V has 7 significant digits
275 * : 0.999999 V has 6 significant digits
277 * The number of significant digits is determined based on the range in which
278 * the measurement was taken:
279 * 1. By taking the base 10 logarithm of the range, and converting that to
280 * an integer, we can get the minimum reading which has a full resolution
281 * reading. Raising 10 to the integer power gives the full resolution.
282 * Ex: For 30 V range, a full resolution reading is 10.000000.
283 * 2. A ratio is taken between the full resolution reading and the
284 * measurement. Since the full resolution reading is a power of 10,
285 * for every leading zero, this ratio will be slightly higher than a
286 * power of 10. For example, for 10 V full resolution:
287 * : 10.000000 V, ratio = 1.0000000
288 * : 9.999999 V, ratio = 1.0000001
289 * : 0.999999 V, ratio = 10.000001
290 * 3. The ratio is rounded up to prevent loss of precision in the next step.
291 * 4. The base 10 logarithm of the ratio is taken, then rounded up. This
292 * gives the number of leading zeroes in the measurement.
293 * For example, for 10 V full resolution:
294 * : 10.000000 V, ceil(1.0000000) = 1, log10 = 0.00; 0 leading zeroes
295 * : 9.999999 V, ceil(1.0000001) = 2, log10 = 0.30; 1 leading zero
296 * : 0.999999 V, ceil(10.000001) = 11, log10 = 1.04, 2 leading zeroes
297 * 5. The number of leading zeroes is subtracted from the maximum number of
298 * significant digits, 8, at 7 1/2 digits resolution.
299 * For a 10 V full resolution reading, this gives:
300 * : 10.000000 V, 0 leading zeroes => 8 significant digits
301 * : 9.999999 V, 1 leading zero => 7 significant digits
302 * : 0.999999 V, 2 leading zeroes => 6 significant digits
304 * Single precision floating point numbers can achieve about 16 million counts,
305 * but in high resolution mode we can get as much as 30 million counts. As a
306 * result, these calculations must be done with double precision
307 * (the HP 3457A is a very precise instrument).
309 static int calculate_num_zero_digits(double measurement, double range)
312 double min_full_res_reading, log10_range, full_res_ratio;
314 log10_range = log10(range);
315 min_full_res_reading = pow(10, (int)log10_range);
316 if (measurement > min_full_res_reading) {
318 } else if (measurement == 0.0) {
321 full_res_ratio = min_full_res_reading / measurement;
322 zero_digits = ceil(log10(ceil(full_res_ratio)));
329 * Until the output modules understand double precision data, we need to send
330 * the measurement as floats instead of doubles, hence, the dance with
331 * measurement_workaround double to float conversion.
332 * See bug #779 for details.
333 * The workaround should be removed once the output modules are fixed.
335 static void acq_send_measurement(struct sr_dev_inst *sdi)
337 double hires_measurement;
338 float measurement_workaround;
339 int zero_digits, num_digits;
340 struct sr_datafeed_packet packet;
341 struct sr_datafeed_analog analog;
342 struct sr_analog_encoding encoding;
343 struct sr_analog_meaning meaning;
344 struct sr_analog_spec spec;
345 struct dev_context *devc = sdi->priv;
347 hires_measurement = devc->base_measurement;
348 if (is_highres_enabled(devc))
349 hires_measurement += devc->hires_register;
351 /* Figure out how many of the digits are significant. */
352 num_digits = is_highres_enabled(devc) ? 8 : 7;
353 zero_digits = calculate_num_zero_digits(hires_measurement,
354 devc->measurement_range);
355 num_digits = num_digits - zero_digits;
357 packet.type = SR_DF_ANALOG;
358 packet.payload = &analog;
360 sr_analog_init(&analog, &encoding, &meaning, &spec, num_digits);
361 encoding.unitsize = sizeof(float);
363 meaning.channels = g_slist_append(NULL, devc->current_channel);
365 measurement_workaround = hires_measurement;
366 analog.num_samples = 1;
367 analog.data = &measurement_workaround;
369 meaning.mq = devc->measurement_mq;
370 meaning.mqflags = devc->measurement_mq_flags;
371 meaning.unit = devc->measurement_unit;
373 sr_session_send(sdi, &packet);
375 g_slist_free(meaning.channels);
379 * The scan-advance channel sync -- call to request_current_channel() -- is not
380 * necessarily needed. It is done in case we have a communication error and the
381 * DMM advances the channel without having sent the reading. The DMM only
382 * advances the channel when it thinks it sent the reading over HP-IB. Thus, on
383 * most errors we can retrigger the measurement and still be in sync. This
384 * check is done to make sure we don't fall out of sync due to obscure errors.
386 SR_PRIV int hp_3457a_receive_data(int fd, int revents, void *cb_data)
389 struct sr_scpi_dev_inst *scpi;
390 struct dev_context *devc;
391 struct channel_context *chanc;
392 struct sr_dev_inst *sdi;
397 if (!(sdi = cb_data))
400 if (!(devc = sdi->priv))
405 switch (devc->acq_state) {
406 case ACQ_TRIGGERED_MEASUREMENT:
407 ret = sr_scpi_get_double(scpi, NULL, &devc->base_measurement);
409 retrigger_measurement(scpi, devc);
413 if (is_highres_enabled(devc))
414 request_hires(scpi, devc);
416 request_range(scpi, devc);
419 case ACQ_REQUESTED_HIRES:
420 ret = sr_scpi_get_double(scpi, NULL, &devc->hires_register);
422 retrigger_measurement(scpi, devc);
425 request_range(scpi, devc);
427 case ACQ_REQUESTED_RANGE:
428 ret = sr_scpi_get_double(scpi, NULL, &devc->measurement_range);
430 retrigger_measurement(scpi, devc);
433 devc->acq_state = ACQ_GOT_MEASUREMENT;
435 case ACQ_REQUESTED_CHANNEL_SYNC:
436 ret = sr_scpi_get_double(scpi, NULL, &devc->last_channel_sync);
438 sr_err("Cannot check channel synchronization.");
439 sr_dev_acquisition_stop(sdi);
442 devc->acq_state = ACQ_GOT_CHANNEL_SYNC;
448 if (devc->acq_state == ACQ_GOT_MEASUREMENT) {
449 acq_send_measurement(sdi);
453 if (devc->acq_state == ACQ_GOT_CHANNEL_SYNC) {
454 chanc = devc->current_channel->priv;
455 if (chanc->index != devc->last_channel_sync) {
456 sr_err("Current channel and scan advance out of sync.");
457 sr_err("Expected channel %u, but device says %u",
459 (unsigned int)devc->last_channel_sync);
460 sr_dev_acquisition_stop(sdi);
463 /* All is good. Back to business. */
464 retrigger_measurement(scpi, devc);
467 if (devc->limit_samples && (devc->num_samples >= devc->limit_samples)) {
468 sr_dev_acquisition_stop(sdi);
472 /* Got more to go. */
473 if (devc->acq_state == ACQ_GOT_MEASUREMENT) {
474 activate_next_channel(devc);
475 /* Retrigger, or check if scan-advance is in sync. */
476 if (((devc->num_samples % 10) == 9)
477 && (devc->num_active_channels > 1)) {
478 request_current_channel(scpi, devc);
480 retrigger_measurement(scpi, devc);