#define SCPI_READ_RETRY_TIMEOUT_US (10 * 1000)
static const char *scpi_vendors[][2] = {
- { "HEWLETT-PACKARD", "HP" },
{ "Agilent Technologies", "Agilent" },
- { "RIGOL TECHNOLOGIES", "Rigol" },
- { "PHILIPS", "Philips" },
{ "CHROMA", "Chroma" },
{ "Chroma ATE", "Chroma" },
+ { "HEWLETT-PACKARD", "HP" },
+ { "Keysight Technologies", "Keysight" },
+ { "PHILIPS", "Philips" },
+ { "RIGOL TECHNOLOGIES", "Rigol" },
};
/**
#ifdef HAVE_LIBGPIB
&scpi_libgpib_dev,
#endif
-#ifdef HAVE_LIBSERIALPORT
+#ifdef HAVE_SERIAL_COMM
&scpi_serial_dev, /* Must be last as it matches any resource. */
#endif
};
/* Get length of buffer required. */
va_copy(args_copy, args);
- len = vsnprintf(NULL, 0, format, args_copy);
+ len = sr_vsnprintf_ascii(NULL, 0, format, args_copy);
va_end(args_copy);
/* Allocate buffer and write out command. */
buf = g_malloc0(len + 2);
- vsprintf(buf, format, args);
+ sr_vsprintf_ascii(buf, format, args);
if (buf[len - 1] != '\n')
buf[len] = '\n';
*
* @return SR_OK on success, SR_ERR on failure.
*/
-static int scpi_send(struct sr_scpi_dev_inst *scpi, const char *format,
- va_list args)
+static int scpi_send(struct sr_scpi_dev_inst *scpi, const char *format, ...)
{
- return scpi_send_variadic(scpi, format, args);
+ va_list args;
+ int ret;
+
+ va_start(args, format);
+ ret = scpi_send_variadic(scpi, format, args);
+ va_end(args);
+
+ return ret;
}
/**
GString *response;
int space;
gint64 timeout;
- va_list empty_va_list;
/* Optionally send caller provided command. */
if (command) {
- if (scpi_send(scpi, command, empty_va_list) != SR_OK)
+ if (scpi_send(scpi, command) != SR_OK)
return SR_ERR;
}
return scpi->open(scpi);
}
+/**
+ * Get the connection ID of the SCPI device.
+ *
+ * Callers must free the allocated memory regardless of the routine's
+ * return code. See @ref g_free().
+ *
+ * @param[in] scpi Previously initialized SCPI device structure.
+ * @param[out] connection_id Pointer where to store the connection ID.
+ *
+ * @return SR_OK on success, SR_ERR on failure.
+ */
+SR_PRIV int sr_scpi_connection_id(struct sr_scpi_dev_inst *scpi,
+ char **connection_id)
+{
+ return scpi->connection_id(scpi, connection_id);
+}
+
/**
* Add an event source for an SCPI device.
*
scpi->free(scpi->priv);
g_free(scpi->priv);
+ g_free(scpi->actual_channel_name);
g_free(scpi);
}
/**
* Send a SCPI command, receive the reply and store the reply in scpi_response.
*
- * @param scpi Previously initialised SCPI device structure.
- * @param command The SCPI command to send to the device (can be NULL).
- * @param scpi_response Pointer where to store the SCPI response.
+ * Callers must free the allocated memory regardless of the routine's
+ * return code. See @ref g_free().
+ *
+ * @param[in] scpi Previously initialised SCPI device structure.
+ * @param[in] command The SCPI command to send to the device (can be NULL).
+ * @param[out] scpi_response Pointer where to store the SCPI response.
*
* @return SR_OK on success, SR_ERR* on failure.
*/
const char *command, char **scpi_response)
{
GString *response;
- response = g_string_sized_new(1024);
+ *scpi_response = NULL;
+
+ response = g_string_sized_new(1024);
if (sr_scpi_get_data(scpi, command, &response) != SR_OK) {
if (response)
g_string_free(response, TRUE);
const char *command, int *scpi_response)
{
int ret;
+ struct sr_rational ret_rational;
char *response;
response = NULL;
if (ret != SR_OK && !response)
return ret;
- if (sr_atoi(response, scpi_response) == SR_OK)
- ret = SR_OK;
- else
+ ret = sr_parse_rational(response, &ret_rational);
+ if (ret == SR_OK && (ret_rational.p % ret_rational.q) == 0) {
+ *scpi_response = ret_rational.p / ret_rational.q;
+ } else {
+ sr_dbg("get_int: non-integer rational=%" PRId64 "/%" PRIu64,
+ ret_rational.p, ret_rational.q);
ret = SR_ERR_DATA;
+ }
g_free(response);
* Send a SCPI command, read the reply, parse it as comma separated list of
* floats and store the as an result in scpi_response.
*
- * @param scpi Previously initialised SCPI device structure.
- * @param command The SCPI command to send to the device (can be NULL).
- * @param scpi_response Pointer where to store the parsed result.
+ * Callers must free the allocated memory (unless it's NULL) regardless of
+ * the routine's return code. See @ref g_array_free().
+ *
+ * @param[in] scpi Previously initialised SCPI device structure.
+ * @param[in] command The SCPI command to send to the device (can be NULL).
+ * @param[out] scpi_response Pointer where to store the parsed result.
*
* @return SR_OK upon successfully parsing all values, SR_ERR* upon a parsing
- * error or upon no response. The allocated response must be freed by
- * the caller in the case of an SR_OK as well as in the case of
- * parsing error.
+ * error or upon no response.
*/
SR_PRIV int sr_scpi_get_floatv(struct sr_scpi_dev_inst *scpi,
const char *command, GArray **scpi_response)
gchar **ptr, **tokens;
GArray *response_array;
+ *scpi_response = NULL;
response = NULL;
tokens = NULL;
if (ret != SR_OK && response_array->len == 0) {
g_array_free(response_array, TRUE);
- *scpi_response = NULL;
return SR_ERR_DATA;
}
* Send a SCPI command, read the reply, parse it as comma separated list of
* unsigned 8 bit integers and store the as an result in scpi_response.
*
- * @param scpi Previously initialised SCPI device structure.
- * @param command The SCPI command to send to the device (can be NULL).
- * @param scpi_response Pointer where to store the parsed result.
+ * Callers must free the allocated memory (unless it's NULL) regardless of
+ * the routine's return code. See @ref g_array_free().
+ *
+ * @param[in] scpi Previously initialised SCPI device structure.
+ * @param[in] command The SCPI command to send to the device (can be NULL).
+ * @param[out] scpi_response Pointer where to store the parsed result.
*
* @return SR_OK upon successfully parsing all values, SR_ERR* upon a parsing
- * error or upon no response. The allocated response must be freed by
- * the caller in the case of an SR_OK as well as in the case of
- * parsing error.
+ * error or upon no response.
*/
SR_PRIV int sr_scpi_get_uint8v(struct sr_scpi_dev_inst *scpi,
const char *command, GArray **scpi_response)
gchar **ptr, **tokens;
GArray *response_array;
+ *scpi_response = NULL;
response = NULL;
tokens = NULL;
if (response_array->len == 0) {
g_array_free(response_array, TRUE);
- *scpi_response = NULL;
return SR_ERR_DATA;
}
* Send a SCPI command, read the reply, parse it as binary data with a
* "definite length block" header and store the as an result in scpi_response.
*
- * @param scpi Previously initialised SCPI device structure.
- * @param command The SCPI command to send to the device (can be NULL).
- * @param scpi_response Pointer where to store the parsed result.
+ * Callers must free the allocated memory (unless it's NULL) regardless of
+ * the routine's return code. See @ref g_byte_array_free().
+ *
+ * @param[in] scpi Previously initialised SCPI device structure.
+ * @param[in] command The SCPI command to send to the device (can be NULL).
+ * @param[out] scpi_response Pointer where to store the parsed result.
*
* @return SR_OK upon successfully parsing all values, SR_ERR* upon a parsing
- * error or upon no response. The allocated response must be freed by
- * the caller in the case of an SR_OK as well as in the case of
- * parsing error.
+ * error or upon no response.
*/
SR_PRIV int sr_scpi_get_block(struct sr_scpi_dev_inst *scpi,
const char *command, GByteArray **scpi_response)
{
int ret;
GString* response;
+ gsize oldlen;
char buf[10];
long llen;
long datalen;
gint64 timeout;
- va_list empty_va_list;
+
+ *scpi_response = NULL;
g_mutex_lock(&scpi->scpi_mutex);
if (command)
- if (scpi_send(scpi, command, empty_va_list) != SR_OK) {
+ if (scpi_send(scpi, command) != SR_OK) {
g_mutex_unlock(&scpi->scpi_mutex);
return SR_ERR;
}
timeout = g_get_monotonic_time() + scpi->read_timeout_us;
- *scpi_response = NULL;
-
/* Get (the first chunk of) the response. */
- while (response->len < 2) {
+ do {
ret = scpi_read_response(scpi, response, timeout);
if (ret < 0) {
g_mutex_unlock(&scpi->scpi_mutex);
g_string_free(response, TRUE);
return ret;
}
- }
+ } while (response->len < 2);
/*
* SCPI protocol data blocks are preceeded with a length spec.
g_string_erase(response, 0, 2 + llen);
/*
- * If the initially assumed length does not cover the data block
- * length, then re-allocate the buffer size to the now known
- * length, and keep reading more chunks of response data.
+ * Re-allocate the buffer size to the now known length
+ * and keep reading more chunks of response data.
*/
- if (response->len < (unsigned long)(datalen)) {
- int oldlen = response->len;
- g_string_set_size(response, datalen);
- g_string_set_size(response, oldlen);
- }
-
- while (response->len < (unsigned long)(datalen)) {
- ret = scpi_read_response(scpi, response, timeout);
- if (ret < 0) {
- g_mutex_unlock(&scpi->scpi_mutex);
- g_string_free(response, TRUE);
- return ret;
- }
- if (ret > 0)
- timeout = g_get_monotonic_time() + scpi->read_timeout_us;
+ oldlen = response->len;
+ g_string_set_size(response, datalen);
+ g_string_set_size(response, oldlen);
+
+ if (oldlen < (unsigned long)(datalen)) {
+ do {
+ oldlen = response->len;
+ ret = scpi_read_response(scpi, response, timeout);
+
+ /* On timeout truncate the buffer and send the partial response
+ * instead of getting stuck on timeouts...
+ */
+ if (ret == SR_ERR_TIMEOUT) {
+ datalen = oldlen;
+ break;
+ }
+ if (ret < 0) {
+ g_mutex_unlock(&scpi->scpi_mutex);
+ g_string_free(response, TRUE);
+ return ret;
+ }
+ if (ret > 0)
+ timeout = g_get_monotonic_time() + scpi->read_timeout_us;
+ } while (response->len < (unsigned long)(datalen));
}
g_mutex_unlock(&scpi->scpi_mutex);
* Send the *IDN? SCPI command, receive the reply, parse it and store the
* reply as a sr_scpi_hw_info structure in the supplied scpi_response pointer.
*
- * The hw_info structure must be freed by the caller via sr_scpi_hw_info_free().
+ * Callers must free the allocated memory regardless of the routine's
+ * return code. See @ref sr_scpi_hw_info_free().
*
- * @param scpi Previously initialised SCPI device structure.
- * @param scpi_response Pointer where to store the hw_info structure.
+ * @param[in] scpi Previously initialised SCPI device structure.
+ * @param[out] scpi_response Pointer where to store the hw_info structure.
*
* @return SR_OK upon success, SR_ERR* on failure.
*/
struct sr_scpi_hw_info *hw_info;
gchar *idn_substr;
+ *scpi_response = NULL;
response = NULL;
tokens = NULL;
* The response to a '*IDN?' is specified by the SCPI spec. It contains
* a comma-separated list containing the manufacturer name, instrument
* model, serial number of the instrument and the firmware version.
+ *
+ * BEWARE! Although strictly speaking a smaller field count is invalid,
+ * this implementation also accepts IDN responses with one field less,
+ * and assumes that the serial number is missing. Some GWInstek DMMs
+ * were found to do this. Keep warning about this condition, which may
+ * need more consideration later.
*/
tokens = g_strsplit(response, ",", 0);
-
- for (num_tokens = 0; tokens[num_tokens] != NULL; num_tokens++);
-
- if (num_tokens < 4) {
- sr_dbg("IDN response not according to spec: %80.s.", response);
+ num_tokens = g_strv_length(tokens);
+ if (num_tokens < 3) {
+ sr_dbg("IDN response not according to spec: '%s'", response);
g_strfreev(tokens);
g_free(response);
return SR_ERR_DATA;
}
+ if (num_tokens < 4) {
+ sr_warn("Short IDN response, assume missing serial number.");
+ }
g_free(response);
hw_info = g_malloc0(sizeof(struct sr_scpi_hw_info));
hw_info->manufacturer = g_strstrip(g_strdup(idn_substr + 4));
hw_info->model = g_strstrip(g_strdup(tokens[1]));
- hw_info->serial_number = g_strstrip(g_strdup(tokens[2]));
- hw_info->firmware_version = g_strstrip(g_strdup(tokens[3]));
+ if (num_tokens < 4) {
+ hw_info->serial_number = g_strdup("Unknown");
+ hw_info->firmware_version = g_strstrip(g_strdup(tokens[2]));
+ } else {
+ hw_info->serial_number = g_strstrip(g_strdup(tokens[2]));
+ hw_info->firmware_version = g_strstrip(g_strdup(tokens[3]));
+ }
g_strfreev(tokens);
g_free(hw_info);
}
+/**
+ * Remove potentially enclosing pairs of quotes, un-escape content.
+ * This implementation modifies the caller's buffer when quotes are found
+ * and doubled quote characters need to get removed from the content.
+ *
+ * @param[in, out] s The SCPI string to check and un-quote.
+ *
+ * @return The start of the un-quoted string.
+ */
+SR_PRIV const char *sr_scpi_unquote_string(char *s)
+{
+ size_t s_len;
+ char quotes[3];
+ char *rdptr;
+
+ /* Immediately bail out on invalid or short input. */
+ if (!s || !*s)
+ return s;
+ s_len = strlen(s);
+ if (s_len < 2)
+ return s;
+
+ /* Check for matching quote characters front and back. */
+ if (s[0] != '\'' && s[0] != '"')
+ return s;
+ if (s[0] != s[s_len - 1])
+ return s;
+
+ /* Need to strip quotes, and un-double quote chars inside. */
+ quotes[0] = quotes[1] = *s;
+ quotes[2] = '\0';
+ s[s_len - 1] = '\0';
+ s++;
+ rdptr = s;
+ while ((rdptr = strstr(rdptr, quotes)) != NULL) {
+ memmove(rdptr, rdptr + 1, strlen(rdptr));
+ rdptr++;
+ }
+
+ return s;
+}
+
SR_PRIV const char *sr_vendor_alias(const char *raw_vendor)
{
unsigned int i;
return raw_vendor;
}
-SR_PRIV const char *sr_scpi_cmd_get(const struct scpi_command *cmdtable, int command)
+SR_PRIV const char *sr_scpi_cmd_get(const struct scpi_command *cmdtable,
+ int command)
{
unsigned int i;
const char *cmd;
return cmd;
}
-SR_PRIV int sr_scpi_cmd(const struct sr_dev_inst *sdi, const struct scpi_command *cmdtable,
+SR_PRIV int sr_scpi_cmd(const struct sr_dev_inst *sdi,
+ const struct scpi_command *cmdtable,
+ int channel_command, const char *channel_name,
int command, ...)
{
struct sr_scpi_dev_inst *scpi;
va_list args;
int ret;
+ const char *channel_cmd;
const char *cmd;
+ scpi = sdi->conn;
+
if (!(cmd = sr_scpi_cmd_get(cmdtable, command))) {
/* Device does not implement this command, that's OK. */
return SR_OK;
}
- scpi = sdi->conn;
+ g_mutex_lock(&scpi->scpi_mutex);
+
+ /* Select channel. */
+ channel_cmd = sr_scpi_cmd_get(cmdtable, channel_command);
+ if (channel_cmd && channel_name &&
+ g_strcmp0(channel_name, scpi->actual_channel_name)) {
+ sr_spew("sr_scpi_cmd(): new channel = %s", channel_name);
+ g_free(scpi->actual_channel_name);
+ scpi->actual_channel_name = g_strdup(channel_name);
+ ret = scpi_send(scpi, channel_cmd, channel_name);
+ if (ret != SR_OK)
+ return ret;
+ }
+
va_start(args, command);
- ret = sr_scpi_send_variadic(scpi, cmd, args);
+ ret = scpi_send_variadic(scpi, cmd, args);
va_end(args);
+ g_mutex_unlock(&scpi->scpi_mutex);
+
return ret;
}
SR_PRIV int sr_scpi_cmd_resp(const struct sr_dev_inst *sdi,
const struct scpi_command *cmdtable,
+ int channel_command, const char *channel_name,
GVariant **gvar, const GVariantType *gvtype, int command, ...)
{
struct sr_scpi_dev_inst *scpi;
va_list args;
+ const char *channel_cmd;
const char *cmd;
GString *response;
char *s;
g_mutex_lock(&scpi->scpi_mutex);
+ /* Select channel. */
+ channel_cmd = sr_scpi_cmd_get(cmdtable, channel_command);
+ if (channel_cmd && channel_name &&
+ g_strcmp0(channel_name, scpi->actual_channel_name)) {
+ sr_spew("sr_scpi_cmd_get(): new channel = %s", channel_name);
+ g_free(scpi->actual_channel_name);
+ scpi->actual_channel_name = g_strdup(channel_name);
+ ret = scpi_send(scpi, channel_cmd, channel_name);
+ if (ret != SR_OK)
+ return ret;
+ }
+
va_start(args, command);
ret = scpi_send_variadic(scpi, cmd, args);
va_end(args);
projects / libsigrok.git / blobdiff