#include <glib.h>
#include <string.h>
-/* Message logging helpers with subsystem-specific prefix string. */
-#define LOG_PREFIX "scpi: "
-#define sr_log(l, s, args...) sr_log(l, LOG_PREFIX s, ## args)
-#define sr_spew(s, args...) sr_spew(LOG_PREFIX s, ## args)
-#define sr_dbg(s, args...) sr_dbg(LOG_PREFIX s, ## args)
-#define sr_info(s, args...) sr_info(LOG_PREFIX s, ## args)
-#define sr_warn(s, args...) sr_warn(LOG_PREFIX s, ## args)
+#define LOG_PREFIX "scpi"
#define SCPI_READ_RETRIES 100
#define SCPI_READ_RETRY_TIMEOUT 10000
*
* @return SR_OK on success, SR_ERR on failure.
*/
-static int sr_parse_strict_bool(const char *str, gboolean *ret)
+static int parse_strict_bool(const char *str, gboolean *ret)
{
if (!str)
return SR_ERR_ARG;
!g_ascii_strncasecmp(str, "yes", 3) ||
!g_ascii_strncasecmp(str, "true", 4) ||
!g_ascii_strncasecmp(str, "on", 2)) {
-
*ret = TRUE;
return SR_OK;
-
} else if (!g_strcmp0(str, "0") ||
!g_ascii_strncasecmp(str, "n", 1) ||
!g_ascii_strncasecmp(str, "f", 1) ||
!g_ascii_strncasecmp(str, "no", 2) ||
!g_ascii_strncasecmp(str, "false", 5) ||
!g_ascii_strncasecmp(str, "off", 3)) {
-
*ret = FALSE;
return SR_OK;
}
}
/**
- * Send a SCPI command.
+ * Open SCPI device.
*
- * @param serial Previously initialized serial port structure.
- * @param command The SCPI command to send to the device.
+ * @param scpi Previously initialized SCPI device structure.
*
* @return SR_OK on success, SR_ERR on failure.
*/
-SR_PRIV int sr_scpi_send(struct sr_serial_dev_inst *serial,
- const char *command)
+SR_PRIV int sr_scpi_open(struct sr_scpi_dev_inst *scpi)
{
- int len;
- int out;
- gchar *terminated_command;
-
- terminated_command = g_strconcat(command, "\n", NULL);
- len = strlen(terminated_command);
+ return scpi->open(scpi->priv);
+}
- out = serial_write(serial, terminated_command,
- strlen(terminated_command));
+/**
+ * Add an event source for an SCPI device.
+ *
+ * @param scpi Previously initialized SCPI device structure.
+ * @param events Events to check for.
+ * @param timeout Max time to wait before the callback is called, ignored if 0.
+ * @param cb Callback function to add. Must not be NULL.
+ * @param cb_data Data for the callback function. Can be NULL.
+ *
+ * @return SR_OK upon success, SR_ERR_ARG upon invalid arguments, or
+ * SR_ERR_MALLOC upon memory allocation errors.
+ */
+SR_PRIV int sr_scpi_source_add(struct sr_scpi_dev_inst *scpi, int events,
+ int timeout, sr_receive_data_callback_t cb, void *cb_data)
+{
+ return scpi->source_add(scpi->priv, events, timeout, cb, cb_data);
+}
- g_free(terminated_command);
+/**
+ * Remove event source for an SCPI device.
+ *
+ * @param scpi Previously initialized SCPI device structure.
+ *
+ * @return SR_OK upon success, SR_ERR_ARG upon invalid arguments, or
+ * SR_ERR_MALLOC upon memory allocation errors, SR_ERR_BUG upon
+ * internal errors.
+ */
+SR_PRIV int sr_scpi_source_remove(struct sr_scpi_dev_inst *scpi)
+{
+ return scpi->source_remove(scpi->priv);
+}
- if (out != len) {
- sr_dbg("Only sent %d/%d bytes of SCPI command: '%s'.", out,
- len, command);
- return SR_ERR;
- }
+/**
+ * Send a SCPI command.
+ *
+ * @param scpi Previously initialized SCPI device structure.
+ * @param format Format string, to be followed by any necessary arguments.
+ *
+ * @return SR_OK on success, SR_ERR on failure.
+ */
+SR_PRIV int sr_scpi_send(struct sr_scpi_dev_inst *scpi,
+ const char *format, ...)
+{
+ va_list args;
+ int ret;
- sr_spew("Successfully sent SCPI command: '%s'.", command);
+ va_start(args, format);
+ ret = sr_scpi_send_variadic(scpi, format, args);
+ va_end(args);
- return SR_OK;
+ return ret;
}
/**
- * Send a SCPI command, receive the reply and store the reply in scpi_response.
+ * Send a SCPI command with a variadic argument list.
*
- * @param serial Previously initialized serial port structure.
- * @param command The SCPI command to send to the device (can be NULL).
- * @param scpi_response Pointer where to store the scpi response.
+ * @param scpi Previously initialized SCPI device structure.
+ * @param format Format string.
+ * @param args Argument list.
*
- * @return SR_OK upon fetching a full SCPI response, SR_ERR upon fetching a
- * incomplete or no response. The allocated response must be freed by the caller
- * in the case of a full response as well in the case of an incomplete.
+ * @return SR_OK on success, SR_ERR on failure.
*/
-SR_PRIV int sr_scpi_get_string(struct sr_serial_dev_inst *serial,
- const char *command, char **scpi_response)
+SR_PRIV int sr_scpi_send_variadic(struct sr_scpi_dev_inst *scpi,
+ const char *format, va_list args)
{
- int len;
- int ret;
- char buf[256];
- unsigned int i;
- GString *response;
-
- if (command)
- if (sr_scpi_send(serial, command) != SR_OK)
- return SR_ERR;
+ va_list args_copy;
+ char *buf;
+ int len, ret;
- response = g_string_sized_new(1024);
+ /* Get length of buffer required. */
+ va_copy(args_copy, args);
+ len = vsnprintf(NULL, 0, format, args_copy);
+ va_end(args_copy);
- for (i = 0; i <= SCPI_READ_RETRIES; i++) {
- while ((len = serial_read(serial, buf, sizeof(buf))) > 0)
- response = g_string_append_len(response, buf, len);
+ /* Allocate buffer and write out command. */
+ buf = g_malloc(len + 1);
+ vsprintf(buf, format, args);
- if (response->len > 0 &&
- response->str[response->len-1] == '\n') {
- sr_spew("Fetched full SCPI response");
- break;
- }
+ /* Send command. */
+ ret = scpi->send(scpi->priv, buf);
- g_usleep(SCPI_READ_RETRY_TIMEOUT);
- }
+ /* Free command buffer. */
+ g_free(buf);
- if (response->len == 0) {
- sr_dbg("No SCPI response received");
- g_string_free(response, TRUE);
- *scpi_response = NULL;
- return SR_ERR;
+ return ret;
+}
- } else if (response->str[response->len-1] == '\n') {
- /*
- * The SCPI response contains a LF ('\n') at the end and we
- * don't need this so replace it with a '\0' and decrement
- * the length.
- */
- response->str[--response->len] = '\0';
- ret = SR_OK;
+/**
+ * Receive an SCPI reply and store the reply in scpi_response.
+ *
+ * @param scpi Previously initialised SCPI device structure.
+ * @param scpi_response Pointer where to store the SCPI response.
+ *
+ * @return SR_OK upon fetching a full SCPI response, SR_ERR upon fetching an
+ * incomplete or no response. The allocated response must be freed by
+ * the caller in the case of a full response as well in the case of
+ * an incomplete.
+ */
+SR_PRIV int sr_scpi_receive(struct sr_scpi_dev_inst *scpi,
+ char **scpi_response)
+{
+ return scpi->receive(scpi->priv, scpi_response);
+}
- } else {
- sr_warn("Incomplete SCPI response received!");
- ret = SR_ERR;
- }
+/**
+ * Read part of a response from SCPI device.
+ *
+ * @param scpi Previously initialised SCPI device structure.
+ * @param buf Buffer to store result.
+ * @param maxlen Maximum number of bytes to read.
+ *
+ * @return Number of bytes read, or SR_ERR upon failure.
+ */
+SR_PRIV int sr_scpi_read(struct sr_scpi_dev_inst *scpi,
+ char *buf, int maxlen)
+{
+ return scpi->read(scpi->priv, buf, maxlen);
+}
- /* Minor optimization: steal the string instead of copying. */
- *scpi_response = response->str;
+/**
+ * Close SCPI device.
+ *
+ * @param scpi Previously initialized SCPI device structure.
+ *
+ * @return SR_OK on success, SR_ERR on failure.
+ */
+SR_PRIV int sr_scpi_close(struct sr_scpi_dev_inst *scpi)
+{
+ return scpi->close(scpi->priv);
+}
- /* A SCPI response can be quite large, print at most 50 characters */
- sr_dbg("SCPI response for command %s received (length %d): '%.50s'",
- command, response->len, response->str);
+/**
+ * Free SCPI device.
+ *
+ * @param scpi Previously initialized SCPI device structure.
+ *
+ * @return SR_OK on success, SR_ERR on failure.
+ */
+SR_PRIV void sr_scpi_free(struct sr_scpi_dev_inst *scpi)
+{
+ scpi->free(scpi->priv);
+ g_free(scpi);
+}
- g_string_free(response, FALSE);
+/**
+ * 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.
+ *
+ * @return SR_OK upon fetching a full SCPI response, SR_ERR upon fetching an
+ * incomplete or no response. The allocated response must be freed by
+ * the caller in the case of a full response as well in the case of
+ * an incomplete.
+ */
+SR_PRIV int sr_scpi_get_string(struct sr_scpi_dev_inst *scpi,
+ const char *command, char **scpi_response)
+{
+ if (command)
+ if (sr_scpi_send(scpi, command) != SR_OK)
+ return SR_ERR;
- return ret;
+ return sr_scpi_receive(scpi, scpi_response);
}
/**
* Send a SCPI command, read the reply, parse it as a bool value and store the
* result in scpi_response.
*
- * @param serial Previously initialized serial port structure.
+ * @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.
*
* @return SR_OK on success, SR_ERR on failure.
*/
-SR_PRIV int sr_scpi_get_bool(struct sr_serial_dev_inst *serial,
+SR_PRIV int sr_scpi_get_bool(struct sr_scpi_dev_inst *scpi,
const char *command, gboolean *scpi_response)
{
int ret;
response = NULL;
- if (sr_scpi_get_string(serial, command, &response) != SR_OK)
+ if (sr_scpi_get_string(scpi, command, &response) != SR_OK)
if (!response)
return SR_ERR;
- if (sr_parse_strict_bool(response, scpi_response) == SR_OK)
+ if (parse_strict_bool(response, scpi_response) == SR_OK)
ret = SR_OK;
else
ret = SR_ERR;
* Send a SCPI command, read the reply, parse it as an integer and store the
* result in scpi_response.
*
- * @param serial Previously initialized serial port structure.
+ * @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.
*
* @return SR_OK on success, SR_ERR on failure.
*/
-SR_PRIV int sr_scpi_get_int(struct sr_serial_dev_inst *serial,
- const char *command, int *scpi_response)
+SR_PRIV int sr_scpi_get_int(struct sr_scpi_dev_inst *scpi,
+ const char *command, int *scpi_response)
{
int ret;
char *response;
response = NULL;
- if (sr_scpi_get_string(serial, command, &response) != SR_OK)
+ if (sr_scpi_get_string(scpi, command, &response) != SR_OK)
if (!response)
return SR_ERR;
* Send a SCPI command, read the reply, parse it as a float and store the
* result in scpi_response.
*
- * @param serial Previously initialized serial port structure.
+ * @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.
*
* @return SR_OK on success, SR_ERR on failure.
*/
-SR_PRIV int sr_scpi_get_float(struct sr_serial_dev_inst *serial,
+SR_PRIV int sr_scpi_get_float(struct sr_scpi_dev_inst *scpi,
const char *command, float *scpi_response)
{
int ret;
response = NULL;
- if (sr_scpi_get_string(serial, command, &response) != SR_OK)
+ if (sr_scpi_get_string(scpi, command, &response) != SR_OK)
if (!response)
return SR_ERR;
* Send a SCPI command, read the reply, parse it as a double and store the
* result in scpi_response.
*
- * @param serial Previously initialized serial port structure.
+ * @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.
*
* @return SR_OK on success, SR_ERR on failure.
*/
-SR_PRIV int sr_scpi_get_double(struct sr_serial_dev_inst *serial,
- const char *command, double *scpi_response)
+SR_PRIV int sr_scpi_get_double(struct sr_scpi_dev_inst *scpi,
+ const char *command, double *scpi_response)
{
int ret;
char *response;
response = NULL;
- if (sr_scpi_get_string(serial, command, &response) != SR_OK)
+ if (sr_scpi_get_string(scpi, command, &response) != SR_OK)
if (!response)
return SR_ERR;
return ret;
}
+/**
+ * Send a SCPI *OPC? command, read the reply and return the result of the
+ * command.
+ *
+ * @param scpi Previously initialised SCPI device structure.
+ *
+ * @return SR_OK on success, SR_ERR on failure.
+ */
+SR_PRIV int sr_scpi_get_opc(struct sr_scpi_dev_inst *scpi)
+{
+ unsigned int i;
+ gboolean opc;
+
+ for (i = 0; i < SCPI_READ_RETRIES; ++i) {
+ sr_scpi_get_bool(scpi, SCPI_CMD_OPC, &opc);
+ if (opc)
+ return SR_OK;
+ g_usleep(SCPI_READ_RETRY_TIMEOUT);
+ }
+
+ return SR_ERR;
+}
+
+/**
+ * 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.
+ *
+ * @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.
+ */
+SR_PRIV int sr_scpi_get_floatv(struct sr_scpi_dev_inst *scpi,
+ const char *command, GArray **scpi_response)
+{
+ int ret;
+ float tmp;
+ char *response;
+ gchar **ptr, **tokens;
+ GArray *response_array;
+
+ ret = SR_OK;
+ response = NULL;
+ tokens = NULL;
+
+ if (sr_scpi_get_string(scpi, command, &response) != SR_OK)
+ if (!response)
+ return SR_ERR;
+
+ tokens = g_strsplit(response, ",", 0);
+ ptr = tokens;
+
+ response_array = g_array_sized_new(TRUE, FALSE, sizeof(float), 256);
+
+ while (*ptr) {
+ if (sr_atof(*ptr, &tmp) == SR_OK)
+ response_array = g_array_append_val(response_array,
+ tmp);
+ else
+ ret = SR_ERR;
+
+ ptr++;
+ }
+ g_strfreev(tokens);
+ g_free(response);
+
+ if (ret == SR_ERR && response_array->len == 0) {
+ g_array_free(response_array, TRUE);
+ *scpi_response = NULL;
+ return SR_ERR;
+ }
+
+ *scpi_response = response_array;
+
+ return ret;
+}
+
+/**
+ * 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.
+ *
+ * @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.
+ */
+SR_PRIV int sr_scpi_get_uint8v(struct sr_scpi_dev_inst *scpi,
+ const char *command, GArray **scpi_response)
+{
+ int tmp, ret;
+ char *response;
+ gchar **ptr, **tokens;
+ GArray *response_array;
+
+ ret = SR_OK;
+ response = NULL;
+ tokens = NULL;
+
+ if (sr_scpi_get_string(scpi, command, &response) != SR_OK)
+ if (!response)
+ return SR_ERR;
+
+ tokens = g_strsplit(response, ",", 0);
+ ptr = tokens;
+
+ response_array = g_array_sized_new(TRUE, FALSE, sizeof(uint8_t), 256);
+
+ while (*ptr) {
+ if (sr_atoi(*ptr, &tmp) == SR_OK)
+ response_array = g_array_append_val(response_array,
+ tmp);
+ else
+ ret = SR_ERR;
+
+ ptr++;
+ }
+ g_strfreev(tokens);
+ g_free(response);
+
+ if (response_array->len == 0) {
+ g_array_free(response_array, TRUE);
+ *scpi_response = NULL;
+ return SR_ERR;
+ }
+
+ *scpi_response = response_array;
+
+ return ret;
+}
+
/**
* 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.
*
- * @param serial Previously initialized serial port structure.
+ * The hw_info structure must be freed by the caller via sr_scpi_hw_info_free().
+ *
+ * @param scpi Previously initialised SCPI device structure.
* @param scpi_response Pointer where to store the hw_info structure.
*
* @return SR_OK upon success, SR_ERR on failure.
- * The hw_info structure must be freed by the caller with sr_scpi_hw_info_free().
*/
-SR_PRIV int sr_scpi_get_hw_id(struct sr_serial_dev_inst *serial,
+SR_PRIV int sr_scpi_get_hw_id(struct sr_scpi_dev_inst *scpi,
struct sr_scpi_hw_info **scpi_response)
{
int num_tokens;
char *response;
gchar **tokens;
-
struct sr_scpi_hw_info *hw_info;
response = NULL;
tokens = NULL;
- if (sr_scpi_get_string(serial, SCPI_CMD_IDN, &response) != SR_OK)
+ if (sr_scpi_get_string(scpi, SCPI_CMD_IDN, &response) != SR_OK)
if (!response)
return SR_ERR;
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);
+ sr_dbg("IDN response not according to spec: %80.s.", response);
g_strfreev(tokens);
g_free(response);
return SR_ERR;
projects / libsigrok.git / blobdiff