X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;f=src%2Fscpi%2Fscpi.c;h=a3a16ebd382e3ef92807709dda601c56206763ab;hb=9e50659470cb7a34fddeaf27a73a07e5f15e933d;hp=e4346e5db6d3fef19360e24367f291dd45f7b789;hpb=d9251a2c9f1ca4380c27240ccca90c9f9ed46d3f;p=libsigrok.git diff --git a/src/scpi/scpi.c b/src/scpi/scpi.c index e4346e5d..a3a16ebd 100644 --- a/src/scpi/scpi.c +++ b/src/scpi/scpi.c @@ -190,7 +190,7 @@ SR_PRIV struct sr_scpi_dev_inst *scpi_dev_inst_new(struct drv_context *drvc, scpi = g_malloc(sizeof(*scpi)); *scpi = *scpi_dev; scpi->priv = g_malloc0(scpi->priv_size); - scpi->read_timeout_ms = 1000; + scpi->read_timeout_us = 1000 * 1000; params = g_strsplit(resource, "/", 0); if (scpi->dev_inst_new(scpi->priv, drvc, resource, params, serialcomm) != SR_OK) { @@ -412,49 +412,81 @@ SR_PRIV int sr_scpi_get_string(struct sr_scpi_dev_inst *scpi, return SR_OK; } +/** + * Do a non-blocking read of up to the allocated length, and + * check if a timeout has occured. + * + * @param scpi Previously initialised SCPI device structure. + * @param response Buffer to which the response is appended. + * @param abs_timeout_us Absolute timeout in microseconds + * + * @return read length on success, SR_ERR* on failure. + */ +SR_PRIV int sr_scpi_read_response(struct sr_scpi_dev_inst *scpi, + GString *response, gint64 abs_timeout_us) +{ + int len, space; + + space = response->allocated_len - response->len; + len = sr_scpi_read_data(scpi, &response->str[response->len], space); + + if (len < 0) { + sr_err("Incompletely read SCPI response."); + return SR_ERR; + } + + if (len > 0) { + g_string_set_size(response, response->len + len); + return len; + } + + if (g_get_monotonic_time() > abs_timeout_us) { + sr_err("Timed out waiting for SCPI response."); + return SR_ERR_TIMEOUT; + } + + return 0; +} + SR_PRIV int sr_scpi_get_data(struct sr_scpi_dev_inst *scpi, const char *command, GString **scpi_response) { - int len; + int ret; GString *response; - gint64 laststart; - unsigned int elapsed_ms; - unsigned int offset = 0; int space; + gint64 timeout; - if (command) + /* Optionally send caller provided command. */ + if (command) { if (sr_scpi_send(scpi, command) != SR_OK) return SR_ERR; + } + /* Initiate SCPI read operation. */ if (sr_scpi_read_begin(scpi) != SR_OK) return SR_ERR; - laststart = g_get_monotonic_time(); + /* Keep reading until completion or until timeout. */ + timeout = g_get_monotonic_time() + scpi->read_timeout_us; response = *scpi_response; - offset = response->len; - while (!sr_scpi_read_complete(scpi)) { + /* Resize the buffer when free space drops below a threshold. */ space = response->allocated_len - response->len; if (space < 128) { - g_string_set_size(response, response->len + 1024); - space = response->allocated_len - response->len; - } - len = sr_scpi_read_data(scpi, &response->str[offset], space); - if (len < 0) { - sr_err("Incompletely read SCPI response."); - return SR_ERR; - } else if (len > 0) { - laststart = g_get_monotonic_time(); - } - offset += len; - g_string_set_size(response, offset); - elapsed_ms = (g_get_monotonic_time() - laststart) / 1000; - if (elapsed_ms >= scpi->read_timeout_ms) { - sr_err("Timed out waiting for SCPI response."); - return SR_ERR; + int oldlen = response->len; + g_string_set_size(response, oldlen + 1024); + g_string_set_size(response, oldlen); } + + /* Read another chunk of the response. */ + ret = sr_scpi_read_response(scpi, response, timeout); + + if (ret < 0) + return ret; + if (ret > 0) + timeout = g_get_monotonic_time() + scpi->read_timeout_us; } return SR_OK; @@ -723,6 +755,7 @@ SR_PRIV int sr_scpi_get_uint8v(struct sr_scpi_dev_inst *scpi, return ret; } + /** * 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. @@ -741,42 +774,82 @@ SR_PRIV int sr_scpi_get_block(struct sr_scpi_dev_inst *scpi, { int ret; GString* response; - - char buf[10] = { 0 }; + char buf[10]; long llen; long datalen; + gint64 timeout; + if (command) + if (sr_scpi_send(scpi, command) != SR_OK) + return SR_ERR; + + if (sr_scpi_read_begin(scpi) != SR_OK) + return SR_ERR; + + /* + * Assume an initial maximum length, optionally gets adjusted below. + * Prepare a NULL return value for when error paths will be taken. + */ response = g_string_sized_new(1024); + + timeout = g_get_monotonic_time() + scpi->read_timeout_us; + *scpi_response = NULL; - ret = sr_scpi_get_data(scpi, command, &response); - if (ret != SR_OK) { - g_string_free(response, TRUE); - return ret; + /* Get (the first chunk of) the response. */ + while (response->len < 2) { + ret = sr_scpi_read_response(scpi, response, timeout); + if (ret < 0) { + g_string_free(response, TRUE); + return ret; + } } + /* + * SCPI protocol data blocks are preceeded with a length spec. + * The length spec consists of a '#' marker, one digit which + * specifies the character count of the length spec, and the + * respective number of characters which specify the data block's + * length. Raw data bytes follow (thus one must no longer assume + * that the received input stream would be an ASCIIZ string). + * + * Get the data block length, and strip off the length spec from + * the input buffer, leaving just the data bytes. + */ if (response->str[0] != '#') { g_string_free(response, TRUE); return SR_ERR_DATA; } - buf[0] = response->str[1]; + buf[1] = '\0'; ret = sr_atol(buf, &llen); if ((ret != SR_OK) || (llen == 0)) { g_string_free(response, TRUE); return ret; } + while (response->len < (unsigned long)(2 + llen)) { + ret = sr_scpi_read_response(scpi, response, timeout); + if (ret < 0) { + g_string_free(response, TRUE); + return ret; + } + } + memcpy(buf, &response->str[2], llen); + buf[llen] = '\0'; ret = sr_atol(buf, &datalen); if ((ret != SR_OK) || (datalen == 0)) { g_string_free(response, TRUE); return ret; } - - // strip header 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. + */ if (response->len < (unsigned long)(datalen)) { int oldlen = response->len; g_string_set_size(response, datalen); @@ -784,19 +857,22 @@ SR_PRIV int sr_scpi_get_block(struct sr_scpi_dev_inst *scpi, } while (response->len < (unsigned long)(datalen)) { - if (sr_scpi_get_data(scpi, NULL, &response) != SR_OK) { + ret = sr_scpi_read_response(scpi, response, timeout); + if (ret < 0) { g_string_free(response, TRUE); return ret; } + if (ret > 0) + timeout = g_get_monotonic_time() + scpi->read_timeout_us; } + /* Convert received data to byte array. */ *scpi_response = g_byte_array_new_take( (guint8*)g_string_free(response, FALSE), datalen); - return ret; + return SR_OK; } - /** * 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.