#include <scpi.h>
#include "protocol.h"
+static int set_mq_volt(struct sr_scpi_dev_inst *scpi, enum sr_mqflag flags);
+static int set_mq_amp(struct sr_scpi_dev_inst *scpi, enum sr_mqflag flags);
+static int set_mq_ohm(struct sr_scpi_dev_inst *scpi, enum sr_mqflag flags);
+
/*
- * Currently, only DC voltage and current are supported, as switching to AC or
- * AC+DC requires mq flags, which is not yet implemented.
- * Four-wire resistance measurements are not implemented (See "OHMF" command).
* The source for the frequency measurement can be either AC voltage, AC+DC
* voltage, AC current, or AC+DC current. Configuring this is not yet
* supported. For details, see "FSOURCE" command.
+ * The set_mode function is optional and can be set to NULL, but in that case
+ * a cmd string must be provided.
*/
static const struct {
enum sr_mq mq;
enum sr_unit unit;
const char *cmd;
+ int (*set_mode)(struct sr_scpi_dev_inst *scpi, enum sr_mqflag flags);
} sr_mq_to_cmd_map[] = {
- { SR_MQ_VOLTAGE, SR_UNIT_VOLT, "DCV" },
- { SR_MQ_CURRENT, SR_UNIT_AMPERE, "DCI" },
- { SR_MQ_RESISTANCE, SR_UNIT_OHM, "OHM" },
- { SR_MQ_FREQUENCY, SR_UNIT_HERTZ, "FREQ" },
+ { SR_MQ_VOLTAGE, SR_UNIT_VOLT, "DCV", set_mq_volt },
+ { SR_MQ_CURRENT, SR_UNIT_AMPERE, "DCI", set_mq_amp },
+ { SR_MQ_RESISTANCE, SR_UNIT_OHM, "OHM", set_mq_ohm },
+ { SR_MQ_FREQUENCY, SR_UNIT_HERTZ, "FREQ", NULL },
};
static const struct rear_card_info rear_card_parameters[] = {
.card_id = 0,
.name = "Rear terminals",
.cg_name = "rear",
+ .num_channels = 1,
}, {
.type = HP_44491A,
.card_id = 44491,
.name = "44491A Armature Relay Multiplexer",
.cg_name = "44491a",
+ .num_channels = 14,
}, {
.type = HP_44492A,
.card_id = 44492,
.name = "44492A Reed Relay Multiplexer",
.cg_name = "44492a",
+ .num_channels = 10,
}
};
-SR_PRIV int hp_3457a_set_mq(const struct sr_dev_inst *sdi, enum sr_mq mq)
+static int send_mq_ac_dc(struct sr_scpi_dev_inst *scpi, const char *mode,
+ enum sr_mqflag flags)
+{
+ const char *ac_flag, *dc_flag;
+
+ if (flags & ~(SR_MQFLAG_AC | SR_MQFLAG_DC))
+ return SR_ERR_NA;
+
+ ac_flag = (flags & SR_MQFLAG_AC) ? "AC" : "";
+ dc_flag = "";
+ /* Must specify DC measurement when AC flag is not given. */
+ if ((flags & SR_MQFLAG_DC) || !(flags & SR_MQFLAG_AC))
+ dc_flag = "DC";
+
+ return sr_scpi_send(scpi, "%s%s%s", ac_flag, dc_flag, mode);
+}
+
+static int set_mq_volt(struct sr_scpi_dev_inst *scpi, enum sr_mqflag flags)
+{
+ return send_mq_ac_dc(scpi, "V", flags);
+}
+
+static int set_mq_amp(struct sr_scpi_dev_inst *scpi, enum sr_mqflag flags)
+{
+ return send_mq_ac_dc(scpi, "I", flags);
+}
+
+static int set_mq_ohm(struct sr_scpi_dev_inst *scpi, enum sr_mqflag flags)
+{
+ const char *ohm_flag;
+
+ if (flags & ~(SR_MQFLAG_FOUR_WIRE))
+ return SR_ERR_NA;
+
+ ohm_flag = (flags & SR_MQFLAG_FOUR_WIRE) ? "F" : "";
+ return sr_scpi_send(scpi, "OHM%s", ohm_flag);
+}
+
+SR_PRIV int hp_3457a_set_mq(const struct sr_dev_inst *sdi, enum sr_mq mq,
+ enum sr_mqflag mq_flags)
{
int ret;
size_t i;
struct sr_scpi_dev_inst *scpi = sdi->conn;
struct dev_context *devc = sdi->priv;
+ /* No need to send command if we're not changing measurement type. */
+ if (devc->measurement_mq == mq)
+ return SR_OK;
+
for (i = 0; i < ARRAY_SIZE(sr_mq_to_cmd_map); i++) {
if (sr_mq_to_cmd_map[i].mq != mq)
continue;
- ret = sr_scpi_send(scpi, sr_mq_to_cmd_map[i].cmd);
+ if (sr_mq_to_cmd_map[i].set_mode) {
+ ret = sr_mq_to_cmd_map[i].set_mode(scpi, mq_flags);
+ } else {
+ ret = sr_scpi_send(scpi, sr_mq_to_cmd_map[i].cmd);
+ }
if (ret == SR_OK) {
devc->measurement_mq = sr_mq_to_cmd_map[i].mq;
+ devc->measurement_mq_flags = mq_flags;
devc->measurement_unit = sr_mq_to_cmd_map[i].unit;
}
return ret;
return ret;
}
+SR_PRIV int hp_3457a_select_input(const struct sr_dev_inst *sdi,
+ enum channel_conn loc)
+{
+ int ret;
+ struct sr_scpi_dev_inst *scpi = sdi->conn;
+ struct dev_context *devc = sdi->priv;
+
+ if (devc->input_loc == loc)
+ return SR_OK;
+
+ ret = sr_scpi_send(scpi, "TERM %s", (loc == CONN_FRONT) ? "FRONT": "REAR");
+ if (ret == SR_OK)
+ devc->input_loc = loc;
+
+ return ret;
+}
+
+SR_PRIV int hp_3457a_send_scan_list(const struct sr_dev_inst *sdi,
+ unsigned int *channels, size_t len)
+{
+ size_t i;
+ char chan[16], list_str[64] = "";
+
+ for (i = 0; i < len; i++) {
+ g_snprintf(chan, sizeof(chan), ",%u", channels[i]);
+ g_strlcat(list_str, chan, sizeof(list_str));
+ }
+
+ return sr_scpi_send(sdi->conn, "SLIST %s", list_str);
+}
+
/* HIRES register only contains valid data with 10 or more powerline cycles. */
static int is_highres_enabled(struct dev_context *devc)
{
return (devc->nplc >= 10.0);
}
+static void activate_next_channel(struct dev_context *devc)
+{
+ GSList *list_elem;
+ struct sr_channel *chan;
+
+ list_elem = g_slist_find(devc->active_channels, devc->current_channel);
+ if (list_elem)
+ list_elem = list_elem->next;
+ if (!list_elem)
+ list_elem = devc->active_channels;
+
+ chan = list_elem->data;
+
+ devc->current_channel = chan;
+}
+
static void retrigger_measurement(struct sr_scpi_dev_inst *scpi,
struct dev_context *devc)
{
devc->acq_state = ACQ_REQUESTED_RANGE;
}
+static void request_current_channel(struct sr_scpi_dev_inst *scpi,
+ struct dev_context *devc)
+{
+ sr_scpi_send(scpi, "CHAN?");
+ devc->acq_state = ACQ_REQUESTED_CHANNEL_SYNC;
+}
+
/*
* Calculate the number of leading zeroes in the measurement.
*
sr_analog_init(&analog, &encoding, &meaning, &spec, num_digits);
encoding.unitsize = sizeof(float);
- meaning.channels = sdi->channels;
+ meaning.channels = g_slist_append(NULL, devc->current_channel);
measurement_workaround = hires_measurement;
analog.num_samples = 1;
analog.data = &measurement_workaround;
meaning.mq = devc->measurement_mq;
+ meaning.mqflags = devc->measurement_mq_flags;
meaning.unit = devc->measurement_unit;
sr_session_send(sdi, &packet);
+
+ g_slist_free(meaning.channels);
}
+/*
+ * The scan-advance channel sync -- call to request_current_channel() -- is not
+ * necessarily needed. It is done in case we have a communication error and the
+ * DMM advances the channel without having sent the reading. The DMM only
+ * advances the channel when it thinks it sent the reading over HP-IB. Thus, on
+ * most errors we can retrigger the measurement and still be in sync. This
+ * check is done to make sure we don't fall out of sync due to obscure errors.
+ */
SR_PRIV int hp_3457a_receive_data(int fd, int revents, void *cb_data)
{
int ret;
struct sr_scpi_dev_inst *scpi;
struct dev_context *devc;
- struct sr_dev_inst *sdi = cb_data;
+ struct channel_context *chanc;
+ struct sr_dev_inst *sdi;
(void)fd;
(void)revents;
}
devc->acq_state = ACQ_GOT_MEASUREMENT;
break;
+ case ACQ_REQUESTED_CHANNEL_SYNC:
+ ret = sr_scpi_get_double(scpi, NULL, &devc->last_channel_sync);
+ if (ret != SR_OK) {
+ sr_err("Cannot check channel synchronization.");
+ sr_dev_acquisition_stop(sdi);
+ return FALSE;
+ }
+ devc->acq_state = ACQ_GOT_CHANNEL_SYNC;
+ break;
default:
return FALSE;
}
devc->num_samples++;
}
+ if (devc->acq_state == ACQ_GOT_CHANNEL_SYNC) {
+ chanc = devc->current_channel->priv;
+ if (chanc->index != devc->last_channel_sync) {
+ sr_err("Current channel and scan advance out of sync.");
+ sr_err("Expected channel %u, but device says %u",
+ chanc->index,
+ (unsigned int)devc->last_channel_sync);
+ sr_dev_acquisition_stop(sdi);
+ return FALSE;
+ }
+ /* All is good. Back to business. */
+ retrigger_measurement(scpi, devc);
+ }
+
if (devc->limit_samples && (devc->num_samples >= devc->limit_samples)) {
- sdi->driver->dev_acquisition_stop(sdi, cb_data);
+ sr_dev_acquisition_stop(sdi);
return FALSE;
}
/* Got more to go. */
if (devc->acq_state == ACQ_GOT_MEASUREMENT) {
- /* Retrigger */
- retrigger_measurement(scpi, devc);
+ activate_next_channel(devc);
+ /* Retrigger, or check if scan-advance is in sync. */
+ if (((devc->num_samples % 10) == 9)
+ && (devc->num_active_channels > 1)) {
+ request_current_channel(scpi, devc);
+ } else {
+ retrigger_measurement(scpi, devc);
+ }
}
return TRUE;
projects / libsigrok.git / blobdiff