X-Git-Url: https://sigrok.org/gitweb/?p=libsigrok.git;a=blobdiff_plain;f=src%2Fhardware%2Fscpi-pps%2Fprotocol.c;h=477175872430d7da9db7b608ff26eb72c80106f2;hp=b6049dc3f75c925e141db3e46c2e1924b3244c6d;hb=HEAD;hpb=9e45cd41fd1618238c8a3afc56d4031c984bc3c5 diff --git a/src/hardware/scpi-pps/protocol.c b/src/hardware/scpi-pps/protocol.c index b6049dc3..825fdb94 100644 --- a/src/hardware/scpi-pps/protocol.c +++ b/src/hardware/scpi-pps/protocol.c @@ -2,6 +2,7 @@ * This file is part of the libsigrok project. * * Copyright (C) 2014 Bert Vermeulen + * Copyright (C) 2019 Frank Stettner * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -17,49 +18,32 @@ * along with this program. If not, see . */ +#include #include +#include #include +#include "scpi.h" #include "protocol.h" -SR_PRIV int scpi_cmd(const struct sr_dev_inst *sdi, int command, ...) -{ - va_list args; - struct dev_context *devc; - struct sr_scpi_dev_inst *scpi; - unsigned int i; - int ret; - char *cmd; - - devc = sdi->priv; - cmd = NULL; - for (i = 0; i < devc->device->num_commands; i++) { - if (devc->device->commands[i].command == command) { - cmd = devc->device->commands[i].string; - break; - } - } - if (!cmd) { - /* Device does not implement this command, that's OK. */ - return SR_OK_CONTINUE; - } - - scpi = sdi->conn; - va_start(args, command); - ret = sr_scpi_send_variadic(scpi, cmd, args); - va_end(args); - - return ret; -} - SR_PRIV int scpi_pps_receive_data(int fd, int revents, void *cb_data) { struct dev_context *devc; + const struct scpi_pps *device; struct sr_datafeed_packet packet; struct sr_datafeed_analog analog; - const struct sr_dev_inst *sdi; - struct sr_scpi_dev_inst *scpi; - GSList *l; + struct sr_analog_encoding encoding; + struct sr_analog_meaning meaning; + struct sr_analog_spec spec; + struct sr_dev_inst *sdi; + int channel_group_cmd; + const char *channel_group_name; + struct pps_channel *pch; + const struct channel_spec *ch_spec; + int ret; float f; + GVariant *gvdata; + const GVariantType *gvtype; + int cmd; (void)fd; (void)revents; @@ -70,51 +54,100 @@ SR_PRIV int scpi_pps_receive_data(int fd, int revents, void *cb_data) if (!(devc = sdi->priv)) return TRUE; - if (devc->state == STATE_STOP) + if (!(device = devc->device)) return TRUE; - scpi = sdi->conn; - - /* Retrieve requested value for this state. */ - if (sr_scpi_get_float(scpi, NULL, &f) == SR_OK) { - packet.type = SR_DF_ANALOG; - packet.payload = &analog; - analog.channels = g_slist_append(NULL, devc->cur_channel); - analog.num_samples = 1; - if (devc->state == STATE_VOLTAGE) { - analog.mq = SR_MQ_VOLTAGE; - analog.unit = SR_UNIT_VOLT; - } else { - analog.mq = SR_MQ_CURRENT; - analog.unit = SR_UNIT_AMPERE; - } - analog.mqflags = SR_MQFLAG_DC; - analog.data = &f; - sr_session_send(sdi, &packet); - g_slist_free(analog.channels); + pch = devc->cur_acquisition_channel->priv; + + channel_group_cmd = 0; + channel_group_name = NULL; + if (g_slist_length(sdi->channel_groups) > 1) { + channel_group_cmd = SCPI_CMD_SELECT_CHANNEL; + channel_group_name = pch->hwname; } - if (devc->state == STATE_VOLTAGE) { - /* Just got voltage, request current for this channel. */ - devc->state = STATE_CURRENT; - scpi_cmd(sdi, SCPI_CMD_GET_MEAS_CURRENT, devc->cur_channel->name); - } else if (devc->state == STATE_CURRENT) { - /* - * Done with voltage and current for this channel, switch to - * the next enabled channel. - */ - do { - l = g_slist_find(sdi->channels, devc->cur_channel); - if (l->next) - devc->cur_channel = l->next->data; - else - devc->cur_channel = sdi->channels->data; - } while (!devc->cur_channel->enabled); - - /* Request voltage. */ - devc->state = STATE_VOLTAGE; - scpi_cmd(sdi, SCPI_CMD_GET_MEAS_VOLTAGE, devc->cur_channel->name); + /* + * When the current channel is the first in the array, perform the device + * specific status update first. + */ + if (devc->cur_acquisition_channel == sr_next_enabled_channel(sdi, NULL) && + device->update_status) { + device->update_status(sdi); } + if (pch->mq == SR_MQ_VOLTAGE) { + gvtype = G_VARIANT_TYPE_DOUBLE; + cmd = SCPI_CMD_GET_MEAS_VOLTAGE; + } else if (pch->mq == SR_MQ_FREQUENCY) { + gvtype = G_VARIANT_TYPE_DOUBLE; + cmd = SCPI_CMD_GET_MEAS_FREQUENCY; + } else if (pch->mq == SR_MQ_CURRENT) { + gvtype = G_VARIANT_TYPE_DOUBLE; + cmd = SCPI_CMD_GET_MEAS_CURRENT; + } else if (pch->mq == SR_MQ_POWER) { + gvtype = G_VARIANT_TYPE_DOUBLE; + cmd = SCPI_CMD_GET_MEAS_POWER; + } else { + return SR_ERR; + } + + ret = sr_scpi_cmd_resp(sdi, devc->device->commands, + channel_group_cmd, channel_group_name, &gvdata, gvtype, cmd); + + if (ret != SR_OK) + return ret; + + if (devc->channels) { + /* Dynamically-probed devices. */ + ch_spec = &devc->channels[pch->hw_output_idx]; + } else { + /* Statically-configured devices. */ + ch_spec = &devc->device->channels[pch->hw_output_idx]; + } + packet.type = SR_DF_ANALOG; + packet.payload = &analog; + /* Note: digits/spec_digits will be overridden later. */ + sr_analog_init(&analog, &encoding, &meaning, &spec, 0); + analog.meaning->channels = g_slist_append(NULL, devc->cur_acquisition_channel); + analog.num_samples = 1; + analog.meaning->mq = pch->mq; + analog.meaning->mqflags = pch->mqflags; + if (pch->mq == SR_MQ_VOLTAGE) { + analog.meaning->unit = SR_UNIT_VOLT; + analog.encoding->digits = ch_spec->voltage[4]; + analog.spec->spec_digits = ch_spec->voltage[3]; + } else if (pch->mq == SR_MQ_CURRENT) { + analog.meaning->unit = SR_UNIT_AMPERE; + analog.encoding->digits = ch_spec->current[4]; + analog.spec->spec_digits = ch_spec->current[3]; + } else if (pch->mq == SR_MQ_POWER) { + analog.meaning->unit = SR_UNIT_WATT; + analog.encoding->digits = ch_spec->power[4]; + analog.spec->spec_digits = ch_spec->power[3]; + } else if (pch->mq == SR_MQ_FREQUENCY) { + analog.meaning->unit = SR_UNIT_HERTZ; + analog.encoding->digits = ch_spec->frequency[4]; + analog.spec->spec_digits = ch_spec->frequency[3]; + } + f = (float)g_variant_get_double(gvdata); + g_variant_unref(gvdata); + analog.data = &f; + sr_session_send(sdi, &packet); + g_slist_free(analog.meaning->channels); + + /* Next channel. */ + if (g_slist_length(sdi->channels) > 1) { + devc->cur_acquisition_channel = + sr_next_enabled_channel(sdi, devc->cur_acquisition_channel); + } + + if (devc->cur_acquisition_channel == sr_next_enabled_channel(sdi, NULL)) + /* First enabled channel, so each channel has been sampled */ + sr_sw_limits_update_samples_read(&devc->limits, 1); + + /* Stop if limits have been hit. */ + if (sr_sw_limits_check(&devc->limits)) + sr_dev_acquisition_stop(sdi); + return TRUE; }