X-Git-Url: https://sigrok.org/gitweb/?p=libsigrok.git;a=blobdiff_plain;f=src%2Fhardware%2Fscpi-pps%2Fprotocol.c;h=825fdb945257a32b62eaadc36f8f7d57fee1534b;hp=be4788600ef7ab72aedb216edba440810961bca1;hb=c54b3726418c8211bf9cb19323b5ba09ad409e1c;hpb=329733d92c5004f0fe308eff26b9537fded2cdf3 diff --git a/src/hardware/scpi-pps/protocol.c b/src/hardware/scpi-pps/protocol.c index be478860..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,171 +18,31 @@ * along with this program. If not, see . */ +#include #include +#include #include +#include "scpi.h" #include "protocol.h" -SR_PRIV const char *scpi_cmd_get(const struct sr_dev_inst *sdi, int command) -{ - struct dev_context *devc; - unsigned int i; - const 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; - } - } - - return cmd; -} - -SR_PRIV int scpi_cmd(const struct sr_dev_inst *sdi, int command, ...) -{ - struct sr_scpi_dev_inst *scpi; - va_list args; - int ret; - const char *cmd; - - if (!(cmd = scpi_cmd_get(sdi, command))) { - /* 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_cmd_resp(const struct sr_dev_inst *sdi, GVariant **gvar, - const GVariantType *gvtype, int command, ...) -{ - struct sr_scpi_dev_inst *scpi; - va_list args; - double d; - int ret; - char *s; - const char *cmd; - - if (!(cmd = scpi_cmd_get(sdi, command))) { - /* 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); - if (ret != SR_OK) - return ret; - - /* Non-standard data type responses. */ - if (command == SCPI_CMD_GET_OUTPUT_REGULATION) { - /* - * The Rigol DP800 series return CV/CC/UR, Philips PM2800 - * return VOLT/CURR. We always return a GVariant string in - * the Rigol notation. - */ - if ((ret = sr_scpi_get_string(scpi, NULL, &s)) != SR_OK) - return ret; - if (!strcmp(s, "CV") || !strcmp(s, "VOLT")) { - *gvar = g_variant_new_string("CV"); - } else if (!strcmp(s, "CC") || !strcmp(s, "CURR")) { - *gvar = g_variant_new_string("CC"); - } else if (!strcmp(s, "UR")) { - *gvar = g_variant_new_string("UR"); - } else { - sr_dbg("Unknown response to SCPI_CMD_GET_OUTPUT_REGULATION: %s", s); - ret = SR_ERR_DATA; - } - g_free(s); - } else { - /* Straight SCPI getters to GVariant types. */ - if (g_variant_type_equal(gvtype, G_VARIANT_TYPE_BOOLEAN)) { - if ((ret = sr_scpi_get_string(scpi, NULL, &s)) != SR_OK) - return ret; - if (!strcasecmp(s, "ON") || !strcasecmp(s, "1") || !strcasecmp(s, "YES")) - *gvar = g_variant_new_boolean(TRUE); - else if (!strcasecmp(s, "OFF") || !strcasecmp(s, "0") || !strcasecmp(s, "NO")) - *gvar = g_variant_new_boolean(FALSE); - else - ret = SR_ERR; - g_free(s); - } if (g_variant_type_equal(gvtype, G_VARIANT_TYPE_DOUBLE)) { - if ((ret = sr_scpi_get_double(scpi, NULL, &d)) == SR_OK) - *gvar = g_variant_new_double(d); - } if (g_variant_type_equal(gvtype, G_VARIANT_TYPE_STRING)) { - if ((ret = sr_scpi_get_string(scpi, NULL, &s)) == SR_OK) - *gvar = g_variant_new_string(s); - } - } - - return ret; -} - -SR_PRIV int select_channel(const struct sr_dev_inst *sdi, struct sr_channel *ch) -{ - struct dev_context *devc; - struct pps_channel *cur_pch, *new_pch; - int ret; - - if (g_slist_length(sdi->channels) == 1) - return SR_OK; - - devc = sdi->priv; - if (ch == devc->cur_channel) - return SR_OK; - - new_pch = ch->priv; - if (devc->cur_channel) { - cur_pch = devc->cur_channel->priv; - if (cur_pch->hw_output_idx == new_pch->hw_output_idx) { - /* Same underlying output channel. */ - devc->cur_channel = ch; - return SR_OK; - } - } - - if ((ret = scpi_cmd(sdi, SCPI_CMD_SELECT_CHANNEL, new_pch->hwname)) == SR_OK) - devc->cur_channel = ch; - - return ret; -} - -SR_PRIV struct sr_channel *next_enabled_channel(const struct sr_dev_inst *sdi, - struct sr_channel *cur_channel) -{ - struct sr_channel *next_channel; - GSList *l; - - next_channel = cur_channel; - do { - l = g_slist_find(sdi->channels, next_channel); - if (l && l->next) - next_channel = l->next->data; - else - next_channel = sdi->channels->data; - } while (!next_channel->enabled); - - return next_channel; -} - 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_channel *next_channel; - struct sr_scpi_dev_inst *scpi; + 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; @@ -193,46 +54,100 @@ SR_PRIV int scpi_pps_receive_data(int fd, int revents, void *cb_data) if (!(devc = sdi->priv)) return TRUE; - scpi = sdi->conn; - - /* Retrieve requested value for this state. */ - if (sr_scpi_get_float(scpi, NULL, &f) == SR_OK) { - pch = devc->cur_channel->priv; - packet.type = SR_DF_ANALOG; - packet.payload = &analog; - analog.channels = g_slist_append(NULL, devc->cur_channel); - analog.num_samples = 1; - analog.mq = pch->mq; - if (pch->mq == SR_MQ_VOLTAGE) - analog.unit = SR_UNIT_VOLT; - else if (pch->mq == SR_MQ_CURRENT) - analog.unit = SR_UNIT_AMPERE; - else if (pch->mq == SR_MQ_POWER) - analog.unit = SR_UNIT_WATT; - analog.mqflags = SR_MQFLAG_DC; - analog.data = &f; - sr_session_send(sdi, &packet); - g_slist_free(analog.channels); + if (!(device = devc->device)) + return TRUE; + + 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 (g_slist_length(sdi->channels) > 1) { - next_channel = next_enabled_channel(sdi, devc->cur_channel); - if (select_channel(sdi, next_channel) != SR_OK) { - sr_err("Failed to select channel %s", next_channel->name); - return FALSE; - } + /* + * 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); } - pch = devc->cur_channel->priv; - if (pch->mq == SR_MQ_VOLTAGE) + if (pch->mq == SR_MQ_VOLTAGE) { + gvtype = G_VARIANT_TYPE_DOUBLE; cmd = SCPI_CMD_GET_MEAS_VOLTAGE; - else if (pch->mq == SR_MQ_CURRENT) + } 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) + } else if (pch->mq == SR_MQ_POWER) { + gvtype = G_VARIANT_TYPE_DOUBLE; cmd = SCPI_CMD_GET_MEAS_POWER; - else + } else { return SR_ERR; - scpi_cmd(sdi, cmd); + } + + 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; }